Gordons Projects

--> Projects Top-Level GIT

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