Gordons Projects

--> Projects Top-Level GIT

586b148e74b2e9c85e3bc25887b2ed43d8841eb7
[wiringPi] / wiringPi / wiringPi.c
1 /*
2  * wiringPi:
3  *      Arduino look-a-like Wiring library for the Raspberry Pi
4  *      Copyright (c) 2012-2017 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 #include <asm/ioctl.h>
73
74 #include "softPwm.h"
75 #include "softTone.h"
76
77 #include "wiringPi.h"
78 #include "../version.h"
79
80 // Environment Variables
81
82 #define ENV_DEBUG       "WIRINGPI_DEBUG"
83 #define ENV_CODES       "WIRINGPI_CODES"
84 #define ENV_GPIOMEM     "WIRINGPI_GPIOMEM"
85
86
87 // Extend wiringPi with other pin-based devices and keep track of
88 //      them in this structure
89
90 struct wiringPiNodeStruct *wiringPiNodes = NULL ;
91
92 // BCM Magic
93
94 #define BCM_PASSWORD            0x5A000000
95
96
97 // The BCM2835 has 54 GPIO pins.
98 //      BCM2835 data sheet, Page 90 onwards.
99 //      There are 6 control registers, each control the functions of a block
100 //      of 10 pins.
101 //      Each control register has 10 sets of 3 bits per GPIO pin - the ALT values
102 //
103 //      000 = GPIO Pin X is an input
104 //      001 = GPIO Pin X is an output
105 //      100 = GPIO Pin X takes alternate function 0
106 //      101 = GPIO Pin X takes alternate function 1
107 //      110 = GPIO Pin X takes alternate function 2
108 //      111 = GPIO Pin X takes alternate function 3
109 //      011 = GPIO Pin X takes alternate function 4
110 //      010 = GPIO Pin X takes alternate function 5
111 //
112 // So the 3 bits for port X are:
113 //      X / 10 + ((X % 10) * 3)
114
115 // Port function select bits
116
117 #define FSEL_INPT               0b000
118 #define FSEL_OUTP               0b001
119 #define FSEL_ALT0               0b100
120 #define FSEL_ALT1               0b101
121 #define FSEL_ALT2               0b110
122 #define FSEL_ALT3               0b111
123 #define FSEL_ALT4               0b011
124 #define FSEL_ALT5               0b010
125
126 // Access from ARM Running Linux
127 //      Taken from Gert/Doms code. Some of this is not in the manual
128 //      that I can find )-:
129 //
130 // Updates in September 2015 - all now static variables (and apologies for the caps)
131 //      due to the Pi v2, v3, etc. and the new /dev/gpiomem interface
132
133 static volatile unsigned int GPIO_PADS ;
134 static volatile unsigned int GPIO_CLOCK_BASE ;
135 static volatile unsigned int GPIO_BASE ;
136 static volatile unsigned int GPIO_TIMER ;
137 static volatile unsigned int GPIO_PWM ;
138
139 #define PAGE_SIZE               (4*1024)
140 #define BLOCK_SIZE              (4*1024)
141
142 static unsigned int usingGpioMem    = FALSE ;
143 static          int wiringPiSetuped = FALSE ;
144
145 // PWM
146 //      Word offsets into the PWM control region
147
148 #define PWM_CONTROL 0
149 #define PWM_STATUS  1
150 #define PWM0_RANGE  4
151 #define PWM0_DATA   5
152 #define PWM1_RANGE  8
153 #define PWM1_DATA   9
154
155 //      Clock regsiter offsets
156
157 #define PWMCLK_CNTL     40
158 #define PWMCLK_DIV      41
159
160 #define PWM0_MS_MODE    0x0080  // Run in MS mode
161 #define PWM0_USEFIFO    0x0020  // Data from FIFO
162 #define PWM0_REVPOLAR   0x0010  // Reverse polarity
163 #define PWM0_OFFSTATE   0x0008  // Ouput Off state
164 #define PWM0_REPEATFF   0x0004  // Repeat last value if FIFO empty
165 #define PWM0_SERIAL     0x0002  // Run in serial mode
166 #define PWM0_ENABLE     0x0001  // Channel Enable
167
168 #define PWM1_MS_MODE    0x8000  // Run in MS mode
169 #define PWM1_USEFIFO    0x2000  // Data from FIFO
170 #define PWM1_REVPOLAR   0x1000  // Reverse polarity
171 #define PWM1_OFFSTATE   0x0800  // Ouput Off state
172 #define PWM1_REPEATFF   0x0400  // Repeat last value if FIFO empty
173 #define PWM1_SERIAL     0x0200  // Run in serial mode
174 #define PWM1_ENABLE     0x0100  // Channel Enable
175
176 // Timer
177 //      Word offsets
178
179 #define TIMER_LOAD      (0x400 >> 2)
180 #define TIMER_VALUE     (0x404 >> 2)
181 #define TIMER_CONTROL   (0x408 >> 2)
182 #define TIMER_IRQ_CLR   (0x40C >> 2)
183 #define TIMER_IRQ_RAW   (0x410 >> 2)
184 #define TIMER_IRQ_MASK  (0x414 >> 2)
185 #define TIMER_RELOAD    (0x418 >> 2)
186 #define TIMER_PRE_DIV   (0x41C >> 2)
187 #define TIMER_COUNTER   (0x420 >> 2)
188
189 // Locals to hold pointers to the hardware
190
191 static volatile unsigned int *gpio ;
192 static volatile unsigned int *pwm ;
193 static volatile unsigned int *clk ;
194 static volatile unsigned int *pads ;
195 static volatile unsigned int *timer ;
196 static volatile unsigned int *timerIrqRaw ;
197
198 // Export variables for the hardware pointers
199
200 volatile unsigned int *_wiringPiGpio ;
201 volatile unsigned int *_wiringPiPwm ;
202 volatile unsigned int *_wiringPiClk ;
203 volatile unsigned int *_wiringPiPads ;
204 volatile unsigned int *_wiringPiTimer ;
205 volatile unsigned int *_wiringPiTimerIrqRaw ;
206
207
208 // Data for use with the boardId functions.
209 //      The order of entries here to correspond with the PI_MODEL_X
210 //      and PI_VERSION_X defines in wiringPi.h
211 //      Only intended for the gpio command - use at your own risk!
212
213 // piGpioBase:
214 //      The base address of the GPIO memory mapped hardware IO
215
216 #define GPIO_PERI_BASE_OLD      0x20000000
217 #define GPIO_PERI_BASE_NEW      0x3F000000
218
219 static volatile unsigned int piGpioBase = 0 ;
220
221 const char *piModelNames [16] =
222 {
223   "Model A",    //  0
224   "Model B",    //  1
225   "Model A+",   //  2
226   "Model B+",   //  3
227   "Pi 2",       //  4
228   "Alpha",      //  5
229   "CM",         //  6
230   "Unknown07",  // 07
231   "Pi 3",       // 08
232   "Pi Zero",    // 09
233   "CM3",        // 10
234   "Unknown11",  // 11
235   "Pi Zero-W",  // 12
236   "Pi 3+",      // 13
237   "Unknown14",  // 14
238   "Unknown15",  // 15
239 } ;
240
241 const char *piRevisionNames [16] =
242 {
243   "00",
244   "01",
245   "02",
246   "03",
247   "04",
248   "05",
249   "06",
250   "07",
251   "08",
252   "09",
253   "10",
254   "11",
255   "12",
256   "13",
257   "14",
258   "15",
259 } ;
260
261 const char *piMakerNames [16] =
262 {
263   "Sony",       //       0
264   "Egoman",     //       1
265   "Embest",     //       2
266   "Unknown",    //       3
267   "Embest",     //       4
268   "Unknown05",  //       5
269   "Unknown06",  //       6
270   "Unknown07",  //       7
271   "Unknown08",  //       8
272   "Unknown09",  //       9
273   "Unknown10",  //      10
274   "Unknown11",  //      11
275   "Unknown12",  //      12
276   "Unknown13",  //      13
277   "Unknown14",  //      14
278   "Unknown15",  //      15
279 } ;
280
281 const int piMemorySize [8] =
282 {
283    256,         //       0
284    512,         //       1
285   1024,         //       2
286      0,         //       3
287      0,         //       4
288      0,         //       5
289      0,         //       6
290      0,         //       7
291 } ;
292
293 // Time for easy calculations
294
295 static uint64_t epochMilli, epochMicro ;
296
297 // Misc
298
299 static int wiringPiMode = WPI_MODE_UNINITIALISED ;
300 static volatile int    pinPass = -1 ;
301 static pthread_mutex_t pinMutex ;
302
303 // Debugging & Return codes
304
305 int wiringPiDebug       = FALSE ;
306 int wiringPiReturnCodes = FALSE ;
307
308 // Use /dev/gpiomem ?
309
310 int wiringPiTryGpioMem  = FALSE ;
311
312 // sysFds:
313 //      Map a file descriptor from the /sys/class/gpio/gpioX/value
314
315 static int sysFds [64] =
316 {
317   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
318   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
319   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
320   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
321 } ;
322
323 // ISR Data
324
325 static void (*isrFunctions [64])(void) ;
326
327
328 // Doing it the Arduino way with lookup tables...
329 //      Yes, it's probably more innefficient than all the bit-twidling, but it
330 //      does tend to make it all a bit clearer. At least to me!
331
332 // pinToGpio:
333 //      Take a Wiring pin (0 through X) and re-map it to the BCM_GPIO pin
334 //      Cope for 3 different board revisions here.
335
336 static int *pinToGpio ;
337
338 // Revision 1, 1.1:
339
340 static int pinToGpioR1 [64] =
341 {
342   17, 18, 21, 22, 23, 24, 25, 4,        // From the Original Wiki - GPIO 0 through 7:   wpi  0 -  7
343    0,  1,                               // I2C  - SDA1, SCL1                            wpi  8 -  9
344    8,  7,                               // SPI  - CE1, CE0                              wpi 10 - 11
345   10,  9, 11,                           // SPI  - MOSI, MISO, SCLK                      wpi 12 - 14
346   14, 15,                               // UART - Tx, Rx                                wpi 15 - 16
347
348 // Padding:
349
350       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 31
351   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
352   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
353 } ;
354
355 // Revision 2:
356
357 static int pinToGpioR2 [64] =
358 {
359   17, 18, 27, 22, 23, 24, 25, 4,        // From the Original Wiki - GPIO 0 through 7:   wpi  0 -  7
360    2,  3,                               // I2C  - SDA0, SCL0                            wpi  8 -  9
361    8,  7,                               // SPI  - CE1, CE0                              wpi 10 - 11
362   10,  9, 11,                           // SPI  - MOSI, MISO, SCLK                      wpi 12 - 14
363   14, 15,                               // UART - Tx, Rx                                wpi 15 - 16
364   28, 29, 30, 31,                       // Rev 2: New GPIOs 8 though 11                 wpi 17 - 20
365    5,  6, 13, 19, 26,                   // B+                                           wpi 21, 22, 23, 24, 25
366   12, 16, 20, 21,                       // B+                                           wpi 26, 27, 28, 29
367    0,  1,                               // B+                                           wpi 30, 31
368
369 // Padding:
370
371   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
372   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
373 } ;
374
375
376 // physToGpio:
377 //      Take a physical pin (1 through 26) and re-map it to the BCM_GPIO pin
378 //      Cope for 2 different board revisions here.
379 //      Also add in the P5 connector, so the P5 pins are 3,4,5,6, so 53,54,55,56
380
381 static int *physToGpio ;
382
383 static int physToGpioR1 [64] =
384 {
385   -1,           // 0
386   -1, -1,       // 1, 2
387    0, -1,
388    1, -1,
389    4, 14,
390   -1, 15,
391   17, 18,
392   21, -1,
393   22, 23,
394   -1, 24,
395   10, -1,
396    9, 25,
397   11,  8,
398   -1,  7,       // 25, 26
399
400                                               -1, -1, -1, -1, -1,       // ... 31
401   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
402   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
403 } ;
404
405 static int physToGpioR2 [64] =
406 {
407   -1,           // 0
408   -1, -1,       // 1, 2
409    2, -1,
410    3, -1,
411    4, 14,
412   -1, 15,
413   17, 18,
414   27, -1,
415   22, 23,
416   -1, 24,
417   10, -1,
418    9, 25,
419   11,  8,
420   -1,  7,       // 25, 26
421
422 // B+
423
424    0,  1,
425    5, -1,
426    6, 12,
427   13, -1,
428   19, 16,
429   26, 20,
430   -1, 21,
431
432 // the P5 connector on the Rev 2 boards:
433
434   -1, -1,
435   -1, -1,
436   -1, -1,
437   -1, -1,
438   -1, -1,
439   28, 29,
440   30, 31,
441   -1, -1,
442   -1, -1,
443   -1, -1,
444   -1, -1,
445 } ;
446
447 // gpioToGPFSEL:
448 //      Map a BCM_GPIO pin to it's Function Selection
449 //      control port. (GPFSEL 0-5)
450 //      Groups of 10 - 3 bits per Function - 30 bits per port
451
452 static uint8_t gpioToGPFSEL [] =
453 {
454   0,0,0,0,0,0,0,0,0,0,
455   1,1,1,1,1,1,1,1,1,1,
456   2,2,2,2,2,2,2,2,2,2,
457   3,3,3,3,3,3,3,3,3,3,
458   4,4,4,4,4,4,4,4,4,4,
459   5,5,5,5,5,5,5,5,5,5,
460 } ;
461
462
463 // gpioToShift
464 //      Define the shift up for the 3 bits per pin in each GPFSEL port
465
466 static uint8_t gpioToShift [] =
467 {
468   0,3,6,9,12,15,18,21,24,27,
469   0,3,6,9,12,15,18,21,24,27,
470   0,3,6,9,12,15,18,21,24,27,
471   0,3,6,9,12,15,18,21,24,27,
472   0,3,6,9,12,15,18,21,24,27,
473   0,3,6,9,12,15,18,21,24,27,
474 } ;
475
476
477 // gpioToGPSET:
478 //      (Word) offset to the GPIO Set registers for each GPIO pin
479
480 static uint8_t gpioToGPSET [] =
481 {
482    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,
483    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,
484 } ;
485
486 // gpioToGPCLR:
487 //      (Word) offset to the GPIO Clear registers for each GPIO pin
488
489 static uint8_t gpioToGPCLR [] =
490 {
491   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,
492   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,
493 } ;
494
495
496 // gpioToGPLEV:
497 //      (Word) offset to the GPIO Input level registers for each GPIO pin
498
499 static uint8_t gpioToGPLEV [] =
500 {
501   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,
502   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,
503 } ;
504
505
506 #ifdef notYetReady
507 // gpioToEDS
508 //      (Word) offset to the Event Detect Status
509
510 static uint8_t gpioToEDS [] =
511 {
512   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,
513   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,
514 } ;
515
516 // gpioToREN
517 //      (Word) offset to the Rising edge ENable register
518
519 static uint8_t gpioToREN [] =
520 {
521   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,
522   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,
523 } ;
524
525 // gpioToFEN
526 //      (Word) offset to the Falling edgde ENable register
527
528 static uint8_t gpioToFEN [] =
529 {
530   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,
531   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,
532 } ;
533 #endif
534
535
536 // GPPUD:
537 //      GPIO Pin pull up/down register
538
539 #define GPPUD   37
540
541 // gpioToPUDCLK
542 //      (Word) offset to the Pull Up Down Clock regsiter
543
544 static uint8_t gpioToPUDCLK [] =
545 {
546   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,
547   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,
548 } ;
549
550
551 // gpioToPwmALT
552 //      the ALT value to put a GPIO pin into PWM mode
553
554 static uint8_t gpioToPwmALT [] =
555 {
556           0,         0,         0,         0,         0,         0,         0,         0,       //  0 ->  7
557           0,         0,         0,         0, FSEL_ALT0, FSEL_ALT0,         0,         0,       //  8 -> 15
558           0,         0, FSEL_ALT5, FSEL_ALT5,         0,         0,         0,         0,       // 16 -> 23
559           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
560           0,         0,         0,         0,         0,         0,         0,         0,       // 32 -> 39
561   FSEL_ALT0, FSEL_ALT0,         0,         0,         0, FSEL_ALT0,         0,         0,       // 40 -> 47
562           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
563           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
564 } ;
565
566
567 // gpioToPwmPort
568 //      The port value to put a GPIO pin into PWM mode
569
570 static uint8_t gpioToPwmPort [] =
571 {
572           0,         0,         0,         0,         0,         0,         0,         0,       //  0 ->  7
573           0,         0,         0,         0, PWM0_DATA, PWM1_DATA,         0,         0,       //  8 -> 15
574           0,         0, PWM0_DATA, PWM1_DATA,         0,         0,         0,         0,       // 16 -> 23
575           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
576           0,         0,         0,         0,         0,         0,         0,         0,       // 32 -> 39
577   PWM0_DATA, PWM1_DATA,         0,         0,         0, PWM1_DATA,         0,         0,       // 40 -> 47
578           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
579           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
580
581 } ;
582
583 // gpioToGpClkALT:
584 //      ALT value to put a GPIO pin into GP Clock mode.
585 //      On the Pi we can really only use BCM_GPIO_4 and BCM_GPIO_21
586 //      for clocks 0 and 1 respectively, however I'll include the full
587 //      list for completeness - maybe one day...
588
589 #define GPIO_CLOCK_SOURCE       1
590
591 // gpioToGpClkALT0:
592
593 static uint8_t gpioToGpClkALT0 [] =
594 {
595           0,         0,         0,         0, FSEL_ALT0, FSEL_ALT0, FSEL_ALT0,         0,       //  0 ->  7
596           0,         0,         0,         0,         0,         0,         0,         0,       //  8 -> 15
597           0,         0,         0,         0, FSEL_ALT5, FSEL_ALT5,         0,         0,       // 16 -> 23
598           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
599   FSEL_ALT0,         0, FSEL_ALT0,         0,         0,         0,         0,         0,       // 32 -> 39
600           0,         0, FSEL_ALT0, FSEL_ALT0, FSEL_ALT0,         0,         0,         0,       // 40 -> 47
601           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
602           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
603 } ;
604
605 // gpioToClk:
606 //      (word) Offsets to the clock Control and Divisor register
607
608 static uint8_t gpioToClkCon [] =
609 {
610          -1,        -1,        -1,        -1,        28,        30,        32,        -1,       //  0 ->  7
611          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       //  8 -> 15
612          -1,        -1,        -1,        -1,        28,        30,        -1,        -1,       // 16 -> 23
613          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 24 -> 31
614          28,        -1,        28,        -1,        -1,        -1,        -1,        -1,       // 32 -> 39
615          -1,        -1,        28,        30,        28,        -1,        -1,        -1,       // 40 -> 47
616          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 48 -> 55
617          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 56 -> 63
618 } ;
619
620 static uint8_t gpioToClkDiv [] =
621 {
622          -1,        -1,        -1,        -1,        29,        31,        33,        -1,       //  0 ->  7
623          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       //  8 -> 15
624          -1,        -1,        -1,        -1,        29,        31,        -1,        -1,       // 16 -> 23
625          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 24 -> 31
626          29,        -1,        29,        -1,        -1,        -1,        -1,        -1,       // 32 -> 39
627          -1,        -1,        29,        31,        29,        -1,        -1,        -1,       // 40 -> 47
628          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 48 -> 55
629          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 56 -> 63
630 } ;
631
632
633 /*
634  * Functions
635  *********************************************************************************
636  */
637
638
639 /*
640  * wiringPiFailure:
641  *      Fail. Or not.
642  *********************************************************************************
643  */
644
645 int wiringPiFailure (int fatal, const char *message, ...)
646 {
647   va_list argp ;
648   char buffer [1024] ;
649
650   if (!fatal && wiringPiReturnCodes)
651     return -1 ;
652
653   va_start (argp, message) ;
654     vsnprintf (buffer, 1023, message, argp) ;
655   va_end (argp) ;
656
657   fprintf (stderr, "%s", buffer) ;
658   exit (EXIT_FAILURE) ;
659
660   return 0 ;
661 }
662
663
664 /*
665  * setupCheck
666  *      Another sanity check because some users forget to call the setup
667  *      function. Mosty because they need feeding C drip by drip )-:
668  *********************************************************************************
669  */
670
671 static void setupCheck (const char *fName)
672 {
673   if (!wiringPiSetuped)
674   {
675     fprintf (stderr, "%s: You have not called one of the wiringPiSetup\n"
676         "  functions, so I'm aborting your program before it crashes anyway.\n", fName) ;
677     exit (EXIT_FAILURE) ;
678   }
679 }
680
681 /*
682  * gpioMemCheck:
683  *      See if we're using the /dev/gpiomem interface, if-so then some operations
684  *      can't be done and will crash the Pi.
685  *********************************************************************************
686  */
687
688 static void usingGpioMemCheck (const char *what)
689 {
690   if (usingGpioMem)
691   {
692     fprintf (stderr, "%s: Unable to do this when using /dev/gpiomem. Try sudo?\n", what) ;
693     exit (EXIT_FAILURE) ;
694   }
695 }
696
697
698
699 /*
700  * piGpioLayout:
701  *      Return a number representing the hardware revision of the board.
702  *      This is not strictly the board revision but is used to check the
703  *      layout of the GPIO connector - and there are 2 types that we are
704  *      really interested in here. The very earliest Pi's and the
705  *      ones that came after that which switched some pins ....
706  *
707  *      Revision 1 really means the early Model A and B's.
708  *      Revision 2 is everything else - it covers the B, B+ and CM.
709  *              ... and the Pi 2 - which is a B+ ++  ...
710  *              ... and the Pi 0 - which is an A+ ...
711  *
712  *      The main difference between the revision 1 and 2 system that I use here
713  *      is the mapping of the GPIO pins. From revision 2, the Pi Foundation changed
714  *      3 GPIO pins on the (original) 26-way header - BCM_GPIO 22 was dropped and
715  *      replaced with 27, and 0 + 1 - I2C bus 0 was changed to 2 + 3; I2C bus 1.
716  *
717  *      Additionally, here we set the piModel2 flag too. This is again, nothing to
718  *      do with the actual model, but the major version numbers - the GPIO base
719  *      hardware address changed at model 2 and above (not the Zero though)
720  *
721  *********************************************************************************
722  */
723
724 static void piGpioLayoutOops (const char *why)
725 {
726   fprintf (stderr, "Oops: Unable to determine board revision from /proc/cpuinfo\n") ;
727   fprintf (stderr, " -> %s\n", why) ;
728   fprintf (stderr, " ->  You'd best google the error to find out why.\n") ;
729 //fprintf (stderr, " ->  http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
730   exit (EXIT_FAILURE) ;
731 }
732
733 int piGpioLayout (void)
734 {
735   FILE *cpuFd ;
736   char line [120] ;
737   char *c ;
738   static int  gpioLayout = -1 ;
739
740   if (gpioLayout != -1) // No point checking twice
741     return gpioLayout ;
742
743   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
744     piGpioLayoutOops ("Unable to open /proc/cpuinfo") ;
745
746 // Start by looking for the Architecture to make sure we're really running
747 //      on a Pi. I'm getting fed-up with people whinging at me because
748 //      they can't get it to work on weirdFruitPi boards...
749
750   while (fgets (line, 120, cpuFd) != NULL)
751     if (strncmp (line, "Hardware", 8) == 0)
752       break ;
753
754   if (strncmp (line, "Hardware", 8) != 0)
755     piGpioLayoutOops ("No \"Hardware\" line") ;
756
757   if (wiringPiDebug)
758     printf ("piGpioLayout: Hardware: %s\n", line) ;
759
760 // See if it's BCM2708 or BCM2709 or the new BCM2835.
761
762 // OK. As of Kernel 4.8,  we have BCM2835 only, regardless of model.
763 //      However I still want to check because it will trap the cheapskates and rip-
764 //      off merchants who want to use wiringPi on non-Raspberry Pi platforms - which
765 //      I do not support so don't email me your bleating whinges about anything
766 //      other than a genuine Raspberry Pi.
767
768 #ifdef  DONT_CARE_ANYMORE
769   if (! (strstr (line, "BCM2708") || strstr (line, "BCM2709") || strstr (line, "BCM2835")))
770   {
771     fprintf (stderr, "Unable to determine hardware version. I see: %s,\n", line) ;
772     fprintf (stderr, " - expecting BCM2708, BCM2709 or BCM2835.\n") ;
773     fprintf (stderr, "If this is a genuine Raspberry Pi then please report this\n") ;
774     fprintf (stderr, "to projects@drogon.net. If this is not a Raspberry Pi then you\n") ;
775     fprintf (stderr, "are on your own as wiringPi is designed to support the\n") ;
776     fprintf (stderr, "Raspberry Pi ONLY.\n") ;
777     exit (EXIT_FAILURE) ;
778   }
779 #endif
780
781 // Actually... That has caused me more than 10,000 emails so-far. Mosty by
782 //      people who think they know better by creating a statically linked
783 //      version that will not run with a new 4.9 kernel. I utterly hate and
784 //      despise those people.
785 //
786 //      I also get bleats from people running other than Raspbian with another
787 //      distros compiled kernel rather than a foundation compiled kernel, so
788 //      this might actually help them. It might not - I only have the capacity
789 //      to support Raspbian.
790 //
791 //      However, I've decided to leave this check out and rely purely on the
792 //      Revision: line for now. It will not work on a non-pi hardware or weird
793 //      kernels that don't give you a suitable revision line.
794
795 // So - we're Probably on a Raspberry Pi. Check the revision field for the real
796 //      hardware type
797 //      In-future, I ought to use the device tree as there are now Pi entries in
798 //      /proc/device-tree/ ...
799 //      but I'll leave that for the next revision. Or the next.
800
801 // Isolate the Revision line
802
803   rewind (cpuFd) ;
804   while (fgets (line, 120, cpuFd) != NULL)
805     if (strncmp (line, "Revision", 8) == 0)
806       break ;
807
808   fclose (cpuFd) ;
809
810   if (strncmp (line, "Revision", 8) != 0)
811     piGpioLayoutOops ("No \"Revision\" line") ;
812
813 // Chomp trailing CR/NL
814
815   for (c = &line [strlen (line) - 1] ; (*c == '\n') || (*c == '\r') ; --c)
816     *c = 0 ;
817   
818   if (wiringPiDebug)
819     printf ("piGpioLayout: Revision string: %s\n", line) ;
820
821 // Scan to the first character of the revision number
822
823   for (c = line ; *c ; ++c)
824     if (*c == ':')
825       break ;
826
827   if (*c != ':')
828     piGpioLayoutOops ("Bogus \"Revision\" line (no colon)") ;
829
830 // Chomp spaces
831
832   ++c ;
833   while (isspace (*c))
834     ++c ;
835
836   if (!isxdigit (*c))
837     piGpioLayoutOops ("Bogus \"Revision\" line (no hex digit at start of revision)") ;
838
839 // Make sure its long enough
840
841   if (strlen (c) < 4)
842     piGpioLayoutOops ("Bogus revision line (too small)") ;
843
844 // Isolate  last 4 characters: (in-case of overvolting or new encoding scheme)
845
846   c = c + strlen (c) - 4 ;
847
848   if (wiringPiDebug)
849     printf ("piGpioLayout: last4Chars are: \"%s\"\n", c) ;
850
851   if ( (strcmp (c, "0002") == 0) || (strcmp (c, "0003") == 0))
852     gpioLayout = 1 ;
853   else
854     gpioLayout = 2 ;    // Covers everything else from the B revision 2 to the B+, the Pi v2, v3, zero and CM's.
855
856   if (wiringPiDebug)
857     printf ("piGpioLayoutOops: Returning revision: %d\n", gpioLayout) ;
858
859   return gpioLayout ;
860 }
861
862 /*
863  * piBoardRev:
864  *      Deprecated, but does the same as piGpioLayout
865  *********************************************************************************
866  */
867
868 int piBoardRev (void)
869 {
870   return piGpioLayout () ;
871 }
872
873
874
875 /*
876  * piBoardId:
877  *      Return the real details of the board we have.
878  *
879  *      This is undocumented and really only intended for the GPIO command.
880  *      Use at your own risk!
881  *
882  *      Seems there are some boards with 0000 in them (mistake in manufacture)
883  *      So the distinction between boards that I can see is:
884  *
885  *              0000 - Error
886  *              0001 - Not used 
887  *
888  *      Original Pi boards:
889  *              0002 - Model B,  Rev 1,   256MB, Egoman
890  *              0003 - Model B,  Rev 1.1, 256MB, Egoman, Fuses/D14 removed.
891  *
892  *      Newer Pi's with remapped GPIO:
893  *              0004 - Model B,  Rev 1.2, 256MB, Sony
894  *              0005 - Model B,  Rev 1.2, 256MB, Egoman
895  *              0006 - Model B,  Rev 1.2, 256MB, Egoman
896  *
897  *              0007 - Model A,  Rev 1.2, 256MB, Egoman
898  *              0008 - Model A,  Rev 1.2, 256MB, Sony
899  *              0009 - Model A,  Rev 1.2, 256MB, Egoman
900  *
901  *              000d - Model B,  Rev 1.2, 512MB, Egoman (Red Pi, Blue Pi?)
902  *              000e - Model B,  Rev 1.2, 512MB, Sony
903  *              000f - Model B,  Rev 1.2, 512MB, Egoman
904  *
905  *              0010 - Model B+, Rev 1.2, 512MB, Sony
906  *              0013 - Model B+  Rev 1.2, 512MB, Embest
907  *              0016 - Model B+  Rev 1.2, 512MB, Sony
908  *              0019 - Model B+  Rev 1.2, 512MB, Egoman
909  *
910  *              0011 - Pi CM,    Rev 1.1, 512MB, Sony
911  *              0014 - Pi CM,    Rev 1.1, 512MB, Embest
912  *              0017 - Pi CM,    Rev 1.1, 512MB, Sony
913  *              001a - Pi CM,    Rev 1.1, 512MB, Egoman
914  *
915  *              0012 - Model A+  Rev 1.1, 256MB, Sony
916  *              0015 - Model A+  Rev 1.1, 512MB, Embest
917  *              0018 - Model A+  Rev 1.1, 256MB, Sony
918  *              001b - Model A+  Rev 1.1, 256MB, Egoman
919  *
920  *      A small thorn is the olde style overvolting - that will add in
921  *              1000000
922  *
923  *      The Pi compute module has an revision of 0011 or 0014 - since we only
924  *      check the last digit, then it's 1, therefore it'll default to not 2 or
925  *      3 for a Rev 1, so will appear as a Rev 2. This is fine for the most part, but
926  *      we'll properly detect the Compute Module later and adjust accordingly.
927  *
928  * And then things changed with the introduction of the v2...
929  *
930  * For Pi v2 and subsequent models - e.g. the Zero:
931  *
932  *   [USER:8] [NEW:1] [MEMSIZE:3] [MANUFACTURER:4] [PROCESSOR:4] [TYPE:8] [REV:4]
933  *   NEW          23: will be 1 for the new scheme, 0 for the old scheme
934  *   MEMSIZE      20: 0=256M 1=512M 2=1G
935  *   MANUFACTURER 16: 0=SONY 1=EGOMAN 2=EMBEST
936  *   PROCESSOR    12: 0=2835 1=2836
937  *   TYPE         04: 0=MODELA 1=MODELB 2=MODELA+ 3=MODELB+ 4=Pi2 MODEL B 5=ALPHA 6=CM
938  *   REV          00: 0=REV0 1=REV1 2=REV2
939  *********************************************************************************
940  */
941
942 void piBoardId (int *model, int *rev, int *mem, int *maker, int *warranty)
943 {
944   FILE *cpuFd ;
945   char line [120] ;
946   char *c ;
947   unsigned int revision ;
948   int bRev, bType, bProc, bMfg, bMem, bWarranty ;
949
950 //      Will deal with the properly later on - for now, lets just get it going...
951 //  unsigned int modelNum ;
952
953   (void)piGpioLayout () ;       // Call this first to make sure all's OK. Don't care about the result.
954
955   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
956     piGpioLayoutOops ("Unable to open /proc/cpuinfo") ;
957
958   while (fgets (line, 120, cpuFd) != NULL)
959     if (strncmp (line, "Revision", 8) == 0)
960       break ;
961
962   fclose (cpuFd) ;
963
964   if (strncmp (line, "Revision", 8) != 0)
965     piGpioLayoutOops ("No \"Revision\" line") ;
966
967 // Chomp trailing CR/NL
968
969   for (c = &line [strlen (line) - 1] ; (*c == '\n') || (*c == '\r') ; --c)
970     *c = 0 ;
971   
972   if (wiringPiDebug)
973     printf ("piBoardId: Revision string: %s\n", line) ;
974
975 // Need to work out if it's using the new or old encoding scheme:
976
977 // Scan to the first character of the revision number
978
979   for (c = line ; *c ; ++c)
980     if (*c == ':')
981       break ;
982
983   if (*c != ':')
984     piGpioLayoutOops ("Bogus \"Revision\" line (no colon)") ;
985
986 // Chomp spaces
987
988   ++c ;
989   while (isspace (*c))
990     ++c ;
991
992   if (!isxdigit (*c))
993     piGpioLayoutOops ("Bogus \"Revision\" line (no hex digit at start of revision)") ;
994
995   revision = (unsigned int)strtol (c, NULL, 16) ; // Hex number with no leading 0x
996
997 // Check for new way:
998
999   if ((revision &  (1 << 23)) != 0)     // New way
1000   {
1001     if (wiringPiDebug)
1002       printf ("piBoardId: New Way: revision is: %08X\n", revision) ;
1003
1004     bRev      = (revision & (0x0F <<  0)) >>  0 ;
1005     bType     = (revision & (0xFF <<  4)) >>  4 ;
1006     bProc     = (revision & (0x0F << 12)) >> 12 ;       // Not used for now.
1007     bMfg      = (revision & (0x0F << 16)) >> 16 ;
1008     bMem      = (revision & (0x07 << 20)) >> 20 ;
1009     bWarranty = (revision & (0x03 << 24)) != 0 ;
1010     
1011     *model    = bType ;
1012     *rev      = bRev ;
1013     *mem      = bMem ;
1014     *maker    = bMfg  ;
1015     *warranty = bWarranty ;
1016
1017     if (wiringPiDebug)
1018       printf ("piBoardId: rev: %d, type: %d, proc: %d, mfg: %d, mem: %d, warranty: %d\n",
1019                 bRev, bType, bProc, bMfg, bMem, bWarranty) ;
1020   }
1021   else                                  // Old way
1022   {
1023     if (wiringPiDebug)
1024       printf ("piBoardId: Old Way: revision is: %s\n", c) ;
1025
1026     if (!isdigit (*c))
1027       piGpioLayoutOops ("Bogus \"Revision\" line (no digit at start of revision)") ;
1028
1029 // Make sure its long enough
1030
1031     if (strlen (c) < 4)
1032       piGpioLayoutOops ("Bogus \"Revision\" line (not long enough)") ;
1033
1034 // If longer than 4, we'll assume it's been overvolted
1035
1036     *warranty = strlen (c) > 4 ;
1037   
1038 // Extract last 4 characters:
1039
1040     c = c + strlen (c) - 4 ;
1041
1042 // Fill out the replys as appropriate
1043
1044     /**/ if (strcmp (c, "0002") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1   ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
1045     else if (strcmp (c, "0003") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_1 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
1046
1047     else if (strcmp (c, "0004") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_SONY    ; }
1048     else if (strcmp (c, "0005") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
1049     else if (strcmp (c, "0006") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
1050
1051     else if (strcmp (c, "0007") == 0) { *model = PI_MODEL_A  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
1052     else if (strcmp (c, "0008") == 0) { *model = PI_MODEL_A  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_SONY ;  ; }
1053     else if (strcmp (c, "0009") == 0) { *model = PI_MODEL_A  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
1054
1055     else if (strcmp (c, "000d") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_EGOMAN  ; }
1056     else if (strcmp (c, "000e") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_SONY    ; }
1057     else if (strcmp (c, "000f") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_EGOMAN  ; }
1058
1059     else if (strcmp (c, "0010") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_SONY    ; }
1060     else if (strcmp (c, "0013") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_EMBEST  ; }
1061     else if (strcmp (c, "0016") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_SONY    ; }
1062     else if (strcmp (c, "0019") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_EGOMAN  ; }
1063
1064     else if (strcmp (c, "0011") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_1 ; *mem = 1 ; *maker = PI_MAKER_SONY    ; }
1065     else if (strcmp (c, "0014") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_1 ; *mem = 1 ; *maker = PI_MAKER_EMBEST  ; }
1066     else if (strcmp (c, "0017") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_1 ; *mem = 1 ; *maker = PI_MAKER_SONY    ; }
1067     else if (strcmp (c, "001a") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_1 ; *mem = 1 ; *maker = PI_MAKER_EGOMAN  ; }
1068
1069     else if (strcmp (c, "0012") == 0) { *model = PI_MODEL_AP ; *rev = PI_VERSION_1_1 ; *mem = 0 ; *maker = PI_MAKER_SONY    ; }
1070     else if (strcmp (c, "0015") == 0) { *model = PI_MODEL_AP ; *rev = PI_VERSION_1_1 ; *mem = 1 ; *maker = PI_MAKER_EMBEST  ; }
1071     else if (strcmp (c, "0018") == 0) { *model = PI_MODEL_AP ; *rev = PI_VERSION_1_1 ; *mem = 0 ; *maker = PI_MAKER_SONY    ; }
1072     else if (strcmp (c, "001b") == 0) { *model = PI_MODEL_AP ; *rev = PI_VERSION_1_1 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
1073
1074     else                              { *model = 0           ; *rev = 0              ; *mem =   0 ; *maker = 0 ;               }
1075   }
1076 }
1077  
1078
1079
1080 /*
1081  * wpiPinToGpio:
1082  *      Translate a wiringPi Pin number to native GPIO pin number.
1083  *      Provided for external support.
1084  *********************************************************************************
1085  */
1086
1087 int wpiPinToGpio (int wpiPin)
1088 {
1089   return pinToGpio [wpiPin & 63] ;
1090 }
1091
1092
1093 /*
1094  * physPinToGpio:
1095  *      Translate a physical Pin number to native GPIO pin number.
1096  *      Provided for external support.
1097  *********************************************************************************
1098  */
1099
1100 int physPinToGpio (int physPin)
1101 {
1102   return physToGpio [physPin & 63] ;
1103 }
1104
1105
1106 /*
1107  * setPadDrive:
1108  *      Set the PAD driver value
1109  *********************************************************************************
1110  */
1111
1112 void setPadDrive (int group, int value)
1113 {
1114   uint32_t wrVal ;
1115
1116   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
1117   {
1118     if ((group < 0) || (group > 2))
1119       return ;
1120
1121     wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
1122     *(pads + group + 11) = wrVal ;
1123
1124     if (wiringPiDebug)
1125     {
1126       printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
1127       printf ("Read : %08X\n", *(pads + group + 11)) ;
1128     }
1129   }
1130 }
1131
1132
1133 /*
1134  * getAlt:
1135  *      Returns the ALT bits for a given port. Only really of-use
1136  *      for the gpio readall command (I think)
1137  *********************************************************************************
1138  */
1139
1140 int getAlt (int pin)
1141 {
1142   int fSel, shift, alt ;
1143
1144   pin &= 63 ;
1145
1146   /**/ if (wiringPiMode == WPI_MODE_PINS)
1147     pin = pinToGpio [pin] ;
1148   else if (wiringPiMode == WPI_MODE_PHYS)
1149     pin = physToGpio [pin] ;
1150   else if (wiringPiMode != WPI_MODE_GPIO)
1151     return 0 ;
1152
1153   fSel    = gpioToGPFSEL [pin] ;
1154   shift   = gpioToShift  [pin] ;
1155
1156   alt = (*(gpio + fSel) >> shift) & 7 ;
1157
1158   return alt ;
1159 }
1160
1161
1162 /*
1163  * pwmSetMode:
1164  *      Select the native "balanced" mode, or standard mark:space mode
1165  *********************************************************************************
1166  */
1167
1168 void pwmSetMode (int mode)
1169 {
1170   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
1171   {
1172     if (mode == PWM_MODE_MS)
1173       *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
1174     else
1175       *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
1176   }
1177 }
1178
1179
1180 /*
1181  * pwmSetRange:
1182  *      Set the PWM range register. We set both range registers to the same
1183  *      value. If you want different in your own code, then write your own.
1184  *********************************************************************************
1185  */
1186
1187 void pwmSetRange (unsigned int range)
1188 {
1189   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
1190   {
1191     *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
1192     *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
1193   }
1194 }
1195
1196
1197 /*
1198  * pwmSetClock:
1199  *      Set/Change the PWM clock. Originally my code, but changed
1200  *      (for the better!) by Chris Hall, <chris@kchall.plus.com>
1201  *      after further study of the manual and testing with a 'scope
1202  *********************************************************************************
1203  */
1204
1205 void pwmSetClock (int divisor)
1206 {
1207   uint32_t pwm_control ;
1208   divisor &= 4095 ;
1209
1210   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
1211   {
1212     if (wiringPiDebug)
1213       printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
1214
1215     pwm_control = *(pwm + PWM_CONTROL) ;                // preserve PWM_CONTROL
1216
1217 // We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY
1218 // stays high.
1219
1220     *(pwm + PWM_CONTROL) = 0 ;                          // Stop PWM
1221
1222 // Stop PWM clock before changing divisor. The delay after this does need to
1223 // this big (95uS occasionally fails, 100uS OK), it's almost as though the BUSY
1224 // flag is not working properly in balanced mode. Without the delay when DIV is
1225 // adjusted the clock sometimes switches to very slow, once slow further DIV
1226 // adjustments do nothing and it's difficult to get out of this mode.
1227
1228     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;        // Stop PWM Clock
1229       delayMicroseconds (110) ;                 // prevents clock going sloooow
1230
1231     while ((*(clk + PWMCLK_CNTL) & 0x80) != 0)  // Wait for clock to be !BUSY
1232       delayMicroseconds (1) ;
1233
1234     *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12) ;
1235
1236     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;        // Start PWM clock
1237     *(pwm + PWM_CONTROL) = pwm_control ;                // restore PWM_CONTROL
1238
1239     if (wiringPiDebug)
1240       printf ("Set     to: %d. Now    : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
1241   }
1242 }
1243
1244
1245 /*
1246  * gpioClockSet:
1247  *      Set the frequency on a GPIO clock pin
1248  *********************************************************************************
1249  */
1250
1251 void gpioClockSet (int pin, int freq)
1252 {
1253   int divi, divr, divf ;
1254
1255   pin &= 63 ;
1256
1257   /**/ if (wiringPiMode == WPI_MODE_PINS)
1258     pin = pinToGpio [pin] ;
1259   else if (wiringPiMode == WPI_MODE_PHYS)
1260     pin = physToGpio [pin] ;
1261   else if (wiringPiMode != WPI_MODE_GPIO)
1262     return ;
1263   
1264   divi = 19200000 / freq ;
1265   divr = 19200000 % freq ;
1266   divf = (int)((double)divr * 4096.0 / 19200000.0) ;
1267
1268   if (divi > 4095)
1269     divi = 4095 ;
1270
1271   *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | GPIO_CLOCK_SOURCE ;              // Stop GPIO Clock
1272   while ((*(clk + gpioToClkCon [pin]) & 0x80) != 0)                             // ... and wait
1273     ;
1274
1275   *(clk + gpioToClkDiv [pin]) = BCM_PASSWORD | (divi << 12) | divf ;            // Set dividers
1276   *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | 0x10 | GPIO_CLOCK_SOURCE ;       // Start Clock
1277 }
1278
1279
1280 /*
1281  * wiringPiFindNode:
1282  *      Locate our device node
1283  *********************************************************************************
1284  */
1285
1286 struct wiringPiNodeStruct *wiringPiFindNode (int pin)
1287 {
1288   struct wiringPiNodeStruct *node = wiringPiNodes ;
1289
1290   while (node != NULL)
1291     if ((pin >= node->pinBase) && (pin <= node->pinMax))
1292       return node ;
1293     else
1294       node = node->next ;
1295
1296   return NULL ;
1297 }
1298
1299
1300 /*
1301  * wiringPiNewNode:
1302  *      Create a new GPIO node into the wiringPi handling system
1303  *********************************************************************************
1304  */
1305
1306 static         void pinModeDummy             (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int mode)  { return ; }
1307 static         void pullUpDnControlDummy     (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int pud)   { return ; }
1308 static unsigned int digitalRead8Dummy        (UNU struct wiringPiNodeStruct *node, UNU int UNU pin)            { return 0 ; }
1309 static         void digitalWrite8Dummy       (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int value) { return ; }
1310 static          int digitalReadDummy         (UNU struct wiringPiNodeStruct *node, UNU int UNU pin)            { return LOW ; }
1311 static         void digitalWriteDummy        (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int value) { return ; }
1312 static         void pwmWriteDummy            (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int value) { return ; }
1313 static          int analogReadDummy          (UNU struct wiringPiNodeStruct *node, UNU int pin)            { return 0 ; }
1314 static         void analogWriteDummy         (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int value) { return ; }
1315
1316 struct wiringPiNodeStruct *wiringPiNewNode (int pinBase, int numPins)
1317 {
1318   int    pin ;
1319   struct wiringPiNodeStruct *node ;
1320
1321 // Minimum pin base is 64
1322
1323   if (pinBase < 64)
1324     (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: pinBase of %d is < 64\n", pinBase) ;
1325
1326 // Check all pins in-case there is overlap:
1327
1328   for (pin = pinBase ; pin < (pinBase + numPins) ; ++pin)
1329     if (wiringPiFindNode (pin) != NULL)
1330       (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: Pin %d overlaps with existing definition\n", pin) ;
1331
1332   node = (struct wiringPiNodeStruct *)calloc (sizeof (struct wiringPiNodeStruct), 1) ;  // calloc zeros
1333   if (node == NULL)
1334     (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: Unable to allocate memory: %s\n", strerror (errno)) ;
1335
1336   node->pinBase          = pinBase ;
1337   node->pinMax           = pinBase + numPins - 1 ;
1338   node->pinMode          = pinModeDummy ;
1339   node->pullUpDnControl  = pullUpDnControlDummy ;
1340   node->digitalRead      = digitalReadDummy ;
1341 //node->digitalRead8     = digitalRead8Dummy ;
1342   node->digitalWrite     = digitalWriteDummy ;
1343 //node->digitalWrite8    = digitalWrite8Dummy ;
1344   node->pwmWrite         = pwmWriteDummy ;
1345   node->analogRead       = analogReadDummy ;
1346   node->analogWrite      = analogWriteDummy ;
1347   node->next             = wiringPiNodes ;
1348   wiringPiNodes          = node ;
1349
1350   return node ;
1351 }
1352
1353
1354 #ifdef notYetReady
1355 /*
1356  * pinED01:
1357  * pinED10:
1358  *      Enables edge-detect mode on a pin - from a 0 to a 1 or 1 to 0
1359  *      Pin must already be in input mode with appropriate pull up/downs set.
1360  *********************************************************************************
1361  */
1362
1363 void pinEnableED01Pi (int pin)
1364 {
1365   pin = pinToGpio [pin & 63] ;
1366 }
1367 #endif
1368
1369
1370 /*
1371  *********************************************************************************
1372  * Core Functions
1373  *********************************************************************************
1374  */
1375
1376 /*
1377  * pinModeAlt:
1378  *      This is an un-documented special to let you set any pin to any mode
1379  *********************************************************************************
1380  */
1381
1382 void pinModeAlt (int pin, int mode)
1383 {
1384   int fSel, shift ;
1385
1386   setupCheck ("pinModeAlt") ;
1387
1388   if ((pin & PI_GPIO_MASK) == 0)                // On-board pin
1389   {
1390     /**/ if (wiringPiMode == WPI_MODE_PINS)
1391       pin = pinToGpio [pin] ;
1392     else if (wiringPiMode == WPI_MODE_PHYS)
1393       pin = physToGpio [pin] ;
1394     else if (wiringPiMode != WPI_MODE_GPIO)
1395       return ;
1396
1397     fSel  = gpioToGPFSEL [pin] ;
1398     shift = gpioToShift  [pin] ;
1399
1400     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | ((mode & 0x7) << shift) ;
1401   }
1402 }
1403
1404
1405 /*
1406  * pinMode:
1407  *      Sets the mode of a pin to be input, output or PWM output
1408  *********************************************************************************
1409  */
1410
1411 void pinMode (int pin, int mode)
1412 {
1413   int    fSel, shift, alt ;
1414   struct wiringPiNodeStruct *node = wiringPiNodes ;
1415   int origPin = pin ;
1416
1417   setupCheck ("pinMode") ;
1418
1419   if ((pin & PI_GPIO_MASK) == 0)                // On-board pin
1420   {
1421     /**/ if (wiringPiMode == WPI_MODE_PINS)
1422       pin = pinToGpio [pin] ;
1423     else if (wiringPiMode == WPI_MODE_PHYS)
1424       pin = physToGpio [pin] ;
1425     else if (wiringPiMode != WPI_MODE_GPIO)
1426       return ;
1427
1428     softPwmStop  (origPin) ;
1429     softToneStop (origPin) ;
1430
1431     fSel    = gpioToGPFSEL [pin] ;
1432     shift   = gpioToShift  [pin] ;
1433
1434     /**/ if (mode == INPUT)
1435       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
1436     else if (mode == OUTPUT)
1437       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
1438     else if (mode == SOFT_PWM_OUTPUT)
1439       softPwmCreate (origPin, 0, 100) ;
1440     else if (mode == SOFT_TONE_OUTPUT)
1441       softToneCreate (origPin) ;
1442     else if (mode == PWM_TONE_OUTPUT)
1443     {
1444       pinMode (origPin, PWM_OUTPUT) ;   // Call myself to enable PWM mode
1445       pwmSetMode (PWM_MODE_MS) ;
1446     }
1447     else if (mode == PWM_OUTPUT)
1448     {
1449       if ((alt = gpioToPwmALT [pin]) == 0)      // Not a hardware capable PWM pin
1450         return ;
1451
1452       usingGpioMemCheck ("pinMode PWM") ;
1453
1454 // Set pin to PWM mode
1455
1456       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
1457       delayMicroseconds (110) ;         // See comments in pwmSetClockWPi
1458
1459       pwmSetMode  (PWM_MODE_BAL) ;      // Pi default mode
1460       pwmSetRange (1024) ;              // Default range of 1024
1461       pwmSetClock (32) ;                // 19.2 / 32 = 600KHz - Also starts the PWM
1462     }
1463     else if (mode == GPIO_CLOCK)
1464     {
1465       if ((alt = gpioToGpClkALT0 [pin]) == 0)   // Not a GPIO_CLOCK pin
1466         return ;
1467
1468       usingGpioMemCheck ("pinMode CLOCK") ;
1469
1470 // Set pin to GPIO_CLOCK mode and set the clock frequency to 100KHz
1471
1472       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
1473       delayMicroseconds (110) ;
1474       gpioClockSet      (pin, 100000) ;
1475     }
1476   }
1477   else
1478   {
1479     if ((node = wiringPiFindNode (pin)) != NULL)
1480       node->pinMode (node, pin, mode) ;
1481     return ;
1482   }
1483 }
1484
1485
1486 /*
1487  * pullUpDownCtrl:
1488  *      Control the internal pull-up/down resistors on a GPIO pin.
1489  *********************************************************************************
1490  */
1491
1492 void pullUpDnControl (int pin, int pud)
1493 {
1494   struct wiringPiNodeStruct *node = wiringPiNodes ;
1495
1496   setupCheck ("pullUpDnControl") ;
1497
1498   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1499   {
1500     /**/ if (wiringPiMode == WPI_MODE_PINS)
1501       pin = pinToGpio [pin] ;
1502     else if (wiringPiMode == WPI_MODE_PHYS)
1503       pin = physToGpio [pin] ;
1504     else if (wiringPiMode != WPI_MODE_GPIO)
1505       return ;
1506
1507     *(gpio + GPPUD)              = pud & 3 ;            delayMicroseconds (5) ;
1508     *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ;    delayMicroseconds (5) ;
1509     
1510     *(gpio + GPPUD)              = 0 ;                  delayMicroseconds (5) ;
1511     *(gpio + gpioToPUDCLK [pin]) = 0 ;                  delayMicroseconds (5) ;
1512   }
1513   else                                          // Extension module
1514   {
1515     if ((node = wiringPiFindNode (pin)) != NULL)
1516       node->pullUpDnControl (node, pin, pud) ;
1517     return ;
1518   }
1519 }
1520
1521
1522 /*
1523  * digitalRead:
1524  *      Read the value of a given Pin, returning HIGH or LOW
1525  *********************************************************************************
1526  */
1527
1528 int digitalRead (int pin)
1529 {
1530   char c ;
1531   struct wiringPiNodeStruct *node = wiringPiNodes ;
1532
1533   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1534   {
1535     /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS) // Sys mode
1536     {
1537       if (sysFds [pin] == -1)
1538         return LOW ;
1539
1540       lseek  (sysFds [pin], 0L, SEEK_SET) ;
1541       read   (sysFds [pin], &c, 1) ;
1542       return (c == '0') ? LOW : HIGH ;
1543     }
1544     else if (wiringPiMode == WPI_MODE_PINS)
1545       pin = pinToGpio [pin] ;
1546     else if (wiringPiMode == WPI_MODE_PHYS)
1547       pin = physToGpio [pin] ;
1548     else if (wiringPiMode != WPI_MODE_GPIO)
1549       return LOW ;
1550
1551     if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
1552       return HIGH ;
1553     else
1554       return LOW ;
1555   }
1556   else
1557   {
1558     if ((node = wiringPiFindNode (pin)) == NULL)
1559       return LOW ;
1560     return node->digitalRead (node, pin) ;
1561   }
1562 }
1563
1564
1565 /*
1566  * digitalRead8:
1567  *      Read 8-bits (a byte) from given start pin.
1568  *********************************************************************************
1569
1570 unsigned int digitalRead8 (int pin)
1571 {
1572   struct wiringPiNodeStruct *node = wiringPiNodes ;
1573
1574   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1575     return 0 ;
1576   else
1577   {
1578     if ((node = wiringPiFindNode (pin)) == NULL)
1579       return LOW ;
1580     return node->digitalRead8 (node, pin) ;
1581   }
1582 }
1583  */
1584
1585
1586 /*
1587  * digitalWrite:
1588  *      Set an output bit
1589  *********************************************************************************
1590  */
1591
1592 void digitalWrite (int pin, int value)
1593 {
1594   struct wiringPiNodeStruct *node = wiringPiNodes ;
1595
1596   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1597   {
1598     /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS) // Sys mode
1599     {
1600       if (sysFds [pin] != -1)
1601       {
1602         if (value == LOW)
1603           write (sysFds [pin], "0\n", 2) ;
1604         else
1605           write (sysFds [pin], "1\n", 2) ;
1606       }
1607       return ;
1608     }
1609     else if (wiringPiMode == WPI_MODE_PINS)
1610       pin = pinToGpio [pin] ;
1611     else if (wiringPiMode == WPI_MODE_PHYS)
1612       pin = physToGpio [pin] ;
1613     else if (wiringPiMode != WPI_MODE_GPIO)
1614       return ;
1615
1616     if (value == LOW)
1617       *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
1618     else
1619       *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
1620   }
1621   else
1622   {
1623     if ((node = wiringPiFindNode (pin)) != NULL)
1624       node->digitalWrite (node, pin, value) ;
1625   }
1626 }
1627
1628
1629 /*
1630  * digitalWrite8:
1631  *      Set an output 8-bit byte on the device from the given pin number
1632  *********************************************************************************
1633
1634 void digitalWrite8 (int pin, int value)
1635 {
1636   struct wiringPiNodeStruct *node = wiringPiNodes ;
1637
1638   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1639     return ;
1640   else
1641   {
1642     if ((node = wiringPiFindNode (pin)) != NULL)
1643       node->digitalWrite8 (node, pin, value) ;
1644   }
1645 }
1646  */
1647
1648
1649 /*
1650  * pwmWrite:
1651  *      Set an output PWM value
1652  *********************************************************************************
1653  */
1654
1655 void pwmWrite (int pin, int value)
1656 {
1657   struct wiringPiNodeStruct *node = wiringPiNodes ;
1658
1659   setupCheck ("pwmWrite") ;
1660
1661   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1662   {
1663     /**/ if (wiringPiMode == WPI_MODE_PINS)
1664       pin = pinToGpio [pin] ;
1665     else if (wiringPiMode == WPI_MODE_PHYS)
1666       pin = physToGpio [pin] ;
1667     else if (wiringPiMode != WPI_MODE_GPIO)
1668       return ;
1669
1670     usingGpioMemCheck ("pwmWrite") ;
1671     *(pwm + gpioToPwmPort [pin]) = value ;
1672   }
1673   else
1674   {
1675     if ((node = wiringPiFindNode (pin)) != NULL)
1676       node->pwmWrite (node, pin, value) ;
1677   }
1678 }
1679
1680
1681 /*
1682  * analogRead:
1683  *      Read the analog value of a given Pin. 
1684  *      There is no on-board Pi analog hardware,
1685  *      so this needs to go to a new node.
1686  *********************************************************************************
1687  */
1688
1689 int analogRead (int pin)
1690 {
1691   struct wiringPiNodeStruct *node = wiringPiNodes ;
1692
1693   if ((node = wiringPiFindNode (pin)) == NULL)
1694     return 0 ;
1695   else
1696     return node->analogRead (node, pin) ;
1697 }
1698
1699
1700 /*
1701  * analogWrite:
1702  *      Write the analog value to the given Pin. 
1703  *      There is no on-board Pi analog hardware,
1704  *      so this needs to go to a new node.
1705  *********************************************************************************
1706  */
1707
1708 void analogWrite (int pin, int value)
1709 {
1710   struct wiringPiNodeStruct *node = wiringPiNodes ;
1711
1712   if ((node = wiringPiFindNode (pin)) == NULL)
1713     return ;
1714
1715   node->analogWrite (node, pin, value) ;
1716 }
1717
1718
1719 /*
1720  * pwmToneWrite:
1721  *      Pi Specific.
1722  *      Output the given frequency on the Pi's PWM pin
1723  *********************************************************************************
1724  */
1725
1726 void pwmToneWrite (int pin, int freq)
1727 {
1728   int range ;
1729
1730   setupCheck ("pwmToneWrite") ;
1731
1732   if (freq == 0)
1733     pwmWrite (pin, 0) ;             // Off
1734   else
1735   {
1736     range = 600000 / freq ;
1737     pwmSetRange (range) ;
1738     pwmWrite    (pin, freq / 2) ;
1739   }
1740 }
1741
1742
1743
1744 /*
1745  * digitalWriteByte:
1746  * digitalReadByte:
1747  *      Pi Specific
1748  *      Write an 8-bit byte to the first 8 GPIO pins - try to do it as
1749  *      fast as possible.
1750  *      However it still needs 2 operations to set the bits, so any external
1751  *      hardware must not rely on seeing a change as there will be a change 
1752  *      to set the outputs bits to zero, then another change to set the 1's
1753  *      Reading is just bit fiddling.
1754  *      These are wiringPi pin numbers 0..7, or BCM_GPIO pin numbers
1755  *      17, 18, 22, 23, 24, 24, 4 on a Pi v1 rev 0-3
1756  *      17, 18, 27, 23, 24, 24, 4 on a Pi v1 rev 3 onwards or B+, 2, 3, zero
1757  *********************************************************************************
1758  */
1759
1760 void digitalWriteByte (const int value)
1761 {
1762   uint32_t pinSet = 0 ;
1763   uint32_t pinClr = 0 ;
1764   int mask = 1 ;
1765   int pin ;
1766
1767   /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
1768   {
1769     for (pin = 0 ; pin < 8 ; ++pin)
1770     {
1771       digitalWrite (pinToGpio [pin], value & mask) ;
1772       mask <<= 1 ;
1773     }
1774     return ;
1775   }
1776   else
1777   {
1778     for (pin = 0 ; pin < 8 ; ++pin)
1779     {
1780       if ((value & mask) == 0)
1781         pinClr |= (1 << pinToGpio [pin]) ;
1782       else
1783         pinSet |= (1 << pinToGpio [pin]) ;
1784
1785       mask <<= 1 ;
1786     }
1787
1788     *(gpio + gpioToGPCLR [0]) = pinClr ;
1789     *(gpio + gpioToGPSET [0]) = pinSet ;
1790   }
1791 }
1792
1793 unsigned int digitalReadByte (void)
1794 {
1795   int pin, x ;
1796   uint32_t raw ;
1797   uint32_t data = 0 ;
1798
1799   /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
1800   {
1801     for (pin = 0 ; pin < 8 ; ++pin)
1802     {
1803       x = digitalRead (pinToGpio [pin]) ;
1804       data = (data << 1) | x ;
1805     }
1806   }
1807   else 
1808   {
1809     raw = *(gpio + gpioToGPLEV [0]) ; // First bank for these pins
1810     for (pin = 0 ; pin < 8 ; ++pin)
1811     {
1812       x = pinToGpio [pin] ;
1813       data = (data << 1) | (((raw & (1 << x)) == 0) ? 0 : 1) ;
1814     }
1815   }
1816   return data ;
1817 }
1818
1819
1820 /*
1821  * digitalWriteByte2:
1822  * digitalReadByte2:
1823  *      Pi Specific
1824  *      Write an 8-bit byte to the second set of 8 GPIO pins. This is marginally
1825  *      faster than the first lot as these are consecutive BCM_GPIO pin numbers.
1826  *      However they overlap with the original read/write bytes.
1827  *********************************************************************************
1828  */
1829
1830 void digitalWriteByte2 (const int value)
1831 {
1832   register int mask = 1 ;
1833   register int pin ;
1834
1835   /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
1836   {
1837     for (pin = 20 ; pin < 28 ; ++pin)
1838     {
1839       digitalWrite (pin, value & mask) ;
1840       mask <<= 1 ;
1841     }
1842     return ;
1843   }
1844   else
1845   {
1846     *(gpio + gpioToGPCLR [0]) = (~value & 0xFF) << 20 ; // 0x0FF00000; ILJ > CHANGE: Old causes glitch
1847     *(gpio + gpioToGPSET [0]) = ( value & 0xFF) << 20 ;
1848   }
1849 }
1850
1851 unsigned int digitalReadByte2 (void)
1852 {
1853   int pin, x ;
1854   uint32_t data = 0 ;
1855
1856   /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
1857   {
1858     for (pin = 20 ; pin < 28 ; ++pin)
1859     {
1860       x = digitalRead (pin) ;
1861       data = (data << 1) | x ;
1862     }
1863   }
1864   else 
1865     data = ((*(gpio + gpioToGPLEV [0])) >> 20) & 0xFF ; // First bank for these pins
1866
1867   return data ;
1868 }
1869
1870
1871 /*
1872  * waitForInterrupt:
1873  *      Pi Specific.
1874  *      Wait for Interrupt on a GPIO pin.
1875  *      This is actually done via the /sys/class/gpio interface regardless of
1876  *      the wiringPi access mode in-use. Maybe sometime it might get a better
1877  *      way for a bit more efficiency.
1878  *********************************************************************************
1879  */
1880
1881 int waitForInterrupt (int pin, int mS)
1882 {
1883   int fd, x ;
1884   uint8_t c ;
1885   struct pollfd polls ;
1886
1887   /**/ if (wiringPiMode == WPI_MODE_PINS)
1888     pin = pinToGpio [pin] ;
1889   else if (wiringPiMode == WPI_MODE_PHYS)
1890     pin = physToGpio [pin] ;
1891
1892   if ((fd = sysFds [pin]) == -1)
1893     return -2 ;
1894
1895 // Setup poll structure
1896
1897   polls.fd     = fd ;
1898   polls.events = POLLPRI | POLLERR ;
1899
1900 // Wait for it ...
1901
1902   x = poll (&polls, 1, mS) ;
1903
1904 // If no error, do a dummy read to clear the interrupt
1905 //      A one character read appars to be enough.
1906
1907   if (x > 0)
1908   {
1909     lseek (fd, 0, SEEK_SET) ;   // Rewind
1910     (void)read (fd, &c, 1) ;    // Read & clear
1911   }
1912
1913   return x ;
1914 }
1915
1916
1917 /*
1918  * interruptHandler:
1919  *      This is a thread and gets started to wait for the interrupt we're
1920  *      hoping to catch. It will call the user-function when the interrupt
1921  *      fires.
1922  *********************************************************************************
1923  */
1924
1925 static void *interruptHandler (UNU void *arg)
1926 {
1927   int myPin ;
1928
1929   (void)piHiPri (55) ;  // Only effective if we run as root
1930
1931   myPin   = pinPass ;
1932   pinPass = -1 ;
1933
1934   for (;;)
1935     if (waitForInterrupt (myPin, -1) > 0)
1936       isrFunctions [myPin] () ;
1937
1938   return NULL ;
1939 }
1940
1941
1942 /*
1943  * wiringPiISR:
1944  *      Pi Specific.
1945  *      Take the details and create an interrupt handler that will do a call-
1946  *      back to the user supplied function.
1947  *********************************************************************************
1948  */
1949
1950 int wiringPiISR (int pin, int mode, void (*function)(void))
1951 {
1952   pthread_t threadId ;
1953   const char *modeS ;
1954   char fName   [64] ;
1955   char  pinS [8] ;
1956   pid_t pid ;
1957   int   count, i ;
1958   char  c ;
1959   int   bcmGpioPin ;
1960
1961   if ((pin < 0) || (pin > 63))
1962     return wiringPiFailure (WPI_FATAL, "wiringPiISR: pin must be 0-63 (%d)\n", pin) ;
1963
1964   /**/ if (wiringPiMode == WPI_MODE_UNINITIALISED)
1965     return wiringPiFailure (WPI_FATAL, "wiringPiISR: wiringPi has not been initialised. Unable to continue.\n") ;
1966   else if (wiringPiMode == WPI_MODE_PINS)
1967     bcmGpioPin = pinToGpio [pin] ;
1968   else if (wiringPiMode == WPI_MODE_PHYS)
1969     bcmGpioPin = physToGpio [pin] ;
1970   else
1971     bcmGpioPin = pin ;
1972
1973 // Now export the pin and set the right edge
1974 //      We're going to use the gpio program to do this, so it assumes
1975 //      a full installation of wiringPi. It's a bit 'clunky', but it
1976 //      is a way that will work when we're running in "Sys" mode, as
1977 //      a non-root user. (without sudo)
1978
1979   if (mode != INT_EDGE_SETUP)
1980   {
1981     /**/ if (mode == INT_EDGE_FALLING)
1982       modeS = "falling" ;
1983     else if (mode == INT_EDGE_RISING)
1984       modeS = "rising" ;
1985     else
1986       modeS = "both" ;
1987
1988     sprintf (pinS, "%d", bcmGpioPin) ;
1989
1990     if ((pid = fork ()) < 0)    // Fail
1991       return wiringPiFailure (WPI_FATAL, "wiringPiISR: fork failed: %s\n", strerror (errno)) ;
1992
1993     if (pid == 0)       // Child, exec
1994     {
1995       /**/ if (access ("/usr/local/bin/gpio", X_OK) == 0)
1996       {
1997         execl ("/usr/local/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
1998         return wiringPiFailure (WPI_FATAL, "wiringPiISR: execl failed: %s\n", strerror (errno)) ;
1999       }
2000       else if (access ("/usr/bin/gpio", X_OK) == 0)
2001       {
2002         execl ("/usr/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
2003         return wiringPiFailure (WPI_FATAL, "wiringPiISR: execl failed: %s\n", strerror (errno)) ;
2004       }
2005       else
2006         return wiringPiFailure (WPI_FATAL, "wiringPiISR: Can't find gpio program\n") ;
2007     }
2008     else                // Parent, wait
2009       wait (NULL) ;
2010   }
2011
2012 // Now pre-open the /sys/class node - but it may already be open if
2013 //      we are in Sys mode...
2014
2015   if (sysFds [bcmGpioPin] == -1)
2016   {
2017     sprintf (fName, "/sys/class/gpio/gpio%d/value", bcmGpioPin) ;
2018     if ((sysFds [bcmGpioPin] = open (fName, O_RDWR)) < 0)
2019       return wiringPiFailure (WPI_FATAL, "wiringPiISR: unable to open %s: %s\n", fName, strerror (errno)) ;
2020   }
2021
2022 // Clear any initial pending interrupt
2023
2024   ioctl (sysFds [bcmGpioPin], FIONREAD, &count) ;
2025   for (i = 0 ; i < count ; ++i)
2026     read (sysFds [bcmGpioPin], &c, 1) ;
2027
2028   isrFunctions [pin] = function ;
2029
2030   pthread_mutex_lock (&pinMutex) ;
2031     pinPass = pin ;
2032     pthread_create (&threadId, NULL, interruptHandler, NULL) ;
2033     while (pinPass != -1)
2034       delay (1) ;
2035   pthread_mutex_unlock (&pinMutex) ;
2036
2037   return 0 ;
2038 }
2039
2040
2041 /*
2042  * initialiseEpoch:
2043  *      Initialise our start-of-time variable to be the current unix
2044  *      time in milliseconds and microseconds.
2045  *********************************************************************************
2046  */
2047
2048 static void initialiseEpoch (void)
2049 {
2050 #ifdef  OLD_WAY
2051   struct timeval tv ;
2052
2053   gettimeofday (&tv, NULL) ;
2054   epochMilli = (uint64_t)tv.tv_sec * (uint64_t)1000    + (uint64_t)(tv.tv_usec / 1000) ;
2055   epochMicro = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)(tv.tv_usec) ;
2056 #else
2057   struct timespec ts ;
2058
2059   clock_gettime (CLOCK_MONOTONIC_RAW, &ts) ;
2060   epochMilli = (uint64_t)ts.tv_sec * (uint64_t)1000    + (uint64_t)(ts.tv_nsec / 1000000L) ;
2061   epochMicro = (uint64_t)ts.tv_sec * (uint64_t)1000000 + (uint64_t)(ts.tv_nsec /    1000L) ;
2062 #endif
2063 }
2064
2065
2066 /*
2067  * delay:
2068  *      Wait for some number of milliseconds
2069  *********************************************************************************
2070  */
2071
2072 void delay (unsigned int howLong)
2073 {
2074   struct timespec sleeper, dummy ;
2075
2076   sleeper.tv_sec  = (time_t)(howLong / 1000) ;
2077   sleeper.tv_nsec = (long)(howLong % 1000) * 1000000 ;
2078
2079   nanosleep (&sleeper, &dummy) ;
2080 }
2081
2082
2083 /*
2084  * delayMicroseconds:
2085  *      This is somewhat intersting. It seems that on the Pi, a single call
2086  *      to nanosleep takes some 80 to 130 microseconds anyway, so while
2087  *      obeying the standards (may take longer), it's not always what we
2088  *      want!
2089  *
2090  *      So what I'll do now is if the delay is less than 100uS we'll do it
2091  *      in a hard loop, watching a built-in counter on the ARM chip. This is
2092  *      somewhat sub-optimal in that it uses 100% CPU, something not an issue
2093  *      in a microcontroller, but under a multi-tasking, multi-user OS, it's
2094  *      wastefull, however we've no real choice )-:
2095  *
2096  *      Plan B: It seems all might not be well with that plan, so changing it
2097  *      to use gettimeofday () and poll on that instead...
2098  *********************************************************************************
2099  */
2100
2101 void delayMicrosecondsHard (unsigned int howLong)
2102 {
2103   struct timeval tNow, tLong, tEnd ;
2104
2105   gettimeofday (&tNow, NULL) ;
2106   tLong.tv_sec  = howLong / 1000000 ;
2107   tLong.tv_usec = howLong % 1000000 ;
2108   timeradd (&tNow, &tLong, &tEnd) ;
2109
2110   while (timercmp (&tNow, &tEnd, <))
2111     gettimeofday (&tNow, NULL) ;
2112 }
2113
2114 void delayMicroseconds (unsigned int howLong)
2115 {
2116   struct timespec sleeper ;
2117   unsigned int uSecs = howLong % 1000000 ;
2118   unsigned int wSecs = howLong / 1000000 ;
2119
2120   /**/ if (howLong ==   0)
2121     return ;
2122   else if (howLong  < 100)
2123     delayMicrosecondsHard (howLong) ;
2124   else
2125   {
2126     sleeper.tv_sec  = wSecs ;
2127     sleeper.tv_nsec = (long)(uSecs * 1000L) ;
2128     nanosleep (&sleeper, NULL) ;
2129   }
2130 }
2131
2132
2133 /*
2134  * millis:
2135  *      Return a number of milliseconds as an unsigned int.
2136  *      Wraps at 49 days.
2137  *********************************************************************************
2138  */
2139
2140 unsigned int millis (void)
2141 {
2142   uint64_t now ;
2143
2144 #ifdef  OLD_WAY
2145   struct timeval tv ;
2146
2147   gettimeofday (&tv, NULL) ;
2148   now  = (uint64_t)tv.tv_sec * (uint64_t)1000 + (uint64_t)(tv.tv_usec / 1000) ;
2149
2150 #else
2151   struct  timespec ts ;
2152
2153   clock_gettime (CLOCK_MONOTONIC_RAW, &ts) ;
2154   now  = (uint64_t)ts.tv_sec * (uint64_t)1000 + (uint64_t)(ts.tv_nsec / 1000000L) ;
2155 #endif
2156
2157   return (uint32_t)(now - epochMilli) ;
2158 }
2159
2160
2161 /*
2162  * micros:
2163  *      Return a number of microseconds as an unsigned int.
2164  *      Wraps after 71 minutes.
2165  *********************************************************************************
2166  */
2167
2168 unsigned int micros (void)
2169 {
2170   uint64_t now ;
2171 #ifdef  OLD_WAY
2172   struct timeval tv ;
2173
2174   gettimeofday (&tv, NULL) ;
2175   now  = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)tv.tv_usec ;
2176 #else
2177   struct  timespec ts ;
2178
2179   clock_gettime (CLOCK_MONOTONIC_RAW, &ts) ;
2180   now  = (uint64_t)ts.tv_sec * (uint64_t)1000000 + (uint64_t)(ts.tv_nsec / 1000) ;
2181 #endif
2182
2183
2184   return (uint32_t)(now - epochMicro) ;
2185 }
2186
2187 /*
2188  * wiringPiVersion:
2189  *      Return our current version number
2190  *********************************************************************************
2191  */
2192
2193 void wiringPiVersion (int *major, int *minor)
2194 {
2195   *major = VERSION_MAJOR ;
2196   *minor = VERSION_MINOR ;
2197 }
2198
2199
2200 /*
2201  * wiringPiSetup:
2202  *      Must be called once at the start of your program execution.
2203  *
2204  * Default setup: Initialises the system into wiringPi Pin mode and uses the
2205  *      memory mapped hardware directly.
2206  *
2207  * Changed now to revert to "gpio" mode if we're running on a Compute Module.
2208  *********************************************************************************
2209  */
2210
2211 int wiringPiSetup (void)
2212 {
2213   int   fd ;
2214   int   model, rev, mem, maker, overVolted ;
2215
2216 // It's actually a fatal error to call any of the wiringPiSetup routines more than once,
2217 //      (you run out of file handles!) but I'm fed-up with the useless twats who email
2218 //      me bleating that there is a bug in my code, so screw-em.
2219
2220   if (wiringPiSetuped)
2221     return 0 ;
2222
2223   wiringPiSetuped = TRUE ;
2224
2225   if (getenv (ENV_DEBUG) != NULL)
2226     wiringPiDebug = TRUE ;
2227
2228   if (getenv (ENV_CODES) != NULL)
2229     wiringPiReturnCodes = TRUE ;
2230
2231   if (wiringPiDebug)
2232     printf ("wiringPi: wiringPiSetup called\n") ;
2233
2234 // Get the board ID information. We're not really using the information here,
2235 //      but it will give us information like the GPIO layout scheme (2 variants
2236 //      on the older 26-pin Pi's) and the GPIO peripheral base address.
2237 //      and if we're running on a compute module, then wiringPi pin numbers
2238 //      don't really many anything, so force native BCM mode anyway.
2239
2240   piBoardId (&model, &rev, &mem, &maker, &overVolted) ;
2241
2242   if ((model == PI_MODEL_CM) || (model == PI_MODEL_CM3))
2243     wiringPiMode = WPI_MODE_GPIO ;
2244   else
2245     wiringPiMode = WPI_MODE_PINS ;
2246
2247   /**/ if (piGpioLayout () == 1)        // A, B, Rev 1, 1.1
2248   {
2249      pinToGpio =  pinToGpioR1 ;
2250     physToGpio = physToGpioR1 ;
2251   }
2252   else                                  // A2, B2, A+, B+, CM, Pi2, Pi3, Zero
2253   {
2254      pinToGpio =  pinToGpioR2 ;
2255     physToGpio = physToGpioR2 ;
2256   }
2257
2258 // ...
2259
2260   switch (model)
2261   {
2262     case PI_MODEL_A:    case PI_MODEL_B:
2263     case PI_MODEL_AP:   case PI_MODEL_BP:
2264     case PI_ALPHA:      case PI_MODEL_CM:
2265     case PI_MODEL_ZERO: case PI_MODEL_ZERO_W:
2266       piGpioBase = GPIO_PERI_BASE_OLD ;
2267       break ;
2268
2269     default:
2270       piGpioBase = GPIO_PERI_BASE_NEW ;
2271       break ;
2272   }
2273
2274 // Open the master /dev/ memory control device
2275 // Device strategy: December 2016:
2276 //      Try /dev/mem. If that fails, then 
2277 //      try /dev/gpiomem. If that fails then game over.
2278
2279   if ((fd = open ("/dev/mem", O_RDWR | O_SYNC | O_CLOEXEC)) < 0)
2280   {
2281     if ((fd = open ("/dev/gpiomem", O_RDWR | O_SYNC | O_CLOEXEC) ) >= 0)        // We're using gpiomem
2282     {
2283       piGpioBase   = 0 ;
2284       usingGpioMem = TRUE ;
2285     }
2286     else
2287       return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: Unable to open /dev/mem or /dev/gpiomem: %s.\n"
2288         "  Aborting your program because if it can not access the GPIO\n"
2289         "  hardware then it most certianly won't work\n"
2290         "  Try running with sudo?\n", strerror (errno)) ;
2291   }
2292
2293 // Set the offsets into the memory interface.
2294
2295   GPIO_PADS       = piGpioBase + 0x00100000 ;
2296   GPIO_CLOCK_BASE = piGpioBase + 0x00101000 ;
2297   GPIO_BASE       = piGpioBase + 0x00200000 ;
2298   GPIO_TIMER      = piGpioBase + 0x0000B000 ;
2299   GPIO_PWM        = piGpioBase + 0x0020C000 ;
2300
2301 // Map the individual hardware components
2302
2303 //      GPIO:
2304
2305   gpio = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_BASE) ;
2306   if (gpio == MAP_FAILED)
2307     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (GPIO) failed: %s\n", strerror (errno)) ;
2308
2309 //      PWM
2310
2311   pwm = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PWM) ;
2312   if (pwm == MAP_FAILED)
2313     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (PWM) failed: %s\n", strerror (errno)) ;
2314  
2315 //      Clock control (needed for PWM)
2316
2317   clk = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_CLOCK_BASE) ;
2318   if (clk == MAP_FAILED)
2319     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (CLOCK) failed: %s\n", strerror (errno)) ;
2320  
2321 //      The drive pads
2322
2323   pads = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PADS) ;
2324   if (pads == MAP_FAILED)
2325     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (PADS) failed: %s\n", strerror (errno)) ;
2326
2327 //      The system timer
2328
2329   timer = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_TIMER) ;
2330   if (timer == MAP_FAILED)
2331     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (TIMER) failed: %s\n", strerror (errno)) ;
2332
2333 // Set the timer to free-running, 1MHz.
2334 //      0xF9 is 249, the timer divide is base clock / (divide+1)
2335 //      so base clock is 250MHz / 250 = 1MHz.
2336
2337   *(timer + TIMER_CONTROL) = 0x0000280 ;
2338   *(timer + TIMER_PRE_DIV) = 0x00000F9 ;
2339   timerIrqRaw = timer + TIMER_IRQ_RAW ;
2340
2341 // Export the base addresses for any external software that might need them
2342
2343   _wiringPiGpio  = gpio ;
2344   _wiringPiPwm   = pwm ;
2345   _wiringPiClk   = clk ;
2346   _wiringPiPads  = pads ;
2347   _wiringPiTimer = timer ;
2348
2349   initialiseEpoch () ;
2350
2351   return 0 ;
2352 }
2353
2354
2355 /*
2356  * wiringPiSetupGpio:
2357  *      Must be called once at the start of your program execution.
2358  *
2359  * GPIO setup: Initialises the system into GPIO Pin mode and uses the
2360  *      memory mapped hardware directly.
2361  *********************************************************************************
2362  */
2363
2364 int wiringPiSetupGpio (void)
2365 {
2366   (void)wiringPiSetup () ;
2367
2368   if (wiringPiDebug)
2369     printf ("wiringPi: wiringPiSetupGpio called\n") ;
2370
2371   wiringPiMode = WPI_MODE_GPIO ;
2372
2373   return 0 ;
2374 }
2375
2376
2377 /*
2378  * wiringPiSetupPhys:
2379  *      Must be called once at the start of your program execution.
2380  *
2381  * Phys setup: Initialises the system into Physical Pin mode and uses the
2382  *      memory mapped hardware directly.
2383  *********************************************************************************
2384  */
2385
2386 int wiringPiSetupPhys (void)
2387 {
2388   (void)wiringPiSetup () ;
2389
2390   if (wiringPiDebug)
2391     printf ("wiringPi: wiringPiSetupPhys called\n") ;
2392
2393   wiringPiMode = WPI_MODE_PHYS ;
2394
2395   return 0 ;
2396 }
2397
2398
2399 /*
2400  * wiringPiSetupSys:
2401  *      Must be called once at the start of your program execution.
2402  *
2403  * Initialisation (again), however this time we are using the /sys/class/gpio
2404  *      interface to the GPIO systems - slightly slower, but always usable as
2405  *      a non-root user, assuming the devices are already exported and setup correctly.
2406  */
2407
2408 int wiringPiSetupSys (void)
2409 {
2410   int pin ;
2411   char fName [128] ;
2412
2413   if (wiringPiSetuped)
2414     return 0 ;
2415
2416   wiringPiSetuped = TRUE ;
2417
2418   if (getenv (ENV_DEBUG) != NULL)
2419     wiringPiDebug = TRUE ;
2420
2421   if (getenv (ENV_CODES) != NULL)
2422     wiringPiReturnCodes = TRUE ;
2423
2424   if (wiringPiDebug)
2425     printf ("wiringPi: wiringPiSetupSys called\n") ;
2426
2427   if (piGpioLayout () == 1)
2428   {
2429      pinToGpio =  pinToGpioR1 ;
2430     physToGpio = physToGpioR1 ;
2431   }
2432   else
2433   {
2434      pinToGpio =  pinToGpioR2 ;
2435     physToGpio = physToGpioR2 ;
2436   }
2437
2438 // Open and scan the directory, looking for exported GPIOs, and pre-open
2439 //      the 'value' interface to speed things up for later
2440   
2441   for (pin = 0 ; pin < 64 ; ++pin)
2442   {
2443     sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
2444     sysFds [pin] = open (fName, O_RDWR) ;
2445   }
2446
2447   initialiseEpoch () ;
2448
2449   wiringPiMode = WPI_MODE_GPIO_SYS ;
2450
2451   return 0 ;
2452 }