Gordons Projects

--> Projects Top-Level GIT

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