Gordons Projects

--> Projects Top-Level GIT

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