Gordons Projects

--> Projects Top-Level GIT

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