Gordons Projects

--> Projects Top-Level GIT

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