Gordons Projects

--> Projects Top-Level GIT

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