Gordons Projects

--> Projects Top-Level GIT

Minor changes to the files and removed a bit of debug.
[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 <stdarg.h>
57 #include <stdint.h>
58 #include <stdlib.h>
59 #include <ctype.h>
60 #include <poll.h>
61 #include <unistd.h>
62 #include <errno.h>
63 #include <string.h>
64 #include <time.h>
65 #include <fcntl.h>
66 #include <pthread.h>
67 #include <sys/time.h>
68 #include <sys/mman.h>
69 #include <sys/stat.h>
70 #include <sys/wait.h>
71 #include <sys/ioctl.h>
72
73 #include "wiringPi.h"
74
75 #ifndef TRUE
76 #define TRUE    (1==1)
77 #define FALSE   (1==2)
78 #endif
79
80 // Environment Variables
81
82 #define ENV_DEBUG       "WIRINGPI_DEBUG"
83 #define ENV_CODES       "WIRINGPI_CODES"
84
85
86 // Mask for the bottom 64 pins which belong to the Raspberry Pi
87 //      The others are available for the other devices
88
89 #define PI_GPIO_MASK    (0xFFFFFFC0)
90
91 struct wiringPiNodeStruct *wiringPiNodes = NULL ;
92
93 // BCM Magic
94
95 #define BCM_PASSWORD            0x5A000000
96
97
98 // The BCM2835 has 54 GPIO pins.
99 //      BCM2835 data sheet, Page 90 onwards.
100 //      There are 6 control registers, each control the functions of a block
101 //      of 10 pins.
102 //      Each control register has 10 sets of 3 bits per GPIO pin - the ALT values
103 //
104 //      000 = GPIO Pin X is an input
105 //      001 = GPIO Pin X is an output
106 //      100 = GPIO Pin X takes alternate function 0
107 //      101 = GPIO Pin X takes alternate function 1
108 //      110 = GPIO Pin X takes alternate function 2
109 //      111 = GPIO Pin X takes alternate function 3
110 //      011 = GPIO Pin X takes alternate function 4
111 //      010 = GPIO Pin X takes alternate function 5
112 //
113 // So the 3 bits for port X are:
114 //      X / 10 + ((X % 10) * 3)
115
116 // Port function select bits
117
118 #define FSEL_INPT               0b000
119 #define FSEL_OUTP               0b001
120 #define FSEL_ALT0               0b100
121 #define FSEL_ALT0               0b100
122 #define FSEL_ALT1               0b101
123 #define FSEL_ALT2               0b110
124 #define FSEL_ALT3               0b111
125 #define FSEL_ALT4               0b011
126 #define FSEL_ALT5               0b010
127
128 // Access from ARM Running Linux
129 //      Taken from Gert/Doms code. Some of this is not in the manual
130 //      that I can find )-:
131
132 #define BCM2708_PERI_BASE                            0x20000000
133 #define GPIO_PADS               (BCM2708_PERI_BASE + 0x00100000)
134 #define CLOCK_BASE              (BCM2708_PERI_BASE + 0x00101000)
135 #define GPIO_BASE               (BCM2708_PERI_BASE + 0x00200000)
136 #define GPIO_TIMER              (BCM2708_PERI_BASE + 0x0000B000)
137 #define GPIO_PWM                (BCM2708_PERI_BASE + 0x0020C000)
138
139 #define PAGE_SIZE               (4*1024)
140 #define BLOCK_SIZE              (4*1024)
141
142 // PWM
143 //      Word offsets into the PWM control region
144
145 #define PWM_CONTROL 0
146 #define PWM_STATUS  1
147 #define PWM0_RANGE  4
148 #define PWM0_DATA   5
149 #define PWM1_RANGE  8
150 #define PWM1_DATA   9
151
152 //      Clock regsiter offsets
153
154 #define PWMCLK_CNTL     40
155 #define PWMCLK_DIV      41
156
157 #define PWM0_MS_MODE    0x0080  // Run in MS mode
158 #define PWM0_USEFIFO    0x0020  // Data from FIFO
159 #define PWM0_REVPOLAR   0x0010  // Reverse polarity
160 #define PWM0_OFFSTATE   0x0008  // Ouput Off state
161 #define PWM0_REPEATFF   0x0004  // Repeat last value if FIFO empty
162 #define PWM0_SERIAL     0x0002  // Run in serial mode
163 #define PWM0_ENABLE     0x0001  // Channel Enable
164
165 #define PWM1_MS_MODE    0x8000  // Run in MS mode
166 #define PWM1_USEFIFO    0x2000  // Data from FIFO
167 #define PWM1_REVPOLAR   0x1000  // Reverse polarity
168 #define PWM1_OFFSTATE   0x0800  // Ouput Off state
169 #define PWM1_REPEATFF   0x0400  // Repeat last value if FIFO empty
170 #define PWM1_SERIAL     0x0200  // Run in serial mode
171 #define PWM1_ENABLE     0x0100  // Channel Enable
172
173 // Timer
174 //      Word offsets
175
176 #define TIMER_LOAD      (0x400 >> 2)
177 #define TIMER_VALUE     (0x404 >> 2)
178 #define TIMER_CONTROL   (0x408 >> 2)
179 #define TIMER_IRQ_CLR   (0x40C >> 2)
180 #define TIMER_IRQ_RAW   (0x410 >> 2)
181 #define TIMER_IRQ_MASK  (0x414 >> 2)
182 #define TIMER_RELOAD    (0x418 >> 2)
183 #define TIMER_PRE_DIV   (0x41C >> 2)
184 #define TIMER_COUNTER   (0x420 >> 2)
185
186 // Locals to hold pointers to the hardware
187
188 static volatile uint32_t *gpio ;
189 static volatile uint32_t *pwm ;
190 static volatile uint32_t *clk ;
191 static volatile uint32_t *pads ;
192
193 #ifdef  USE_TIMER
194 static volatile uint32_t *timer ;
195 static volatile uint32_t *timerIrqRaw ;
196 #endif
197
198 // Time for easy calculations
199
200 static uint64_t epochMilli, epochMicro ;
201
202 // Misc
203
204 static int wiringPiMode = WPI_MODE_UNINITIALISED ;
205 static volatile int    pinPass = -1 ;
206 static pthread_mutex_t pinMutex ;
207
208 // Debugging & Return codes
209
210 int wiringPiDebug       = FALSE ;
211 int wiringPiReturnCodes = FALSE ;
212
213 // sysFds:
214 //      Map a file descriptor from the /sys/class/gpio/gpioX/value
215
216 static int sysFds [64] =
217 {
218   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
219   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
220   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
221   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
222 } ;
223
224 // ISR Data
225
226 static void (*isrFunctions [64])(void) ;
227
228
229 // Doing it the Arduino way with lookup tables...
230 //      Yes, it's probably more innefficient than all the bit-twidling, but it
231 //      does tend to make it all a bit clearer. At least to me!
232
233 // pinToGpio:
234 //      Take a Wiring pin (0 through X) and re-map it to the BCM_GPIO pin
235 //      Cope for 2 different board revisions here.
236
237 static int *pinToGpio ;
238
239 static int pinToGpioR1 [64] =
240 {
241   17, 18, 21, 22, 23, 24, 25, 4,        // From the Original Wiki - GPIO 0 through 7:   wpi  0 -  7
242    0,  1,                               // I2C  - SDA0, SCL0                            wpi  8 -  9
243    8,  7,                               // SPI  - CE1, CE0                              wpi 10 - 11
244   10,  9, 11,                           // SPI  - MOSI, MISO, SCLK                      wpi 12 - 14
245   14, 15,                               // UART - Tx, Rx                                wpi 15 - 16
246
247 // Padding:
248
249       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 31
250   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
251   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
252 } ;
253
254 static int pinToGpioR2 [64] =
255 {
256   17, 18, 27, 22, 23, 24, 25, 4,        // From the Original Wiki - GPIO 0 through 7:   wpi  0 -  7
257    2,  3,                               // I2C  - SDA0, SCL0                            wpi  8 -  9
258    8,  7,                               // SPI  - CE1, CE0                              wpi 10 - 11
259   10,  9, 11,                           // SPI  - MOSI, MISO, SCLK                      wpi 12 - 14
260   14, 15,                               // UART - Tx, Rx                                wpi 15 - 16
261   28, 29, 30, 31,                       // New GPIOs 8 though 11                        wpi 17 - 20
262
263 // Padding:
264
265                       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 31
266   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
267   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
268 } ;
269
270
271 // physToGpio:
272 //      Take a physical pin (1 through 26) and re-map it to the BCM_GPIO pin
273 //      Cope for 2 different board revisions here.
274
275 static int *physToGpio ;
276
277 static int physToGpioR1 [64] =
278 {
279   -1,           // 0
280   -1, -1,       // 1, 2
281    0, -1,
282    1, -1,
283    4, 14,
284   -1, 15,
285   17, 18,
286   21, -1,
287   22, 23,
288   -1, 24,
289   10, -1,
290    9, 25,
291   11,  8,
292   -1,  7,       // 25, 26
293
294 // Padding:
295
296                                               -1, -1, -1, -1, -1,       // ... 31
297   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
298   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
299 } ;
300
301 static int physToGpioR2 [64] =
302 {
303   -1,           // 0
304   -1, -1,       // 1, 2
305    2, -1,
306    3, -1,
307    4, 14,
308   -1, 15,
309   17, 18,
310   27, -1,
311   22, 23,
312   -1, 24,
313   10, -1,
314    9, 25,
315   11,  8,
316   -1,  7,       // 25, 26
317
318 // Padding:
319
320                                               -1, -1, -1, -1, -1,       // ... 31
321   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
322   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
323 } ;
324
325
326 // gpioToGPFSEL:
327 //      Map a BCM_GPIO pin to it's Function Selection
328 //      control port. (GPFSEL 0-5)
329 //      Groups of 10 - 3 bits per Function - 30 bits per port
330
331 static uint8_t gpioToGPFSEL [] =
332 {
333   0,0,0,0,0,0,0,0,0,0,
334   1,1,1,1,1,1,1,1,1,1,
335   2,2,2,2,2,2,2,2,2,2,
336   3,3,3,3,3,3,3,3,3,3,
337   4,4,4,4,4,4,4,4,4,4,
338   5,5,5,5,5,5,5,5,5,5,
339 } ;
340
341
342 // gpioToShift
343 //      Define the shift up for the 3 bits per pin in each GPFSEL port
344
345 static uint8_t gpioToShift [] =
346 {
347   0,3,6,9,12,15,18,21,24,27,
348   0,3,6,9,12,15,18,21,24,27,
349   0,3,6,9,12,15,18,21,24,27,
350   0,3,6,9,12,15,18,21,24,27,
351   0,3,6,9,12,15,18,21,24,27,
352 } ;
353
354
355 // gpioToGPSET:
356 //      (Word) offset to the GPIO Set registers for each GPIO pin
357
358 static uint8_t gpioToGPSET [] =
359 {
360    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,
361    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,
362 } ;
363
364 // gpioToGPCLR:
365 //      (Word) offset to the GPIO Clear registers for each GPIO pin
366
367 static uint8_t gpioToGPCLR [] =
368 {
369   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,
370   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,
371 } ;
372
373
374 // gpioToGPLEV:
375 //      (Word) offset to the GPIO Input level registers for each GPIO pin
376
377 static uint8_t gpioToGPLEV [] =
378 {
379   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,
380   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,
381 } ;
382
383
384 #ifdef notYetReady
385 // gpioToEDS
386 //      (Word) offset to the Event Detect Status
387
388 static uint8_t gpioToEDS [] =
389 {
390   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,
391   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,
392 } ;
393
394 // gpioToREN
395 //      (Word) offset to the Rising edgde ENable register
396
397 static uint8_t gpioToREN [] =
398 {
399   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,
400   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,
401 } ;
402
403 // gpioToFEN
404 //      (Word) offset to the Falling edgde ENable register
405
406 static uint8_t gpioToFEN [] =
407 {
408   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,
409   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,
410 } ;
411 #endif
412
413
414 // GPPUD:
415 //      GPIO Pin pull up/down register
416
417 #define GPPUD   37
418
419 // gpioToPUDCLK
420 //      (Word) offset to the Pull Up Down Clock regsiter
421
422 static uint8_t gpioToPUDCLK [] =
423 {
424   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,
425   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,
426 } ;
427
428
429 // gpioToPwmALT
430 //      the ALT value to put a GPIO pin into PWM mode
431
432 static uint8_t gpioToPwmALT [] =
433 {
434           0,         0,         0,         0,         0,         0,         0,         0,       //  0 ->  7
435           0,         0,         0,         0, FSEL_ALT0, FSEL_ALT0,         0,         0,       //  8 -> 15
436           0,         0, FSEL_ALT5, FSEL_ALT5,         0,         0,         0,         0,       // 16 -> 23
437           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
438           0,         0,         0,         0,         0,         0,         0,         0,       // 32 -> 39
439   FSEL_ALT0, FSEL_ALT0,         0,         0,         0, FSEL_ALT0,         0,         0,       // 40 -> 47
440           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
441           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
442 } ;
443
444
445 // gpioToPwmPort
446 //      The port value to put a GPIO pin into PWM mode
447
448 static uint8_t gpioToPwmPort [] =
449 {
450           0,         0,         0,         0,         0,         0,         0,         0,       //  0 ->  7
451           0,         0,         0,         0, PWM0_DATA, PWM1_DATA,         0,         0,       //  8 -> 15
452           0,         0, PWM0_DATA, PWM1_DATA,         0,         0,         0,         0,       // 16 -> 23
453           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
454           0,         0,         0,         0,         0,         0,         0,         0,       // 32 -> 39
455   PWM0_DATA, PWM1_DATA,         0,         0,         0, PWM1_DATA,         0,         0,       // 40 -> 47
456           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
457           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
458
459 } ;
460
461 // gpioToGpClkALT:
462 //      ALT value to put a GPIO pin into GP Clock mode.
463 //      On the Pi we can really only use BCM_GPIO_4 and BCM_GPIO_21
464 //      for clocks 0 and 1 respectively, however I'll include the full
465 //      list for completeness - maybe one day...
466
467 #define GPIO_CLOCK_SOURCE       1
468
469 // gpioToGpClkALT0:
470
471 static uint8_t gpioToGpClkALT0 [] =
472 {
473           0,         0,         0,         0, FSEL_ALT0, FSEL_ALT0, FSEL_ALT0,         0,       //  0 ->  7
474           0,         0,         0,         0,         0,         0,         0,         0,       //  8 -> 15
475           0,         0,         0,         0, FSEL_ALT5, FSEL_ALT5,         0,         0,       // 16 -> 23
476           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
477   FSEL_ALT0,         0, FSEL_ALT0,         0,         0,         0,         0,         0,       // 32 -> 39
478           0,         0, FSEL_ALT0, FSEL_ALT0, FSEL_ALT0,         0,         0,         0,       // 40 -> 47
479           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
480           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
481 } ;
482
483 // gpioToClk:
484 //      (word) Offsets to the clock Control and Divisor register
485
486 static uint8_t gpioToClkCon [] =
487 {
488          -1,        -1,        -1,        -1,        28,        30,        32,        -1,       //  0 ->  7
489          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       //  8 -> 15
490          -1,        -1,        -1,        -1,        28,        30,        -1,        -1,       // 16 -> 23
491          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 24 -> 31
492          28,        -1,        28,        -1,        -1,        -1,        -1,        -1,       // 32 -> 39
493          -1,        -1,        28,        30,        28,        -1,        -1,        -1,       // 40 -> 47
494          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 48 -> 55
495          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 56 -> 63
496 } ;
497
498 static uint8_t gpioToClkDiv [] =
499 {
500          -1,        -1,        -1,        -1,        29,        31,        33,        -1,       //  0 ->  7
501          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       //  8 -> 15
502          -1,        -1,        -1,        -1,        29,        31,        -1,        -1,       // 16 -> 23
503          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 24 -> 31
504          29,        -1,        29,        -1,        -1,        -1,        -1,        -1,       // 32 -> 39
505          -1,        -1,        29,        31,        29,        -1,        -1,        -1,       // 40 -> 47
506          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 48 -> 55
507          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 56 -> 63
508 } ;
509
510
511 /*
512  * Functions
513  *********************************************************************************
514  */
515
516
517 /*
518  * wiringPiFailure:
519  *      Fail. Or not.
520  *********************************************************************************
521  */
522
523 int wiringPiFailure (int fatal, const char *message, ...)
524 {
525   va_list argp ;
526   char buffer [1024] ;
527
528   if (!fatal && wiringPiReturnCodes)
529     return -1 ;
530
531   va_start (argp, message) ;
532     vsnprintf (buffer, 1023, message, argp) ;
533   va_end (argp) ;
534
535   fprintf (stderr, "%s", buffer) ;
536   exit (EXIT_FAILURE) ;
537
538   return 0 ;
539 }
540
541
542 /*
543  * piBoardRev:
544  *      Return a number representing the hardware revision of the board.
545  *      Revision is currently 1 or 2.
546  *
547  *      Much confusion here )-:
548  *      Seems there are some boards with 0000 in them (mistake in manufacture)
549  *      and some board with 0005 in them (another mistake in manufacture?)
550  *      So the distinction between boards that I can see is:
551  *      0000 - Error
552  *      0001 - Not used
553  *      0002 - Rev 1
554  *      0003 - Rev 1
555  *      0004 - Rev 2 (Early reports?
556  *      0005 - Rev 2 (but error?)
557  *      0006 - Rev 2
558  *      0008 - Rev 2 - Model A
559  *      000e - Rev 2 + 512MB
560  *      000f - Rev 2 + 512MB
561  *
562  *      A small thorn is the olde style overvolting - that will add in
563  *              1000000
564  *
565  *********************************************************************************
566  */
567
568 static void piBoardRevOops (const char *why)
569 {
570   fprintf (stderr, "piBoardRev: Unable to determine board revision from /proc/cpuinfo\n") ;
571   fprintf (stderr, " -> %s\n", why) ;
572   fprintf (stderr, " ->  You may want to check:\n") ;
573   fprintf (stderr, " ->  http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
574   exit (EXIT_FAILURE) ;
575 }
576
577 int piBoardRev (void)
578 {
579   FILE *cpuFd ;
580   char line [120] ;
581   char *c, lastChar ;
582   static int  boardRev = -1 ;
583
584   if (boardRev != -1)   // No point checking twice
585     return boardRev ;
586
587   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
588     piBoardRevOops ("Unable to open /proc/cpuinfo") ;
589
590   while (fgets (line, 120, cpuFd) != NULL)
591     if (strncmp (line, "Revision", 8) == 0)
592       break ;
593
594   fclose (cpuFd) ;
595
596   if (strncmp (line, "Revision", 8) != 0)
597     piBoardRevOops ("No \"Revision\" line") ;
598
599   for (c = &line [strlen (line) - 1] ; (*c == '\n') || (*c == '\r') ; --c)
600     *c = 0 ;
601   
602   if (wiringPiDebug)
603     printf ("piboardRev: Revision string: %s\n", line) ;
604
605   for (c = line ; *c ; ++c)
606     if (isdigit (*c))
607       break ;
608
609   if (!isdigit (*c))
610     piBoardRevOops ("No numeric revision string") ;
611
612 // If you have overvolted the Pi, then it appears that the revision
613 //      has 100000 added to it!
614
615   if (wiringPiDebug)
616     if (strlen (c) != 4)
617       printf ("piboardRev: This Pi has/is overvolted!\n") ;
618
619   lastChar = line [strlen (line) - 1] ;
620
621   if (wiringPiDebug)
622     printf ("piboardRev: lastChar is: '%c' (%d, 0x%02X)\n", lastChar, lastChar, lastChar) ;
623
624   /**/ if ((lastChar == '2') || (lastChar == '3'))
625     boardRev = 1 ;
626   else
627     boardRev = 2 ;
628
629   if (wiringPiDebug)
630     printf ("piBoardRev: Returning revision: %d\n", boardRev) ;
631
632   return boardRev ;
633 }
634
635
636 /*
637  * wpiPinToGpio:
638  *      Translate a wiringPi Pin number to native GPIO pin number.
639  *      Provided for external support.
640  *********************************************************************************
641  */
642
643 int wpiPinToGpio (int wpiPin)
644 {
645   return pinToGpio [wpiPin & 63] ;
646 }
647
648
649 /*
650  * physPinToGpio:
651  *      Translate a physical Pin number to native GPIO pin number.
652  *      Provided for external support.
653  *********************************************************************************
654  */
655
656 int physPinToGpio (int physPin)
657 {
658   return physToGpio [physPin & 63] ;
659 }
660
661
662 /*
663  * setPadDrive:
664  *      Set the PAD driver value
665  *********************************************************************************
666  */
667
668 void setPadDrive (int group, int value)
669 {
670   uint32_t wrVal ;
671
672   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
673   {
674     if ((group < 0) || (group > 2))
675       return ;
676
677     wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
678     *(pads + group + 11) = wrVal ;
679
680     if (wiringPiDebug)
681     {
682       printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
683       printf ("Read : %08X\n", *(pads + group + 11)) ;
684     }
685   }
686 }
687
688
689 /*
690  * getAlt:
691  *      Returns the ALT bits for a given port. Only really of-use
692  *      for the gpio readall command (I think)
693  *********************************************************************************
694  */
695
696 int getAlt (int pin)
697 {
698   int fSel, shift, alt ;
699
700   pin &= 63 ;
701
702   /**/ if (wiringPiMode == WPI_MODE_PINS)
703     pin = pinToGpio [pin] ;
704   else if (wiringPiMode == WPI_MODE_PHYS)
705     pin = physToGpio [pin] ;
706   else if (wiringPiMode != WPI_MODE_GPIO)
707     return 0 ;
708
709   fSel    = gpioToGPFSEL [pin] ;
710   shift   = gpioToShift  [pin] ;
711
712   alt = (*(gpio + fSel) >> shift) & 7 ;
713
714   return alt ;
715 }
716
717
718 /*
719  * pwmSetMode:
720  *      Select the native "balanced" mode, or standard mark:space mode
721  *********************************************************************************
722  */
723
724 void pwmSetMode (int mode)
725 {
726   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
727   {
728     if (mode == PWM_MODE_MS)
729       *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
730     else
731       *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
732   }
733 }
734
735
736 /*
737  * pwmSetRange:
738  *      Set the PWM range register. We set both range registers to the same
739  *      value. If you want different in your own code, then write your own.
740  *********************************************************************************
741  */
742
743 void pwmSetRange (unsigned int range)
744 {
745   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
746   {
747     *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
748     *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
749   }
750 }
751
752
753 /*
754  * pwmSetClock:
755  *      Set/Change the PWM clock. Originally my code, but changed
756  *      (for the better!) by Chris Hall, <chris@kchall.plus.com>
757  *      after further study of the manual and testing with a 'scope
758  *********************************************************************************
759  */
760
761 void pwmSetClock (int divisor)
762 {
763   uint32_t pwm_control ;
764   divisor &= 4095 ;
765
766   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
767   {
768     if (wiringPiDebug)
769       printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
770
771     pwm_control = *(pwm + PWM_CONTROL) ;                // preserve PWM_CONTROL
772
773 // We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY
774 // stays high.
775
776     *(pwm + PWM_CONTROL) = 0 ;                          // Stop PWM
777
778 // Stop PWM clock before changing divisor. The delay after this does need to
779 // this big (95uS occasionally fails, 100uS OK), it's almost as though the BUSY
780 // flag is not working properly in balanced mode. Without the delay when DIV is
781 // adjusted the clock sometimes switches to very slow, once slow further DIV
782 // adjustments do nothing and it's difficult to get out of this mode.
783
784     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;        // Stop PWM Clock
785       delayMicroseconds (110) ;                 // prevents clock going sloooow
786
787     while ((*(clk + PWMCLK_CNTL) & 0x80) != 0)  // Wait for clock to be !BUSY
788       delayMicroseconds (1) ;
789
790     *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12) ;
791
792     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;        // Start PWM clock
793     *(pwm + PWM_CONTROL) = pwm_control ;                // restore PWM_CONTROL
794
795     if (wiringPiDebug)
796       printf ("Set     to: %d. Now    : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
797   }
798 }
799
800
801 /*
802  * gpioClockSet:
803  *      Set the freuency on a GPIO clock pin
804  *********************************************************************************
805  */
806
807 void gpioClockSet (int pin, int freq)
808 {
809   int divi, divr, divf ;
810
811   pin &= 63 ;
812
813   /**/ if (wiringPiMode == WPI_MODE_PINS)
814     pin = pinToGpio [pin] ;
815   else if (wiringPiMode == WPI_MODE_PHYS)
816     pin = physToGpio [pin] ;
817   else if (wiringPiMode != WPI_MODE_GPIO)
818     return ;
819   
820   divi = 19200000 / freq ;
821   divr = 19200000 % freq ;
822   divf = (int)((double)divr * 4096.0 / 19200000.0) ;
823
824   if (divi > 4095)
825     divi = 4095 ;
826
827   *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | GPIO_CLOCK_SOURCE ;              // Stop GPIO Clock
828   while ((*(clk + gpioToClkCon [pin]) & 0x80) != 0)                             // ... and wait
829     ;
830
831   *(clk + gpioToClkDiv [pin]) = BCM_PASSWORD | (divi << 12) | divf ;            // Set dividers
832   *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | 0x10 | GPIO_CLOCK_SOURCE ;       // Start Clock
833 }
834
835
836 /*
837  * wiringPiFindNode:
838  *      Locate our device node
839  *********************************************************************************
840  */
841
842 struct wiringPiNodeStruct *wiringPiFindNode (int pin)
843 {
844   struct wiringPiNodeStruct *node = wiringPiNodes ;
845
846   while (node != NULL)
847     if ((pin >= node->pinBase) && (pin <= node->pinMax))
848       return node ;
849     else
850       node = node->next ;
851
852   return NULL ;
853 }
854
855
856 /*
857  * wiringPiNewNode:
858  *      Create a new GPIO node into the wiringPi handling system
859  *********************************************************************************
860  */
861
862 static void pinModeDummy             (struct wiringPiNodeStruct *node, int pin, int mode)  { return ; }
863 static void pullUpDnControlDummy     (struct wiringPiNodeStruct *node, int pin, int pud)   { return ; }
864 static int  digitalReadDummy         (struct wiringPiNodeStruct *node, int pin)            { return LOW ; }
865 static void digitalWriteDummy        (struct wiringPiNodeStruct *node, int pin, int value) { return ; }
866 static void pwmWriteDummy            (struct wiringPiNodeStruct *node, int pin, int value) { return ; }
867 static int  analogReadDummy          (struct wiringPiNodeStruct *node, int pin)            { return 0 ; }
868 static void analogWriteDummy         (struct wiringPiNodeStruct *node, int pin, int value) { return ; }
869
870 struct wiringPiNodeStruct *wiringPiNewNode (int pinBase, int numPins)
871 {
872   int    pin ;
873   struct wiringPiNodeStruct *node ;
874
875 // Minimum pin base is 64
876
877   if (pinBase < 64)
878     (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: pinBase of %d is < 64\n", pinBase) ;
879
880 // Check all pins in-case there is overlap:
881
882   for (pin = pinBase ; pin < (pinBase + numPins) ; ++pin)
883     if (wiringPiFindNode (pin) != NULL)
884       (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: Pin %d overlaps with existing definition\n", pin) ;
885
886   node = (struct wiringPiNodeStruct *)calloc (sizeof (struct wiringPiNodeStruct), 1) ;  // calloc zeros
887   if (node == NULL)
888     (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: Unable to allocate memory: %s\n", strerror (errno)) ;
889
890   node->pinBase         = pinBase ;
891   node->pinMax          = pinBase + numPins - 1 ;
892   node->pinMode         = pinModeDummy ;
893   node->pullUpDnControl = pullUpDnControlDummy ;
894   node->digitalRead     = digitalReadDummy ;
895   node->digitalWrite    = digitalWriteDummy ;
896   node->pwmWrite        = pwmWriteDummy ;
897   node->analogRead      = analogReadDummy ;
898   node->analogWrite     = analogWriteDummy ;
899   node->next            = wiringPiNodes ;
900   wiringPiNodes         = node ;
901
902   return node ;
903 }
904
905
906 #ifdef notYetReady
907 /*
908  * pinED01:
909  * pinED10:
910  *      Enables edge-detect mode on a pin - from a 0 to a 1 or 1 to 0
911  *      Pin must already be in input mode with appropriate pull up/downs set.
912  *********************************************************************************
913  */
914
915 void pinEnableED01Pi (int pin)
916 {
917   pin = pinToGpio [pin & 63] ;
918 }
919 #endif
920
921
922 /*
923  *********************************************************************************
924  * Core Functions
925  *********************************************************************************
926  */
927
928
929 /*
930  * pinMode:
931  *      Sets the mode of a pin to be input, output or PWM output
932  *********************************************************************************
933  */
934
935 void pinMode (int pin, int mode)
936 {
937   int    fSel, shift, alt ;
938   struct wiringPiNodeStruct *node = wiringPiNodes ;
939
940   if ((pin & PI_GPIO_MASK) == 0)                // On-board pin
941   {
942     /**/ if (wiringPiMode == WPI_MODE_PINS)
943       pin = pinToGpio [pin] ;
944     else if (wiringPiMode == WPI_MODE_PHYS)
945       pin = physToGpio [pin] ;
946     else if (wiringPiMode != WPI_MODE_GPIO)
947       return ;
948
949     fSel    = gpioToGPFSEL [pin] ;
950     shift   = gpioToShift  [pin] ;
951
952     /**/ if (mode == INPUT)
953       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
954     else if (mode == OUTPUT)
955       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
956     else if (mode == PWM_OUTPUT)
957     {
958       if ((alt = gpioToPwmALT [pin]) == 0)      // Not a PWM pin
959         return ;
960
961 // Set pin to PWM mode
962
963       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
964       delayMicroseconds (110) ;         // See comments in pwmSetClockWPi
965
966       pwmSetMode  (PWM_MODE_BAL) ;      // Pi default mode
967       pwmSetRange (1024) ;              // Default range of 1024
968       pwmSetClock (32) ;                        // 19.2 / 32 = 600KHz - Also starts the PWM
969     }
970     else if (mode == GPIO_CLOCK)
971     {
972       if ((alt = gpioToGpClkALT0 [pin]) == 0)   // Not a GPIO_CLOCK pin
973         return ;
974
975 // Set pin to GPIO_CLOCK mode and set the clock frequency to 100KHz
976
977       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
978       delayMicroseconds (110) ;
979       gpioClockSet      (pin, 100000) ;
980     }
981   }
982   else
983   {
984     if ((node = wiringPiFindNode (pin)) != NULL)
985       node->pinMode (node, pin, mode) ;
986     return ;
987   }
988 }
989
990
991 /*
992  * pullUpDownCtrl:
993  *      Control the internal pull-up/down resistors on a GPIO pin
994  *      The Arduino only has pull-ups and these are enabled by writing 1
995  *      to a port when in input mode - this paradigm doesn't quite apply
996  *      here though.
997  *********************************************************************************
998  */
999
1000 void pullUpDnControl (int pin, int pud)
1001 {
1002   struct wiringPiNodeStruct *node = wiringPiNodes ;
1003
1004   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1005   {
1006     /**/ if (wiringPiMode == WPI_MODE_PINS)
1007       pin = pinToGpio [pin] ;
1008     else if (wiringPiMode == WPI_MODE_PHYS)
1009       pin = physToGpio [pin] ;
1010     else if (wiringPiMode != WPI_MODE_GPIO)
1011       return ;
1012
1013     *(gpio + GPPUD)              = pud & 3 ;            delayMicroseconds (5) ;
1014     *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ;    delayMicroseconds (5) ;
1015     
1016     *(gpio + GPPUD)              = 0 ;                  delayMicroseconds (5) ;
1017     *(gpio + gpioToPUDCLK [pin]) = 0 ;                  delayMicroseconds (5) ;
1018   }
1019   else                                          // Extension module
1020   {
1021     if ((node = wiringPiFindNode (pin)) != NULL)
1022       node->pullUpDnControl (node, pin, pud) ;
1023     return ;
1024   }
1025 }
1026
1027
1028 /*
1029  * digitalRead:
1030  *      Read the value of a given Pin, returning HIGH or LOW
1031  *********************************************************************************
1032  */
1033
1034 int digitalRead (int pin)
1035 {
1036   char c ;
1037   struct wiringPiNodeStruct *node = wiringPiNodes ;
1038
1039   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1040   {
1041     /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS) // Sys mode
1042     {
1043       if (sysFds [pin] == -1)
1044         return LOW ;
1045
1046       lseek  (sysFds [pin], 0L, SEEK_SET) ;
1047       read   (sysFds [pin], &c, 1) ;
1048       return (c == '0') ? LOW : HIGH ;
1049     }
1050     else if (wiringPiMode == WPI_MODE_PINS)
1051       pin = pinToGpio [pin] ;
1052     else if (wiringPiMode == WPI_MODE_PHYS)
1053       pin = physToGpio [pin] ;
1054     else if (wiringPiMode != WPI_MODE_GPIO)
1055       return LOW ;
1056
1057     if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
1058       return HIGH ;
1059     else
1060       return LOW ;
1061   }
1062   else
1063   {
1064     if ((node = wiringPiFindNode (pin)) == NULL)
1065       return LOW ;
1066     return node->digitalRead (node, pin) ;
1067   }
1068 }
1069
1070
1071 /*
1072  * digitalWrite:
1073  *      Set an output bit
1074  *********************************************************************************
1075  */
1076
1077 void digitalWrite (int pin, int value)
1078 {
1079   struct wiringPiNodeStruct *node = wiringPiNodes ;
1080
1081   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1082   {
1083     /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS) // Sys mode
1084     {
1085       if (sysFds [pin] != -1)
1086       {
1087         if (value == LOW)
1088           write (sysFds [pin], "0\n", 2) ;
1089         else
1090           write (sysFds [pin], "1\n", 2) ;
1091       }
1092       return ;
1093     }
1094     else if (wiringPiMode == WPI_MODE_PINS)
1095       pin = pinToGpio [pin] ;
1096     else if (wiringPiMode == WPI_MODE_PHYS)
1097       pin = physToGpio [pin] ;
1098     else if (wiringPiMode != WPI_MODE_GPIO)
1099       return ;
1100
1101     if (value == LOW)
1102       *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
1103     else
1104       *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
1105   }
1106   else
1107   {
1108     if ((node = wiringPiFindNode (pin)) != NULL)
1109       node->digitalWrite (node, pin, value) ;
1110   }
1111 }
1112
1113
1114 /*
1115  * pwmWrite:
1116  *      Set an output PWM value
1117  *********************************************************************************
1118  */
1119
1120 void pwmWrite (int pin, int value)
1121 {
1122   struct wiringPiNodeStruct *node = wiringPiNodes ;
1123
1124   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1125   {
1126     /**/ if (wiringPiMode == WPI_MODE_PINS)
1127       pin = pinToGpio [pin] ;
1128     else if (wiringPiMode == WPI_MODE_PHYS)
1129       pin = physToGpio [pin] ;
1130     else if (wiringPiMode != WPI_MODE_GPIO)
1131       return ;
1132
1133     *(pwm + gpioToPwmPort [pin]) = value ;
1134   }
1135   else
1136   {
1137     if ((node = wiringPiFindNode (pin)) != NULL)
1138       node->pwmWrite (node, pin, value) ;
1139   }
1140 }
1141
1142
1143 /*
1144  * analogRead:
1145  *      Read the analog value of a given Pin. 
1146  *      There is no on-board Pi analog hardware,
1147  *      so this needs to go to a new node.
1148  *********************************************************************************
1149  */
1150
1151 int analogRead (int pin)
1152 {
1153   struct wiringPiNodeStruct *node = wiringPiNodes ;
1154
1155   if ((node = wiringPiFindNode (pin)) == NULL)
1156     return 0 ;
1157   else
1158     return node->analogRead (node, pin) ;
1159 }
1160
1161
1162 /*
1163  * analogWrite:
1164  *      Write the analog value to the given Pin. 
1165  *      There is no on-board Pi analog hardware,
1166  *      so this needs to go to a new node.
1167  *********************************************************************************
1168  */
1169
1170 void analogWrite (int pin, int value)
1171 {
1172   struct wiringPiNodeStruct *node = wiringPiNodes ;
1173
1174   if ((node = wiringPiFindNode (pin)) == NULL)
1175     return ;
1176
1177   node->analogWrite (node, pin, value) ;
1178 }
1179
1180
1181
1182 /*
1183  * digitalWriteByte:
1184  *      Pi Specific
1185  *      Write an 8-bit byte to the first 8 GPIO pins - try to do it as
1186  *      fast as possible.
1187  *      However it still needs 2 operations to set the bits, so any external
1188  *      hardware must not rely on seeing a change as there will be a change 
1189  *      to set the outputs bits to zero, then another change to set the 1's
1190  *********************************************************************************
1191  */
1192
1193 void digitalWriteByte (int value)
1194 {
1195   uint32_t pinSet = 0 ;
1196   uint32_t pinClr = 0 ;
1197   int mask = 1 ;
1198   int pin ;
1199
1200   /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
1201   {
1202     for (pin = 0 ; pin < 8 ; ++pin)
1203     {
1204       digitalWrite (pin, value & mask) ;
1205       mask <<= 1 ;
1206     }
1207     return ;
1208   }
1209   else
1210   {
1211     for (pin = 0 ; pin < 8 ; ++pin)
1212     {
1213       if ((value & mask) == 0)
1214         pinClr |= (1 << pinToGpio [pin]) ;
1215       else
1216         pinSet |= (1 << pinToGpio [pin]) ;
1217
1218       mask <<= 1 ;
1219     }
1220
1221     *(gpio + gpioToGPCLR [0]) = pinClr ;
1222     *(gpio + gpioToGPSET [0]) = pinSet ;
1223   }
1224 }
1225
1226
1227 /*
1228  * waitForInterrupt:
1229  *      Pi Specific.
1230  *      Wait for Interrupt on a GPIO pin.
1231  *      This is actually done via the /sys/class/gpio interface regardless of
1232  *      the wiringPi access mode in-use. Maybe sometime it might get a better
1233  *      way for a bit more efficiency.
1234  *********************************************************************************
1235  */
1236
1237 int waitForInterrupt (int pin, int mS)
1238 {
1239   int fd, x ;
1240   uint8_t c ;
1241   struct pollfd polls ;
1242
1243   /**/ if (wiringPiMode == WPI_MODE_PINS)
1244     pin = pinToGpio [pin] ;
1245   else if (wiringPiMode == WPI_MODE_PHYS)
1246     pin = physToGpio [pin] ;
1247
1248   if ((fd = sysFds [pin]) == -1)
1249     return -2 ;
1250
1251 // Setup poll structure
1252
1253   polls.fd     = fd ;
1254   polls.events = POLLPRI ;      // Urgent data!
1255
1256 // Wait for it ...
1257
1258   x = poll (&polls, 1, mS) ;
1259
1260 // Do a dummy read to clear the interrupt
1261 //      A one character read appars to be enough.
1262
1263   (void)read (fd, &c, 1) ;
1264
1265   return x ;
1266 }
1267
1268
1269 /*
1270  * interruptHandler:
1271  *      This is a thread and gets started to wait for the interrupt we're
1272  *      hoping to catch. It will call the user-function when the interrupt
1273  *      fires.
1274  *********************************************************************************
1275  */
1276
1277 static void *interruptHandler (void *arg)
1278 {
1279   int myPin ;
1280
1281   (void)piHiPri (55) ;  // Only effective if we run as root
1282
1283   myPin   = pinPass ;
1284   pinPass = -1 ;
1285
1286   for (;;)
1287     if (waitForInterrupt (myPin, -1) > 0)
1288       isrFunctions [myPin] () ;
1289
1290   return NULL ;
1291 }
1292
1293
1294 /*
1295  * wiringPiISR:
1296  *      Pi Specific.
1297  *      Take the details and create an interrupt handler that will do a call-
1298  *      back to the user supplied function.
1299  *********************************************************************************
1300  */
1301
1302 int wiringPiISR (int pin, int mode, void (*function)(void))
1303 {
1304   pthread_t threadId ;
1305   const char *modeS ;
1306   char fName   [64] ;
1307   char  pinS [8] ;
1308   pid_t pid ;
1309   int   count, i ;
1310   char  c ;
1311   int   bcmGpioPin ;
1312
1313   if ((pin < 0) || (pin > 63))
1314     return wiringPiFailure (WPI_FATAL, "wiringPiISR: pin must be 0-63 (%d)\n", pin) ;
1315
1316   /**/ if (wiringPiMode == WPI_MODE_UNINITIALISED)
1317     return wiringPiFailure (WPI_FATAL, "wiringPiISR: wiringPi has not been initialised. Unable to continue.\n") ;
1318   else if (wiringPiMode == WPI_MODE_PINS)
1319     bcmGpioPin = pinToGpio [pin] ;
1320   else if (wiringPiMode == WPI_MODE_PHYS)
1321     bcmGpioPin = physToGpio [pin] ;
1322   else
1323     bcmGpioPin = pin ;
1324
1325 // Now export the pin and set the right edge
1326 //      We're going to use the gpio program to do this, so it assumes
1327 //      a full installation of wiringPi. It's a bit 'clunky', but it
1328 //      is a way that will work when we're running in "Sys" mode, as
1329 //      a non-root user. (without sudo)
1330
1331   if (mode != INT_EDGE_SETUP)
1332   {
1333     /**/ if (mode == INT_EDGE_FALLING)
1334       modeS = "falling" ;
1335     else if (mode == INT_EDGE_RISING)
1336       modeS = "rising" ;
1337     else
1338       modeS = "both" ;
1339
1340     sprintf (pinS, "%d", bcmGpioPin) ;
1341
1342     if ((pid = fork ()) < 0)    // Fail
1343       return wiringPiFailure (WPI_FATAL, "wiringPiISR: fork failed: %s\n", strerror (errno)) ;
1344
1345     if (pid == 0)       // Child, exec
1346     {
1347       execl ("/usr/local/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
1348       return wiringPiFailure (WPI_FATAL, "wiringPiISR: execl failed: %s\n", strerror (errno)) ;
1349     }
1350     else                // Parent, wait
1351       wait (NULL) ;
1352   }
1353
1354 // Now pre-open the /sys/class node - but it may already be open if
1355 //      we are in Sys mode...
1356
1357   if (sysFds [bcmGpioPin] == -1)
1358   {
1359     sprintf (fName, "/sys/class/gpio/gpio%d/value", bcmGpioPin) ;
1360     if ((sysFds [bcmGpioPin] = open (fName, O_RDWR)) < 0)
1361       return wiringPiFailure (WPI_FATAL, "wiringPiISR: unable to open %s: %s\n", fName, strerror (errno)) ;
1362   }
1363
1364 // Clear any initial pending interrupt
1365
1366   ioctl (sysFds [bcmGpioPin], FIONREAD, &count) ;
1367   for (i = 0 ; i < count ; ++i)
1368     read (sysFds [bcmGpioPin], &c, 1) ;
1369
1370   isrFunctions [pin] = function ;
1371
1372   pthread_mutex_lock (&pinMutex) ;
1373     pinPass = pin ;
1374     pthread_create (&threadId, NULL, interruptHandler, NULL) ;
1375     while (pinPass != -1)
1376       delay (1) ;
1377   pthread_mutex_unlock (&pinMutex) ;
1378
1379   return 0 ;
1380 }
1381
1382
1383 /*
1384  * initialiseEpoch:
1385  *      Initialise our start-of-time variable to be the current unix
1386  *      time in milliseconds and microseconds.
1387  *********************************************************************************
1388  */
1389
1390 static void initialiseEpoch (void)
1391 {
1392   struct timeval tv ;
1393
1394   gettimeofday (&tv, NULL) ;
1395   epochMilli = (uint64_t)tv.tv_sec * (uint64_t)1000    + (uint64_t)(tv.tv_usec / 1000) ;
1396   epochMicro = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)(tv.tv_usec) ;
1397 }
1398
1399
1400 /*
1401  * delay:
1402  *      Wait for some number of milliseconds
1403  *********************************************************************************
1404  */
1405
1406 void delay (unsigned int howLong)
1407 {
1408   struct timespec sleeper, dummy ;
1409
1410   sleeper.tv_sec  = (time_t)(howLong / 1000) ;
1411   sleeper.tv_nsec = (long)(howLong % 1000) * 1000000 ;
1412
1413   nanosleep (&sleeper, &dummy) ;
1414 }
1415
1416
1417 /*
1418  * delayMicroseconds:
1419  *      This is somewhat intersting. It seems that on the Pi, a single call
1420  *      to nanosleep takes some 80 to 130 microseconds anyway, so while
1421  *      obeying the standards (may take longer), it's not always what we
1422  *      want!
1423  *
1424  *      So what I'll do now is if the delay is less than 100uS we'll do it
1425  *      in a hard loop, watching a built-in counter on the ARM chip. This is
1426  *      somewhat sub-optimal in that it uses 100% CPU, something not an issue
1427  *      in a microcontroller, but under a multi-tasking, multi-user OS, it's
1428  *      wastefull, however we've no real choice )-:
1429  *
1430  *      Plan B: It seems all might not be well with that plan, so changing it
1431  *      to use gettimeofday () and poll on that instead...
1432  *********************************************************************************
1433  */
1434
1435 void delayMicrosecondsHard (unsigned int howLong)
1436 {
1437   struct timeval tNow, tLong, tEnd ;
1438
1439   gettimeofday (&tNow, NULL) ;
1440   tLong.tv_sec  = howLong / 1000000 ;
1441   tLong.tv_usec = howLong % 1000000 ;
1442   timeradd (&tNow, &tLong, &tEnd) ;
1443
1444   while (timercmp (&tNow, &tEnd, <))
1445     gettimeofday (&tNow, NULL) ;
1446 }
1447
1448 void delayMicroseconds (unsigned int howLong)
1449 {
1450   struct timespec sleeper ;
1451   unsigned int uSecs = howLong % 1000000 ;
1452   unsigned int wSecs = howLong / 1000000 ;
1453
1454   /**/ if (howLong ==   0)
1455     return ;
1456   else if (howLong  < 100)
1457     delayMicrosecondsHard (howLong) ;
1458   else
1459   {
1460     sleeper.tv_sec  = wSecs ;
1461     sleeper.tv_nsec = (long)(uSecs * 1000L) ;
1462     nanosleep (&sleeper, NULL) ;
1463   }
1464 }
1465
1466
1467 /*
1468  * millis:
1469  *      Return a number of milliseconds as an unsigned int.
1470  *********************************************************************************
1471  */
1472
1473 unsigned int millis (void)
1474 {
1475   struct timeval tv ;
1476   uint64_t now ;
1477
1478   gettimeofday (&tv, NULL) ;
1479   now  = (uint64_t)tv.tv_sec * (uint64_t)1000 + (uint64_t)(tv.tv_usec / 1000) ;
1480
1481   return (uint32_t)(now - epochMilli) ;
1482 }
1483
1484
1485 /*
1486  * micros:
1487  *      Return a number of microseconds as an unsigned int.
1488  *********************************************************************************
1489  */
1490
1491 unsigned int micros (void)
1492 {
1493   struct timeval tv ;
1494   uint64_t now ;
1495
1496   gettimeofday (&tv, NULL) ;
1497   now  = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)tv.tv_usec ;
1498
1499   return (uint32_t)(now - epochMicro) ;
1500 }
1501
1502
1503 /*
1504  * wiringPiSetup:
1505  *      Must be called once at the start of your program execution.
1506  *
1507  * Default setup: Initialises the system into wiringPi Pin mode and uses the
1508  *      memory mapped hardware directly.
1509  *********************************************************************************
1510  */
1511
1512 int wiringPiSetup (void)
1513 {
1514   int      fd ;
1515   int      boardRev ;
1516
1517   if (getenv (ENV_DEBUG) != NULL)
1518     wiringPiDebug = TRUE ;
1519
1520   if (getenv (ENV_CODES) != NULL)
1521     wiringPiReturnCodes = TRUE ;
1522
1523   if (geteuid () != 0)
1524     (void)wiringPiFailure (WPI_FATAL, "wiringPiSetup: Must be root. (Did you forget sudo?)\n") ;
1525
1526   if (wiringPiDebug)
1527     printf ("wiringPi: wiringPiSetup called\n") ;
1528
1529   boardRev = piBoardRev () ;
1530
1531   if (boardRev == 1)
1532   {
1533      pinToGpio =  pinToGpioR1 ;
1534     physToGpio = physToGpioR1 ;
1535   }
1536   else
1537   {
1538      pinToGpio =  pinToGpioR2 ;
1539     physToGpio = physToGpioR2 ;
1540   }
1541
1542 // Open the master /dev/memory device
1543
1544   if ((fd = open ("/dev/mem", O_RDWR | O_SYNC | O_CLOEXEC) ) < 0)
1545     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: Unable to open /dev/mem: %s\n", strerror (errno)) ;
1546
1547 // GPIO:
1548
1549   gpio = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_BASE) ;
1550   if ((int32_t)gpio == -1)
1551     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (GPIO) failed: %s\n", strerror (errno)) ;
1552
1553 // PWM
1554
1555   pwm = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PWM) ;
1556   if ((int32_t)pwm == -1)
1557     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (PWM) failed: %s\n", strerror (errno)) ;
1558  
1559 // Clock control (needed for PWM)
1560
1561   clk = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, CLOCK_BASE) ;
1562   if ((int32_t)clk == -1)
1563     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (CLOCK) failed: %s\n", strerror (errno)) ;
1564  
1565 // The drive pads
1566
1567   pads = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PADS) ;
1568   if ((int32_t)pads == -1)
1569     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (PADS) failed: %s\n", strerror (errno)) ;
1570
1571 #ifdef  USE_TIMER
1572 // The system timer
1573
1574   timer = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_TIMER) ;
1575   if ((int32_t)timer == -1)
1576     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (TIMER) failed: %s\n", strerror (errno)) ;
1577
1578 // Set the timer to free-running, 1MHz.
1579 //      0xF9 is 249, the timer divide is base clock / (divide+1)
1580 //      so base clock is 250MHz / 250 = 1MHz.
1581
1582   *(timer + TIMER_CONTROL) = 0x0000280 ;
1583   *(timer + TIMER_PRE_DIV) = 0x00000F9 ;
1584   timerIrqRaw = timer + TIMER_IRQ_RAW ;
1585 #endif
1586
1587   initialiseEpoch () ;
1588
1589   wiringPiMode = WPI_MODE_PINS ;
1590
1591   return 0 ;
1592 }
1593
1594
1595 /*
1596  * wiringPiSetupGpio:
1597  *      Must be called once at the start of your program execution.
1598  *
1599  * GPIO setup: Initialises the system into GPIO Pin mode and uses the
1600  *      memory mapped hardware directly.
1601  *********************************************************************************
1602  */
1603
1604 int wiringPiSetupGpio (void)
1605 {
1606   (void)wiringPiSetup () ;
1607
1608   if (wiringPiDebug)
1609     printf ("wiringPi: wiringPiSetupGpio called\n") ;
1610
1611   wiringPiMode = WPI_MODE_GPIO ;
1612
1613   return 0 ;
1614 }
1615
1616
1617 /*
1618  * wiringPiSetupPhys:
1619  *      Must be called once at the start of your program execution.
1620  *
1621  * Phys setup: Initialises the system into Physical Pin mode and uses the
1622  *      memory mapped hardware directly.
1623  *********************************************************************************
1624  */
1625
1626 int wiringPiSetupPhys (void)
1627 {
1628   (void)wiringPiSetup () ;
1629
1630   if (wiringPiDebug)
1631     printf ("wiringPi: wiringPiSetupPhys called\n") ;
1632
1633   wiringPiMode = WPI_MODE_PHYS ;
1634
1635   return 0 ;
1636 }
1637
1638
1639 /*
1640  * wiringPiSetupSys:
1641  *      Must be called once at the start of your program execution.
1642  *
1643  * Initialisation (again), however this time we are using the /sys/class/gpio
1644  *      interface to the GPIO systems - slightly slower, but always usable as
1645  *      a non-root user, assuming the devices are already exported and setup correctly.
1646  */
1647
1648 int wiringPiSetupSys (void)
1649 {
1650   int boardRev ;
1651   int pin ;
1652   char fName [128] ;
1653
1654   if (getenv (ENV_DEBUG) != NULL)
1655     wiringPiDebug = TRUE ;
1656
1657   if (getenv (ENV_CODES) != NULL)
1658     wiringPiReturnCodes = TRUE ;
1659
1660   if (wiringPiDebug)
1661     printf ("wiringPi: wiringPiSetupSys called\n") ;
1662
1663   boardRev = piBoardRev () ;
1664
1665   if (boardRev == 1)
1666   {
1667      pinToGpio =  pinToGpioR1 ;
1668     physToGpio = physToGpioR1 ;
1669   }
1670   else
1671   {
1672      pinToGpio =  pinToGpioR2 ;
1673     physToGpio = physToGpioR2 ;
1674   }
1675
1676 // Open and scan the directory, looking for exported GPIOs, and pre-open
1677 //      the 'value' interface to speed things up for later
1678   
1679   for (pin = 0 ; pin < 64 ; ++pin)
1680   {
1681     sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1682     sysFds [pin] = open (fName, O_RDWR) ;
1683   }
1684
1685   initialiseEpoch () ;
1686
1687   wiringPiMode = WPI_MODE_GPIO_SYS ;
1688
1689   return 0 ;
1690 }