Gordons Projects

--> Projects Top-Level GIT

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