Gordons Projects

--> Projects Top-Level GIT

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