Gordons Projects

--> Projects Top-Level GIT

Quite a few changes here.
[wiringPi] / wiringPi / wiringPi.c
1 /*
2  * wiringPi:
3  *      Arduino compatable (ish) Wiring library for the Raspberry Pi
4  *      Copyright (c) 2012 Gordon Henderson
5  *      Additional code for pwmSetClock by Chris Hall <chris@kchall.plus.com>
6  *
7  *      Thanks to code samples from Gert Jan van Loo and the
8  *      BCM2835 ARM Peripherals manual, however it's missing
9  *      the clock section /grr/mutter/
10  ***********************************************************************
11  * This file is part of wiringPi:
12  *      https://projects.drogon.net/raspberry-pi/wiringpi/
13  *
14  *    wiringPi is free software: you can redistribute it and/or modify
15  *    it under the terms of the GNU Lesser General Public License as
16  *    published by the Free Software Foundation, either version 3 of the
17  *    License, or (at your option) any later version.
18  *
19  *    wiringPi is distributed in the hope that it will be useful,
20  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
21  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  *    GNU Lesser General Public License for more details.
23  *
24  *    You should have received a copy of the GNU Lesser General Public
25  *    License along with wiringPi.
26  *    If not, see <http://www.gnu.org/licenses/>.
27  ***********************************************************************
28  */
29
30 // Revisions:
31 //      19 Jul 2012:
32 //              Moved to the LGPL
33 //              Added an abstraction layer to the main routines to save a tiny
34 //              bit of run-time and make the clode a little cleaner (if a little
35 //              larger)
36 //              Added waitForInterrupt code
37 //              Added piHiPri code
38 //
39 //       9 Jul 2012:
40 //              Added in support to use the /sys/class/gpio interface.
41 //       2 Jul 2012:
42 //              Fixed a few more bugs to do with range-checking when in GPIO mode.
43 //      11 Jun 2012:
44 //              Fixed some typos.
45 //              Added c++ support for the .h file
46 //              Added a new function to allow for using my "pin" numbers, or native
47 //                      GPIO pin numbers.
48 //              Removed my busy-loop delay and replaced it with a call to delayMicroseconds
49 //
50 //      02 May 2012:
51 //              Added in the 2 UART pins
52 //              Change maxPins to numPins to more accurately reflect purpose
53
54
55 #include <stdio.h>
56 #include <stdint.h>
57 #include <stdlib.h>
58 #include <ctype.h>
59 #include <poll.h>
60 #include <unistd.h>
61 #include <errno.h>
62 #include <string.h>
63 #include <time.h>
64 #include <fcntl.h>
65 #include <pthread.h>
66 #include <sys/time.h>
67 #include <sys/mman.h>
68 #include <sys/stat.h>
69 #include <sys/wait.h>
70 #include <sys/ioctl.h>
71
72 #include "wiringPi.h"
73
74 // Function stubs
75
76 void (*pinMode)           (int pin, int mode) ;
77 int  (*getAlt)            (int pin) ;
78 void (*pullUpDnControl)   (int pin, int pud) ;
79 void (*digitalWrite)      (int pin, int value) ;
80 void (*digitalWriteByte)  (int value) ;
81 void (*pwmWrite)          (int pin, int value) ;
82 void (*setPadDrive)       (int group, int value) ;
83 int  (*digitalRead)       (int pin) ;
84 int  (*waitForInterrupt)  (int pin, int mS) ;
85 void (*pwmSetMode)        (int mode) ;
86 void (*pwmSetRange)       (unsigned int range) ;
87 void (*pwmSetClock)       (int divisor) ;
88
89
90 #ifndef TRUE
91 #define TRUE    (1==1)
92 #define FALSE   (1==2)
93 #endif
94
95 // BCM Magic
96
97 #define BCM_PASSWORD            0x5A000000
98
99
100 // Port function select bits
101
102 #define FSEL_INPT               0b000
103 #define FSEL_OUTP               0b001
104 #define FSEL_ALT0               0b100
105 #define FSEL_ALT0               0b100
106 #define FSEL_ALT1               0b101
107 #define FSEL_ALT2               0b110
108 #define FSEL_ALT3               0b111
109 #define FSEL_ALT4               0b011
110 #define FSEL_ALT5               0b010
111
112 // Access from ARM Running Linux
113 //      Take from Gert/Doms code. Some of this is not in the manual
114 //      that I can find )-:
115
116 #define BCM2708_PERI_BASE                          0x20000000
117 #define GPIO_PADS               (BCM2708_PERI_BASE + 0x100000)
118 #define CLOCK_BASE              (BCM2708_PERI_BASE + 0x101000)
119 #define GPIO_BASE               (BCM2708_PERI_BASE + 0x200000)
120 #define GPIO_TIMER              (BCM2708_PERI_BASE + 0x00B000)
121 #define GPIO_PWM                (BCM2708_PERI_BASE + 0x20C000)
122
123 #define PAGE_SIZE               (4*1024)
124 #define BLOCK_SIZE              (4*1024)
125
126 // PWM
127
128 #define PWM_CONTROL 0
129 #define PWM_STATUS  1
130 #define PWM0_RANGE  4
131 #define PWM0_DATA   5
132 #define PWM1_RANGE  8
133 #define PWM1_DATA   9
134
135 #define PWMCLK_CNTL     40
136 #define PWMCLK_DIV      41
137
138 #define PWM1_MS_MODE    0x8000  // Run in MS mode
139 #define PWM1_USEFIFO    0x2000  // Data from FIFO
140 #define PWM1_REVPOLAR   0x1000  // Reverse polarity
141 #define PWM1_OFFSTATE   0x0800  // Ouput Off state
142 #define PWM1_REPEATFF   0x0400  // Repeat last value if FIFO empty
143 #define PWM1_SERIAL     0x0200  // Run in serial mode
144 #define PWM1_ENABLE     0x0100  // Channel Enable
145
146 #define PWM0_MS_MODE    0x0080  // Run in MS mode
147 #define PWM0_USEFIFO    0x0020  // Data from FIFO
148 #define PWM0_REVPOLAR   0x0010  // Reverse polarity
149 #define PWM0_OFFSTATE   0x0008  // Ouput Off state
150 #define PWM0_REPEATFF   0x0004  // Repeat last value if FIFO empty
151 #define PWM0_SERIAL     0x0002  // Run in serial mode
152 #define PWM0_ENABLE     0x0001  // Channel Enable
153
154 // Timer
155
156 #define TIMER_LOAD      (0x400 >> 2)
157 #define TIMER_VALUE     (0x404 >> 2)
158 #define TIMER_CONTROL   (0x408 >> 2)
159 #define TIMER_IRQ_CLR   (0x40C >> 2)
160 #define TIMER_IRQ_RAW   (0x410 >> 2)
161 #define TIMER_IRQ_MASK  (0x414 >> 2)
162 #define TIMER_RELOAD    (0x418 >> 2)
163 #define TIMER_PRE_DIV   (0x41C >> 2)
164 #define TIMER_COUNTER   (0x420 >> 2)
165
166 // Locals to hold pointers to the hardware
167
168 static volatile uint32_t *gpio ;
169 static volatile uint32_t *pwm ;
170 static volatile uint32_t *clk ;
171 static volatile uint32_t *pads ;
172 static volatile uint32_t *timer ;
173 static volatile uint32_t *timerIrqRaw ;
174
175 // Time for easy calculations
176
177 static uint64_t epochMilli, epochMicro ;
178
179 // Misc
180
181 static int wiringPiMode = WPI_MODE_UNINITIALISED ;
182
183 // Debugging
184
185 int wiringPiDebug = FALSE ;
186
187 // The BCM2835 has 54 GPIO pins.
188 //      BCM2835 data sheet, Page 90 onwards.
189 //      There are 6 control registers, each control the functions of a block
190 //      of 10 pins.
191 //      Each control register has 10 sets of 3 bits per GPIO pin:
192 //
193 //      000 = GPIO Pin X is an input
194 //      001 = GPIO Pin X is an output
195 //      100 = GPIO Pin X takes alternate function 0
196 //      101 = GPIO Pin X takes alternate function 1
197 //      110 = GPIO Pin X takes alternate function 2
198 //      111 = GPIO Pin X takes alternate function 3
199 //      011 = GPIO Pin X takes alternate function 4
200 //      010 = GPIO Pin X takes alternate function 5
201 //
202 // So the 3 bits for port X are:
203 //      X / 10 + ((X % 10) * 3)
204
205 // sysFds:
206 //      Map a file descriptor from the /sys/class/gpio/gpioX/value
207
208 static int sysFds [64] ;
209
210 // ISR Data
211
212 static void (*isrFunctions [64])(void) ;
213
214
215 // Doing it the Arduino way with lookup tables...
216 //      Yes, it's probably more innefficient than all the bit-twidling, but it
217 //      does tend to make it all a bit clearer. At least to me!
218
219 // pinToGpio:
220 //      Take a Wiring pin (0 through X) and re-map it to the BCM_GPIO pin
221 //      Cope for 2 different board revieions here
222
223 static int *pinToGpio ;
224
225 static int pinToGpioR1 [64] =
226 {
227   17, 18, 21, 22, 23, 24, 25, 4,        // From the Original Wiki - GPIO 0 through 7
228    0,  1,                               // I2C  - SDA0, SCL0
229    8,  7,                               // SPI  - CE1, CE0
230   10,  9, 11,                           // SPI  - MOSI, MISO, SCLK
231   14, 15,                               // UART - Tx, Rx
232
233 // Padding:
234
235       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 31
236   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
237   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
238 } ;
239
240 static int pinToGpioR2 [64] =
241 {
242   17, 18, 27, 22, 23, 24, 25, 4,        // From the Original Wiki - GPIO 0 through 7:   wpi  0 -  7
243    2,  3,                               // I2C  - SDA0, SCL0                            wpi  8 -  9
244    8,  7,                               // SPI  - CE1, CE0                              wpi 10 - 11
245   10,  9, 11,                           // SPI  - MOSI, MISO, SCLK                      wpi 12 - 14
246   14, 15,                               // UART - Tx, Rx                                wpi 15 - 16
247   28, 29, 30, 31,                       // New GPIOs 8 though 11                        wpi 17 - 20
248
249 // Padding:
250
251                       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 31
252   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
253   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
254 } ;
255
256
257 // gpioToGPFSEL:
258 //      Map a BCM_GPIO pin to it's control port. (GPFSEL 0-5)
259
260 static uint8_t gpioToGPFSEL [] =
261 {
262   0,0,0,0,0,0,0,0,0,0,
263   1,1,1,1,1,1,1,1,1,1,
264   2,2,2,2,2,2,2,2,2,2,
265   3,3,3,3,3,3,3,3,3,3,
266   4,4,4,4,4,4,4,4,4,4,
267   5,5,5,5,5,5,5,5,5,5,
268 } ;
269
270
271 // gpioToShift
272 //      Define the shift up for the 3 bits per pin in each GPFSEL port
273
274 static uint8_t gpioToShift [] =
275 {
276   0,3,6,9,12,15,18,21,24,27,
277   0,3,6,9,12,15,18,21,24,27,
278   0,3,6,9,12,15,18,21,24,27,
279   0,3,6,9,12,15,18,21,24,27,
280   0,3,6,9,12,15,18,21,24,27,
281 } ;
282
283
284 // gpioToGPSET:
285 //      (Word) offset to the GPIO Set registers for each GPIO pin
286
287 static uint8_t gpioToGPSET [] =
288 {
289    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
290    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
291 } ;
292
293
294 // gpioToGPCLR:
295 //      (Word) offset to the GPIO Clear registers for each GPIO pin
296
297 static uint8_t gpioToGPCLR [] =
298 {
299   10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
300   11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
301 } ;
302
303
304 // gpioToGPLEV:
305 //      (Word) offset to the GPIO Input level registers for each GPIO pin
306
307 static uint8_t gpioToGPLEV [] =
308 {
309   13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
310   14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
311 } ;
312
313
314 #ifdef notYetReady
315 // gpioToEDS
316 //      (Word) offset to the Event Detect Status
317
318 static uint8_t gpioToEDS [] =
319 {
320   16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
321   17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
322 } ;
323
324 // gpioToREN
325 //      (Word) offset to the Rising edgde ENable register
326
327 static uint8_t gpioToREN [] =
328 {
329   19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
330   20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
331 } ;
332
333 // gpioToFEN
334 //      (Word) offset to the Falling edgde ENable register
335
336 static uint8_t gpioToFEN [] =
337 {
338   22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
339   23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
340 } ;
341 #endif
342
343
344 // gpioToPUDCLK
345 //      (Word) offset to the Pull Up Down Clock regsiter
346
347 #define GPPUD   37
348
349 static uint8_t gpioToPUDCLK [] =
350 {
351   38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,
352   39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,
353 } ;
354
355
356 // gpioToPwmALT
357 //      the ALT value to put a GPIO pin into PWM mode
358
359 static uint8_t gpioToPwmALT [] =
360 {
361           0,         0,         0,         0,         0,         0,         0,         0,       //  0 ->  7
362           0,         0,         0,         0, FSEL_ALT0, FSEL_ALT0,         0,         0,       //  8 -> 15
363           0,         0, FSEL_ALT5, FSEL_ALT5,         0,         0,         0,         0,       // 16 -> 23
364           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
365           0,         0,         0,         0,         0,         0,         0,         0,       // 32 -> 39
366   FSEL_ALT0, FSEL_ALT0,         0,         0,         0, FSEL_ALT0,         0,         0,       // 40 -> 47
367           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
368           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
369 } ;
370
371 static uint8_t gpioToPwmPort [] =
372 {
373           0,         0,         0,         0,         0,         0,         0,         0,       //  0 ->  7
374           0,         0,         0,         0, PWM0_DATA, PWM1_DATA,         0,         0,       //  8 -> 15
375           0,         0, PWM0_DATA, PWM1_DATA,         0,         0,         0,         0,       // 16 -> 23
376           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
377           0,         0,         0,         0,         0,         0,         0,         0,       // 32 -> 39
378   PWM0_DATA, PWM1_DATA,         0,         0,         0, PWM1_DATA,         0,         0,       // 40 -> 47
379           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
380           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
381
382 } ;
383
384
385 /*
386  * Functions
387  *********************************************************************************
388  */
389
390
391 /*
392  * wpiPinToGpio:
393  *      Translate a wiringPi Pin number to native GPIO pin number.
394  *      (We don't use this here, prefering to just do the lookup directly,
395  *      but it's been requested!)
396  *********************************************************************************
397  */
398
399 int wpiPinToGpio (int wpiPin)
400 {
401   return pinToGpio [wpiPin & 63] ;
402 }
403
404
405 /*
406  * piBoardRev:
407  *      Return a number representing the hardware revision of the board.
408  *      Revision is currently 1 or 2. -1 is returned on error.
409  *
410  *      Much confusion here )-:
411  *      Seems there are some boards with 0000 in them (mistake in manufacture)
412  *      and some board with 0005 in them (another mistake in manufacture?)
413  *      So the distinction between boards that I can see is:
414  *      0000 - Error
415  *      0001 - Not used
416  *      0002 - Rev 1
417  *      0003 - Rev 1
418  *      0004 - Rev 2
419  *      0005 - Rev 2 (but error)
420  *      0006 - Rev 2
421  *      000f - Rev 2 + 512MB
422  *
423  *      A small thorn is the olde style overvolting - that will add in
424  *              1000000
425  *
426  *********************************************************************************
427  */
428
429 static void piBoardRevOops (char *why)
430 {
431   fprintf (stderr, "piBoardRev: Unable to determine board revision from /proc/cpuinfo\n") ;
432   fprintf (stderr, " -> %s\n", why) ;
433   fprintf (stderr, " ->  You may want to check:\n") ;
434   fprintf (stderr, " ->  http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
435   exit (EXIT_FAILURE) ;
436 }
437
438 int piBoardRev (void)
439 {
440   FILE *cpuFd ;
441   char line [120] ;
442   char *c, lastChar ;
443   static int  boardRev = -1 ;
444
445 // No point checking twice...
446
447   if (boardRev != -1)
448     return boardRev ;
449
450   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
451     return -1 ;
452
453   while (fgets (line, 120, cpuFd) != NULL)
454     if (strncmp (line, "Revision", 8) == 0)
455       break ;
456
457   fclose (cpuFd) ;
458
459   if (line == NULL)
460     piBoardRevOops ("No \"Revision\" line") ;
461
462   line [strlen (line) - 1] = 0 ; // Chomp LF
463   
464   if (wiringPiDebug)
465     printf ("piboardRev: Revision string: %s\n", line) ;
466
467   for (c = line ; *c ; ++c)
468     if (isdigit (*c))
469       break ;
470
471   if (!isdigit (*c))
472     piBoardRevOops ("No numeric revision string") ;
473
474 // If you have overvolted the Pi, then it appears that the revision
475 //      has 100000 added to it!
476
477   if (wiringPiDebug)
478     if (strlen (c) != 4)
479       printf ("piboardRev: This Pi has/is overvolted!\n") ;
480
481   lastChar = line [strlen (line) - 1] ;
482
483   if (wiringPiDebug)
484     printf ("piboardRev: lastChar is: '%c' (%d, 0x%02X)\n", lastChar, lastChar, lastChar) ;
485
486   /**/ if ((lastChar == '2') || (lastChar == '3'))
487     boardRev = 1 ;
488   else
489     boardRev = 2 ;
490
491   if (wiringPiDebug)
492     printf ("piBoardRev: Returning revision: %d\n", boardRev) ;
493
494   return boardRev ;
495 }
496
497
498
499 /*
500  * pinMode:
501  *      Sets the mode of a pin to be input, output or PWM output
502  *********************************************************************************
503  */
504
505 void pinModeGpio (int pin, int mode)
506 {
507 //  register int barrier ;
508
509   int fSel, shift, alt ;
510
511   pin &= 63 ;
512
513   fSel    = gpioToGPFSEL [pin] ;
514   shift   = gpioToShift  [pin] ;
515
516   /**/ if (mode == INPUT)
517     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
518   else if (mode == OUTPUT)
519     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
520   else if (mode == PWM_OUTPUT)
521   {
522     if ((alt = gpioToPwmALT [pin]) == 0)        // Not a PWM pin
523       return ;
524
525 // Set pin to PWM mode
526
527     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
528
529     delayMicroseconds (110) ;                           // See comments in pwmSetClockWPi
530     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
531
532 //  Page 107 of the BCM Peripherals manual talks about the GPIO clocks,
533 //      but I'm assuming (hoping!) that this applies to other clocks too.
534
535     *(pwm + PWM_CONTROL) = 0 ;                          // Stop PWM
536
537     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;        // Stop PWM Clock
538     delayMicroseconds (110) ;                           // See comments in pwmSetClockWPi
539
540     while ((*(clk + PWMCLK_CNTL) & 0x80) != 0)          // Wait for clock to be !BUSY
541       delayMicroseconds (1) ;
542
543     *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (32 << 12) ;  // set pwm div to 32 (19.2/32 = 600KHz)
544     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;        // enable clk
545
546     delayMicroseconds (110) ;                           // See comments in pwmSetClockWPi
547
548 // Default range register of 1024
549
550     *(pwm + PWM0_RANGE) = 1024 ; delayMicroseconds (10) ;
551     *(pwm + PWM1_RANGE) = 1024 ; delayMicroseconds (10) ;
552     *(pwm + PWM0_DATA)  =    0 ; delayMicroseconds (10) ;
553     *(pwm + PWM1_DATA)  =    0 ; delayMicroseconds (10) ;
554
555 // Enable PWMs in balanced mode (default)
556
557     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
558
559     delay (100) ;
560   }
561
562
563 // When we change mode of any pin, we remove the pull up/downs
564 //      Or we used to... Hm. Commented out now because for some wieird reason,
565 //      it seems to block subsequent attempts to set the pull up/downs and I've
566 //      not quite gotten to the bottom of why this happens
567 //      The down-side is that the pull up/downs are rememberd in the SoC between
568 //      power cycles, so it's going to be a good idea to explicitly set them in
569 //      any new code.
570 //
571 //  pullUpDnControl (pin, PUD_OFF) ;
572
573 }
574
575 void pinModeWPi (int pin, int mode)
576 {
577   pinModeGpio (pinToGpio [pin & 63], mode) ;
578 }
579
580 void pinModeSys (int pin, int mode)
581 {
582   return ;
583 }
584
585
586 /*
587  * getAlt:
588  *      Returns the ALT bits for a given port. Only really of-use
589  *      for the gpio readall command (I think)
590  *********************************************************************************
591  */
592
593 int getAltGpio (int pin)
594 {
595   int fSel, shift, alt ;
596
597   pin &= 63 ;
598
599   fSel    = gpioToGPFSEL [pin] ;
600   shift   = gpioToShift  [pin] ;
601
602   alt = (*(gpio + fSel) >> shift) & 7 ;
603
604   return alt ;
605 }
606
607 int getAltWPi (int pin)
608 {
609   return getAltGpio (pinToGpio [pin & 63]) ;
610 }
611
612 int getAltSys (int pin)
613 {
614   return 0 ;
615 }
616
617
618 /*
619  * pwmControl:
620  *      Allow the user to control some of the PWM functions
621  *********************************************************************************
622  */
623
624 void pwmSetModeWPi (int mode)
625 {
626   if (mode == PWM_MODE_MS)
627     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
628   else
629     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
630 }
631
632 void pwmSetModeSys (int mode)
633 {
634   return ;
635 }
636
637
638 void pwmSetRangeWPi (unsigned int range)
639 {
640   *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
641   *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
642 }
643
644 void pwmSetRangeSys (unsigned int range)
645 {
646   return ;
647 }
648
649 /*
650  * pwmSetClockWPi:
651  *      Set/Change the PWM clock. Originally my code, but changed
652  *      (for the better!) by Chris Hall, <chris@kchall.plus.com>
653  *      after further study of the manual and testing with a 'scope
654  *********************************************************************************
655  */
656
657 void pwmSetClockWPi (int divisor)
658 {
659   uint32_t pwm_control ;
660   divisor &= 4095 ;
661
662   if (wiringPiDebug)
663     printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
664
665   pwm_control = *(pwm + PWM_CONTROL) ;          // preserve PWM_CONTROL
666
667 // We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY
668 // stays high.
669
670   *(pwm + PWM_CONTROL) = 0 ;                    // Stop PWM
671
672 // Stop PWM clock before changing divisor. The delay after this does need to
673 // this big (95uS occasionally fails, 100uS OK), it's almost as though the BUSY
674 // flag is not working properly in balanced mode. Without the delay when DIV is
675 // adjusted the clock sometimes switches to very slow, once slow further DIV
676 // adjustments do nothing and it's difficult to get out of this mode.
677
678   *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;  // Stop PWM Clock
679     delayMicroseconds (110) ;                   // prevents clock going sloooow
680
681   while ((*(clk + PWMCLK_CNTL) & 0x80) != 0)    // Wait for clock to be !BUSY
682     delayMicroseconds (1) ;
683
684   *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12) ;
685
686   *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;  // Start PWM clock
687   *(pwm + PWM_CONTROL) = pwm_control ;          // restore PWM_CONTROL
688
689   if (wiringPiDebug)
690     printf ("Set     to: %d. Now    : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
691 }
692
693 void pwmSetClockSys (int divisor)
694 {
695   return ;
696 }
697
698
699 #ifdef notYetReady
700 /*
701  * pinED01:
702  * pinED10:
703  *      Enables edge-detect mode on a pin - from a 0 to a 1 or 1 to 0
704  *      Pin must already be in input mode with appropriate pull up/downs set.
705  *********************************************************************************
706  */
707
708 void pinEnableED01Pi (int pin)
709 {
710   pin = pinToGpio [pin & 63] ;
711 }
712 #endif
713
714
715
716 /*
717  * digitalWrite:
718  *      Set an output bit
719  *********************************************************************************
720  */
721
722 void digitalWriteWPi (int pin, int value)
723 {
724   pin = pinToGpio [pin & 63] ;
725
726   if (value == LOW)
727     *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
728   else
729     *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
730 }
731
732 void digitalWriteGpio (int pin, int value)
733 {
734   pin &= 63 ;
735
736   if (value == LOW)
737     *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
738   else
739     *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
740 }
741
742 void digitalWriteSys (int pin, int value)
743 {
744   pin &= 63 ;
745
746   if (sysFds [pin] != -1)
747   {
748     if (value == LOW)
749       write (sysFds [pin], "0\n", 2) ;
750     else
751       write (sysFds [pin], "1\n", 2) ;
752   }
753 }
754
755
756 /*
757  * digitalWriteByte:
758  *      Write an 8-bit byte to the first 8 GPIO pins - try to do it as
759  *      fast as possible.
760  *      However it still needs 2 operations to set the bits, so any external
761  *      hardware must not rely on seeing a change as there will be a change 
762  *      to set the outputs bits to zero, then another change to set the 1's
763  *********************************************************************************
764  */
765
766 void digitalWriteByteGpio (int value)
767 {
768   uint32_t pinSet = 0 ;
769   uint32_t pinClr = 0 ;
770   int mask = 1 ;
771   int pin ;
772
773   for (pin = 0 ; pin < 8 ; ++pin)
774   {
775     if ((value & mask) == 0)
776       pinClr |= (1 << pinToGpio [pin]) ;
777     else
778       pinSet |= (1 << pinToGpio [pin]) ;
779
780     mask <<= 1 ;
781   }
782
783   *(gpio + gpioToGPCLR [0]) = pinClr ;
784   *(gpio + gpioToGPSET [0]) = pinSet ;
785 }
786
787 void digitalWriteByteSys (int value)
788 {
789   int mask = 1 ;
790   int pin ;
791
792   for (pin = 0 ; pin < 8 ; ++pin)
793   {
794     digitalWriteSys (pinToGpio [pin], value & mask) ;
795     mask <<= 1 ;
796   }
797 }
798
799
800 /*
801  * pwmWrite:
802  *      Set an output PWM value
803  *********************************************************************************
804  */
805
806 void pwmWriteGpio (int pin, int value)
807 {
808   int port ;
809
810   pin  = pin & 63 ;
811   port = gpioToPwmPort [pin] ;
812
813   *(pwm + port) = value ;
814 }
815
816 void pwmWriteWPi (int pin, int value)
817 {
818   pwmWriteGpio (pinToGpio [pin & 63], value) ;
819 }
820
821 void pwmWriteSys (int pin, int value)
822 {
823   return ;
824 }
825
826
827 /*
828  * setPadDrive:
829  *      Set the PAD driver value
830  *********************************************************************************
831  */
832
833 void setPadDriveWPi (int group, int value)
834 {
835   uint32_t wrVal ;
836
837   if ((group < 0) || (group > 2))
838     return ;
839
840   wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
841   *(pads + group + 11) = wrVal ;
842
843   if (wiringPiDebug)
844   {
845     printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
846     printf ("Read : %08X\n", *(pads + group + 11)) ;
847   }
848 }
849
850 void setPadDriveGpio (int group, int value)
851 {
852   setPadDriveWPi (group, value) ;
853 }
854
855 void setPadDriveSys (int group, int value)
856 {
857   return ;
858 }
859
860
861 /*
862  * digitalRead:
863  *      Read the value of a given Pin, returning HIGH or LOW
864  *********************************************************************************
865  */
866
867 int digitalReadWPi (int pin)
868 {
869   pin = pinToGpio [pin & 63] ;
870
871   if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
872     return HIGH ;
873   else
874     return LOW ;
875 }
876
877 int digitalReadGpio (int pin)
878 {
879   pin &= 63 ;
880
881   if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
882     return HIGH ;
883   else
884     return LOW ;
885 }
886
887 int digitalReadSys (int pin)
888 {
889   char c ;
890
891   pin &= 63 ;
892
893   if (sysFds [pin] == -1)
894     return 0 ;
895
896   lseek (sysFds [pin], 0L, SEEK_SET) ;
897   read  (sysFds [pin], &c, 1) ;
898   return (c == '0') ? 0 : 1 ;
899 }
900
901
902 /*
903  * pullUpDownCtrl:
904  *      Control the internal pull-up/down resistors on a GPIO pin
905  *      The Arduino only has pull-ups and these are enabled by writing 1
906  *      to a port when in input mode - this paradigm doesn't quite apply
907  *      here though.
908  *********************************************************************************
909  */
910
911 void pullUpDnControlGpio (int pin, int pud)
912 {
913   pin &= 63 ;
914   pud &=  3 ;
915
916   *(gpio + GPPUD)              = pud ;                  delayMicroseconds (5) ;
917   *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ;      delayMicroseconds (5) ;
918   
919   *(gpio + GPPUD)              = 0 ;                    delayMicroseconds (5) ;
920   *(gpio + gpioToPUDCLK [pin]) = 0 ;                    delayMicroseconds (5) ;
921 }
922
923 void pullUpDnControlWPi (int pin, int pud)
924 {
925   pullUpDnControlGpio (pinToGpio [pin & 63], pud) ;
926 }
927
928 void pullUpDnControlSys (int pin, int pud)
929 {
930   return ;
931 }
932
933
934 /*
935  * waitForInterrupt:
936  *      Wait for Interrupt on a GPIO pin.
937  *      This is actually done via the /sys/class/gpio interface regardless of
938  *      the wiringPi access mode in-use. Maybe sometime it might get a better
939  *      way for a bit more efficiency.
940  *********************************************************************************
941  */
942
943 int waitForInterruptSys (int pin, int mS)
944 {
945   int fd, x ;
946   uint8_t c ;
947   struct pollfd polls ;
948
949   if ((fd = sysFds [pin & 63]) == -1)
950     return -2 ;
951
952 // Setup poll structure
953
954   polls.fd     = fd ;
955   polls.events = POLLPRI ;      // Urgent data!
956
957 // Wait for it ...
958
959   x = poll (&polls, 1, mS) ;
960
961 // Do a dummy read to clear the interrupt
962 //      A one character read appars to be enough.
963
964   (void)read (fd, &c, 1) ;
965
966   return x ;
967 }
968
969 int waitForInterruptWPi (int pin, int mS)
970 {
971   return waitForInterruptSys (pinToGpio [pin & 63], mS) ;
972 }
973
974 int waitForInterruptGpio (int pin, int mS)
975 {
976   return waitForInterruptSys (pin, mS) ;
977 }
978
979
980 /*
981  * interruptHandler:
982  *      This is a thread and gets started to wait for the interrupt we're
983  *      hoping to catch. It will call the user-function when the interrupt
984  *      fires.
985  *********************************************************************************
986  */
987
988 static void *interruptHandler (void *arg)
989 {
990   int myPin = *(int *)arg ;
991
992   (void)piHiPri (55) ;  // Only effective if we run as root
993
994   for (;;)
995     if (waitForInterruptSys (myPin, -1) > 0)
996       isrFunctions [myPin] () ;
997
998   return NULL ;
999 }
1000
1001
1002 /*
1003  * wiringPiISR:
1004  *      Take the details and create an interrupt handler that will do a call-
1005  *      back to the user supplied function.
1006  *********************************************************************************
1007  */
1008
1009 int wiringPiISR (int pin, int mode, void (*function)(void))
1010 {
1011   pthread_t threadId ;
1012   char fName   [64] ;
1013   char *modeS ;
1014   char  pinS [8] ;
1015   pid_t pid ;
1016   int   count, i ;
1017   uint8_t c ;
1018
1019   pin &= 63 ;
1020
1021   if (wiringPiMode == WPI_MODE_UNINITIALISED)
1022   {
1023     fprintf (stderr, "wiringPiISR: wiringPi has not been initialised. Unable to continue.\n") ;
1024     exit (EXIT_FAILURE) ;
1025   }
1026   else if (wiringPiMode == WPI_MODE_PINS)
1027     pin = pinToGpio [pin] ;
1028
1029 // Now export the pin and set the right edge
1030 //      We're going to use the gpio program to do this, so it assumes
1031 //      a full installation of wiringPi. It's a bit 'clunky', but it
1032 //      is a way that will work when we're running in "Sys" mode, as
1033 //      a non-root user. (without sudo)
1034
1035   if (mode != INT_EDGE_SETUP)
1036   {
1037     /**/ if (mode == INT_EDGE_FALLING)
1038       modeS = "falling" ;
1039     else if (mode == INT_EDGE_RISING)
1040       modeS = "rising" ;
1041     else
1042       modeS = "both" ;
1043
1044     sprintf (pinS, "%d", pin) ;
1045
1046     if ((pid = fork ()) < 0)    // Fail
1047       return pid ;
1048
1049     if (pid == 0)       // Child, exec
1050     {
1051       execl ("/usr/local/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
1052       return -1 ;       // Failure ...
1053     }
1054     else                // Parent, wait
1055       wait (NULL) ;
1056   }
1057
1058 // Now pre-open the /sys/class node - it may already be open if
1059 //      we are in Sys mode, but this will do no harm.
1060
1061   sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1062   if ((sysFds [pin] = open (fName, O_RDWR)) < 0)
1063     return -1 ;
1064
1065 // Clear any initial pending interrupt
1066
1067   ioctl (sysFds [pin], FIONREAD, &count) ;
1068   for (i = 0 ; i < count ; ++i)
1069     read (sysFds [pin], &c, 1) ;
1070
1071   isrFunctions [pin] = function ;
1072
1073   pthread_create (&threadId, NULL, interruptHandler, &pin) ;
1074
1075   delay (1) ;
1076
1077   return 0 ;
1078 }
1079
1080
1081 /*
1082  * initialiseEpoch:
1083  *      Initialise our start-of-time variable to be the current unix
1084  *      time in milliseconds.
1085  *********************************************************************************
1086  */
1087
1088 static void initialiseEpoch (void)
1089 {
1090   struct timeval tv ;
1091
1092   gettimeofday (&tv, NULL) ;
1093   epochMilli = (uint64_t)tv.tv_sec * (uint64_t)1000    + (uint64_t)(tv.tv_usec / 1000) ;
1094   epochMicro = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)(tv.tv_usec) ;
1095 }
1096
1097 /*
1098  * delay:
1099  *      Wait for some number of milli seconds
1100  *********************************************************************************
1101  */
1102
1103 void delay (unsigned int howLong)
1104 {
1105   struct timespec sleeper, dummy ;
1106
1107   sleeper.tv_sec  = (time_t)(howLong / 1000) ;
1108   sleeper.tv_nsec = (long)(howLong % 1000) * 1000000 ;
1109
1110   nanosleep (&sleeper, &dummy) ;
1111 }
1112
1113
1114 /*
1115  * delayMicroseconds:
1116  *      This is somewhat intersting. It seems that on the Pi, a single call
1117  *      to nanosleep takes some 80 to 130 microseconds anyway, so while
1118  *      obeying the standards (may take longer), it's not always what we
1119  *      want!
1120  *
1121  *      So what I'll do now is if the delay is less than 100uS we'll do it
1122  *      in a hard loop, watching a built-in counter on the ARM chip. This is
1123  *      somewhat sub-optimal in that it uses 100% CPU, something not an issue
1124  *      in a microcontroller, but under a multi-tasking, multi-user OS, it's
1125  *      wastefull, however we've no real choice )-:
1126  *
1127  *      Plan B: It seems all might not be well with that plan, so changing it
1128  *      to use gettimeofday () and poll on that instead...
1129  *********************************************************************************
1130  */
1131
1132 void delayMicrosecondsHard (unsigned int howLong)
1133 {
1134   struct timeval tNow, tLong, tEnd ;
1135
1136   gettimeofday (&tNow, NULL) ;
1137   tLong.tv_sec  = howLong / 1000000 ;
1138   tLong.tv_usec = howLong % 1000000 ;
1139   timeradd (&tNow, &tLong, &tEnd) ;
1140
1141   while (timercmp (&tNow, &tEnd, <))
1142     gettimeofday (&tNow, NULL) ;
1143 }
1144
1145 void delayMicroseconds (unsigned int howLong)
1146 {
1147   struct timespec sleeper ;
1148
1149   /**/ if (howLong ==   0)
1150     return ;
1151   else if (howLong  < 100)
1152     delayMicrosecondsHard (howLong) ;
1153   else
1154   {
1155     sleeper.tv_sec  = 0 ;
1156     sleeper.tv_nsec = (long)(howLong * 1000) ;
1157     nanosleep (&sleeper, NULL) ;
1158   }
1159 }
1160
1161
1162 /*
1163  * millis:
1164  *      Return a number of milliseconds as an unsigned int.
1165  *********************************************************************************
1166  */
1167
1168 unsigned int millis (void)
1169 {
1170   struct timeval tv ;
1171   uint64_t now ;
1172
1173   gettimeofday (&tv, NULL) ;
1174   now  = (uint64_t)tv.tv_sec * (uint64_t)1000 + (uint64_t)(tv.tv_usec / 1000) ;
1175
1176   return (uint32_t)(now - epochMilli) ;
1177 }
1178
1179
1180 /*
1181  * micros:
1182  *      Return a number of microseconds as an unsigned int.
1183  *********************************************************************************
1184  */
1185
1186 unsigned int micros (void)
1187 {
1188   struct timeval tv ;
1189   uint64_t now ;
1190
1191   gettimeofday (&tv, NULL) ;
1192   now  = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)tv.tv_usec ;
1193
1194   return (uint32_t)(now - epochMicro) ;
1195 }
1196
1197
1198 /*
1199  * wiringPiSetup:
1200  *      Must be called once at the start of your program execution.
1201  *
1202  * Default setup: Initialises the system into wiringPi Pin mode and uses the
1203  *      memory mapped hardware directly.
1204  *********************************************************************************
1205  */
1206
1207 int wiringPiSetup (void)
1208 {
1209   int      fd ;
1210   int      boardRev ;
1211
1212   if (geteuid () != 0)
1213   {
1214     fprintf (stderr, "wiringPi:\n  Must be root to call wiringPiSetup().\n  (Did you forget sudo?)\n") ;
1215     exit (EXIT_FAILURE) ;
1216   }
1217
1218   if (getenv ("WIRINGPI_DEBUG") != NULL)
1219   {
1220     printf ("wiringPi: Debug mode enabled\n") ;
1221     wiringPiDebug = TRUE ;
1222   }
1223
1224   if (wiringPiDebug)
1225     printf ("wiringPi: wiringPiSetup called\n") ;
1226
1227             pinMode =           pinModeWPi ;
1228              getAlt =            getAltWPi ;
1229     pullUpDnControl =   pullUpDnControlWPi ;
1230        digitalWrite =      digitalWriteWPi ;
1231    digitalWriteByte = digitalWriteByteGpio ;    // Same code
1232            pwmWrite =          pwmWriteWPi ;
1233         setPadDrive =       setPadDriveWPi ;
1234         digitalRead =       digitalReadWPi ;
1235    waitForInterrupt =  waitForInterruptWPi ;
1236          pwmSetMode =        pwmSetModeWPi ;
1237         pwmSetRange =       pwmSetRangeWPi ;
1238         pwmSetClock =       pwmSetClockWPi ;
1239   
1240   boardRev = piBoardRev () ;
1241
1242   if (boardRev == 1)
1243     pinToGpio = pinToGpioR1 ;
1244   else
1245     pinToGpio = pinToGpioR2 ;
1246
1247 // Open the master /dev/memory device
1248
1249   if ((fd = open ("/dev/mem", O_RDWR | O_SYNC) ) < 0)
1250   {
1251     if (wiringPiDebug)
1252     {
1253       int serr = errno ;
1254         fprintf (stderr, "wiringPiSetup: Unable to open /dev/mem: %s\n", strerror (errno)) ;
1255       errno = serr ;
1256     }
1257     return -1 ;
1258   }
1259
1260 // GPIO:
1261
1262   gpio = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_BASE) ;
1263   if ((int32_t)gpio == -1)
1264   {
1265     if (wiringPiDebug)
1266     {
1267       int serr = errno ;
1268         fprintf (stderr, "wiringPiSetup: mmap failed: %s\n", strerror (errno)) ;
1269       errno = serr ;
1270     }
1271     return -1 ;
1272   }
1273
1274 // PWM
1275
1276   pwm = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PWM) ;
1277   if ((int32_t)pwm == -1)
1278   {
1279     if (wiringPiDebug)
1280     {
1281       int serr = errno ;
1282         fprintf (stderr, "wiringPiSetup: mmap failed (pwm): %s\n", strerror (errno)) ;
1283       errno = serr ;
1284     }
1285     return -1 ;
1286   }
1287  
1288 // Clock control (needed for PWM)
1289
1290   clk = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, CLOCK_BASE) ;
1291   if ((int32_t)clk == -1)
1292   {
1293     if (wiringPiDebug)
1294     {
1295       int serr = errno ;
1296         fprintf (stderr, "wiringPiSetup: mmap failed (clk): %s\n", strerror (errno)) ;
1297       errno = serr ;
1298     }
1299     return -1 ;
1300   }
1301  
1302 // The drive pads
1303
1304   pads = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PADS) ;
1305   if ((int32_t)pads == -1)
1306   {
1307     if (wiringPiDebug)
1308     {
1309       int serr = errno ;
1310         fprintf (stderr, "wiringPiSetup: mmap failed (pads): %s\n", strerror (errno)) ;
1311       errno = serr ;
1312     }
1313     return -1 ;
1314   }
1315
1316 // The system timer
1317
1318   timer = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_TIMER) ;
1319   if ((int32_t)timer == -1)
1320   {
1321     if (wiringPiDebug)
1322     {
1323       int serr = errno ;
1324         fprintf (stderr, "wiringPiSetup: mmap failed (timer): %s\n", strerror (errno)) ;
1325       errno = serr ;
1326     }
1327     return -1 ;
1328   }
1329
1330 // Set the timer to free-running, 1MHz.
1331 //      0xF9 is 249, the timer divide is base clock / (divide+1)
1332 //      so base clock is 250MHz / 250 = 1MHz.
1333
1334   *(timer + TIMER_CONTROL) = 0x0000280 ;
1335   *(timer + TIMER_PRE_DIV) = 0x00000F9 ;
1336   timerIrqRaw = timer + TIMER_IRQ_RAW ;
1337
1338   initialiseEpoch () ;
1339
1340   wiringPiMode = WPI_MODE_PINS ;
1341
1342   return 0 ;
1343 }
1344
1345
1346 /*
1347  * wiringPiSetupGpio:
1348  *      Must be called once at the start of your program execution.
1349  *
1350  * GPIO setup: Initialises the system into GPIO Pin mode and uses the
1351  *      memory mapped hardware directly.
1352  *********************************************************************************
1353  */
1354
1355 int wiringPiSetupGpio (void)
1356 {
1357   int x  ;
1358
1359   if (geteuid () != 0)
1360   {
1361     fprintf (stderr, "Must be root to call wiringPiSetupGpio(). (Did you forget sudo?)\n") ;
1362     exit (EXIT_FAILURE) ;
1363   }
1364
1365   if ((x = wiringPiSetup ()) < 0)
1366     return x ;
1367
1368   if (wiringPiDebug)
1369     printf ("wiringPi: wiringPiSetupGpio called\n") ;
1370
1371             pinMode =           pinModeGpio ;
1372              getAlt =            getAltGpio ;
1373     pullUpDnControl =   pullUpDnControlGpio ;
1374        digitalWrite =      digitalWriteGpio ;
1375    digitalWriteByte =  digitalWriteByteGpio ;
1376            pwmWrite =          pwmWriteGpio ;
1377         setPadDrive =       setPadDriveGpio ;
1378         digitalRead =       digitalReadGpio ;
1379    waitForInterrupt =  waitForInterruptGpio ;
1380          pwmSetMode =        pwmSetModeWPi ;
1381         pwmSetRange =       pwmSetRangeWPi ;
1382         pwmSetClock =       pwmSetClockWPi ;
1383
1384   wiringPiMode = WPI_MODE_GPIO ;
1385
1386   return 0 ;
1387 }
1388
1389
1390 /*
1391  * wiringPiSetupSys:
1392  *      Must be called once at the start of your program execution.
1393  *
1394  * Initialisation (again), however this time we are using the /sys/class/gpio
1395  *      interface to the GPIO systems - slightly slower, but always usable as
1396  *      a non-root user, assuming the devices are already exported and setup correctly.
1397  */
1398
1399 int wiringPiSetupSys (void)
1400 {
1401   int boardRev ;
1402   int pin ;
1403   char fName [128] ;
1404
1405   if (getenv ("WIRINGPI_DEBUG") != NULL)
1406     wiringPiDebug = TRUE ;
1407
1408   if (wiringPiDebug)
1409     printf ("wiringPi: wiringPiSetupSys called\n") ;
1410
1411             pinMode =           pinModeSys ;
1412              getAlt =            getAltSys ;
1413     pullUpDnControl =   pullUpDnControlSys ;
1414        digitalWrite =      digitalWriteSys ;
1415    digitalWriteByte =  digitalWriteByteSys ;
1416            pwmWrite =          pwmWriteSys ;
1417         setPadDrive =       setPadDriveSys ;
1418         digitalRead =       digitalReadSys ;
1419    waitForInterrupt =  waitForInterruptSys ;
1420          pwmSetMode =        pwmSetModeSys ;
1421         pwmSetRange =       pwmSetRangeSys ;
1422         pwmSetClock =       pwmSetClockSys ;
1423
1424   boardRev = piBoardRev () ;
1425
1426   if (boardRev == 1)
1427     pinToGpio = pinToGpioR1 ;
1428   else
1429     pinToGpio = pinToGpioR2 ;
1430
1431 // Open and scan the directory, looking for exported GPIOs, and pre-open
1432 //      the 'value' interface to speed things up for later
1433   
1434   for (pin = 0 ; pin < 64 ; ++pin)
1435   {
1436     sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1437     sysFds [pin] = open (fName, O_RDWR) ;
1438   }
1439
1440   initialiseEpoch () ;
1441
1442   wiringPiMode = WPI_MODE_GPIO_SYS ;
1443
1444   return 0 ;
1445 }