Gordons Projects

--> Projects Top-Level GIT

OK, so an easier way to manage versions.
[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  *
631  *      For the Pi 2:
632  *      0010 - Model 2, Rev 1.1, Quad Core, 1GB, Sony
633  *
634  *      A small thorn is the olde style overvolting - that will add in
635  *              1000000
636  *
637  *      The Pi compute module has an revision of 0011 - since we only check the
638  *      last digit, then it's 1, therefore it'll default to not 2 or 3 for a
639  *      Rev 1, so will appear as a Rev 2. This is fine for the most part, but
640  *      we'll properly detect the Compute Module later and adjust accordingly.
641  *
642  *********************************************************************************
643  */
644
645 static void piBoardRevOops (const char *why)
646 {
647   fprintf (stderr, "piBoardRev: Unable to determine board revision from /proc/cpuinfo\n") ;
648   fprintf (stderr, " -> %s\n", why) ;
649   fprintf (stderr, " ->  You may want to check:\n") ;
650   fprintf (stderr, " ->  http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
651   exit (EXIT_FAILURE) ;
652 }
653
654 int piBoardRev (void)
655 {
656   FILE *cpuFd ;
657   char line [120] ;
658   char *c ;
659   static int  boardRev = -1 ;
660
661   if (boardRev != -1)   // No point checking twice
662     return boardRev ;
663
664   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
665     piBoardRevOops ("Unable to open /proc/cpuinfo") ;
666
667 // Start by looking for the Architecture, then we can look for a B2 revision....
668
669   while (fgets (line, 120, cpuFd) != NULL)
670     if (strncmp (line, "model name", 10) == 0)
671       break ;
672
673   if (strncmp (line, "model name", 10) != 0)
674     piBoardRevOops ("No \"model name\" line") ;
675
676   if (wiringPiDebug)
677     printf ("piboardRev: Model name: %s\n", line) ;
678
679 // See if it's v7
680
681   if (strstr (line, "ARMv7") != NULL)
682     piModel2 = TRUE ;
683
684 // Now do the rest of it as before
685
686   rewind (cpuFd) ;
687
688   while (fgets (line, 120, cpuFd) != NULL)
689     if (strncmp (line, "Revision", 8) == 0)
690       break ;
691
692   fclose (cpuFd) ;
693
694   if (strncmp (line, "Revision", 8) != 0)
695     piBoardRevOops ("No \"Revision\" line") ;
696
697 // Chomp trailing CR/NL
698
699   for (c = &line [strlen (line) - 1] ; (*c == '\n') || (*c == '\r') ; --c)
700     *c = 0 ;
701   
702   if (wiringPiDebug)
703     printf ("piboardRev: Revision string: %s\n", line) ;
704
705 // Scan to first digit
706
707   for (c = line ; *c ; ++c)
708     if (isdigit (*c))
709       break ;
710
711   if (!isdigit (*c))
712     piBoardRevOops ("No numeric revision string") ;
713
714 // Make sure its long enough
715
716   if (strlen (c) < 4)
717     piBoardRevOops ("Bogus \"Revision\" line (too small)") ;
718   
719 // If you have overvolted the Pi, then it appears that the revision
720 //      has 100000 added to it!
721 // The actual condition for it being set is:
722 //       (force_turbo || current_limit_override || temp_limit>85) && over_voltage>0
723
724   if (wiringPiDebug)
725     if (strlen (c) != 4)
726       printf ("piboardRev: This Pi has/is (force_turbo || current_limit_override || temp_limit>85) && over_voltage>0\n") ;
727
728 // Isolate  last 4 characters:
729
730   c = c + strlen (c) - 4 ;
731
732   if (wiringPiDebug)
733     printf ("piboardRev: last4Chars are: \"%s\"\n", c) ;
734
735   if ( (strcmp (c, "0002") == 0) || (strcmp (c, "0003") == 0))
736     boardRev = 1 ;
737   else
738     boardRev = 2 ;
739
740   if (wiringPiDebug)
741     printf ("piBoardRev: Returning revision: %d\n", boardRev) ;
742
743   return boardRev ;
744 }
745
746
747 /*
748  * piBoardId:
749  *      Do more digging into the board revision string as above, but return
750  *      as much details as we can.
751  *      This is undocumented and really only intended for the GPIO command.
752  *      Use at your own risk!
753  *********************************************************************************
754  */
755
756 void piBoardId (int *model, int *rev, int *mem, int *maker, int *overVolted)
757 {
758   FILE *cpuFd ;
759   char line [120] ;
760   char *c ;
761
762   (void)piBoardRev () ; // Call this first to make sure all's OK. Don't care about the result.
763
764   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
765     piBoardRevOops ("Unable to open /proc/cpuinfo") ;
766
767   while (fgets (line, 120, cpuFd) != NULL)
768     if (strncmp (line, "Revision", 8) == 0)
769       break ;
770
771   fclose (cpuFd) ;
772
773   if (strncmp (line, "Revision", 8) != 0)
774     piBoardRevOops ("No \"Revision\" line") ;
775
776 // Chomp trailing CR/NL
777
778   for (c = &line [strlen (line) - 1] ; (*c == '\n') || (*c == '\r') ; --c)
779     *c = 0 ;
780   
781   if (wiringPiDebug)
782     printf ("piboardId: Revision string: %s\n", line) ;
783
784 // Scan to first digit
785
786   for (c = line ; *c ; ++c)
787     if (isdigit (*c))
788       break ;
789
790 // Make sure its long enough
791
792   if (strlen (c) < 4)
793     piBoardRevOops ("Bogus \"Revision\" line") ;
794
795 // If longer than 4, we'll assume it's been overvolted
796
797   *overVolted = strlen (c) > 4 ;
798   
799 // Extract last 4 characters:
800
801   c = c + strlen (c) - 4 ;
802
803 // Fill out the replys as appropriate
804
805   if (piModel2)
806   {
807     /**/ if (strcmp (c, "0010") == 0) { *model = PI_MODEL_2  ; *rev = PI_VERSION_1_1 ; *mem = 1024 ; *maker = PI_MAKER_SONY   ; }
808     else                              { *model = 0           ; *rev = 0              ; *mem =    0 ; *maker = 0 ;               }
809   }
810   else
811   {
812     /**/ if (strcmp (c, "0002") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1   ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
813     else if (strcmp (c, "0003") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_1 ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
814     else if (strcmp (c, "0004") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_SONY   ; }
815     else if (strcmp (c, "0005") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_QISDA  ; }
816     else if (strcmp (c, "0006") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
817     else if (strcmp (c, "0007") == 0) { *model = PI_MODEL_A  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
818     else if (strcmp (c, "0008") == 0) { *model = PI_MODEL_A  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_SONY ; ; }
819     else if (strcmp (c, "0009") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_QISDA  ; }
820     else if (strcmp (c, "000d") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 512 ; *maker = PI_MAKER_EGOMAN ; }
821     else if (strcmp (c, "000e") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 512 ; *maker = PI_MAKER_SONY   ; }
822     else if (strcmp (c, "000f") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 512 ; *maker = PI_MAKER_EGOMAN ; }
823     else if (strcmp (c, "0010") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 512 ; *maker = PI_MAKER_SONY   ; }
824     else if (strcmp (c, "0011") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_2 ; *mem = 512 ; *maker = PI_MAKER_SONY   ; }
825     else if (strcmp (c, "0012") == 0) { *model = PI_MODEL_AP ; *rev = PI_VERSION_1_2 ; *mem = 256 ; *maker = PI_MAKER_SONY   ; }
826     else if (strcmp (c, "0013") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 512 ; *maker = PI_MAKER_MBEST  ; }
827     else                              { *model = 0           ; *rev = 0              ; *mem =   0 ; *maker = 0 ;               }
828   }
829 }
830  
831
832
833 /*
834  * wpiPinToGpio:
835  *      Translate a wiringPi Pin number to native GPIO pin number.
836  *      Provided for external support.
837  *********************************************************************************
838  */
839
840 int wpiPinToGpio (int wpiPin)
841 {
842   return pinToGpio [wpiPin & 63] ;
843 }
844
845
846 /*
847  * physPinToGpio:
848  *      Translate a physical Pin number to native GPIO pin number.
849  *      Provided for external support.
850  *********************************************************************************
851  */
852
853 int physPinToGpio (int physPin)
854 {
855   return physToGpio [physPin & 63] ;
856 }
857
858
859 /*
860  * setPadDrive:
861  *      Set the PAD driver value
862  *********************************************************************************
863  */
864
865 void setPadDrive (int group, int value)
866 {
867   uint32_t wrVal ;
868
869   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
870   {
871     if ((group < 0) || (group > 2))
872       return ;
873
874     wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
875     *(pads + group + 11) = wrVal ;
876
877     if (wiringPiDebug)
878     {
879       printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
880       printf ("Read : %08X\n", *(pads + group + 11)) ;
881     }
882   }
883 }
884
885
886 /*
887  * getAlt:
888  *      Returns the ALT bits for a given port. Only really of-use
889  *      for the gpio readall command (I think)
890  *********************************************************************************
891  */
892
893 int getAlt (int pin)
894 {
895   int fSel, shift, alt ;
896
897   pin &= 63 ;
898
899   /**/ if (wiringPiMode == WPI_MODE_PINS)
900     pin = pinToGpio [pin] ;
901   else if (wiringPiMode == WPI_MODE_PHYS)
902     pin = physToGpio [pin] ;
903   else if (wiringPiMode != WPI_MODE_GPIO)
904     return 0 ;
905
906   fSel    = gpioToGPFSEL [pin] ;
907   shift   = gpioToShift  [pin] ;
908
909   alt = (*(gpio + fSel) >> shift) & 7 ;
910
911   return alt ;
912 }
913
914
915 /*
916  * pwmSetMode:
917  *      Select the native "balanced" mode, or standard mark:space mode
918  *********************************************************************************
919  */
920
921 void pwmSetMode (int mode)
922 {
923   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
924   {
925     if (mode == PWM_MODE_MS)
926       *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
927     else
928       *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
929   }
930 }
931
932
933 /*
934  * pwmSetRange:
935  *      Set the PWM range register. We set both range registers to the same
936  *      value. If you want different in your own code, then write your own.
937  *********************************************************************************
938  */
939
940 void pwmSetRange (unsigned int range)
941 {
942   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
943   {
944     *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
945     *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
946   }
947 }
948
949
950 /*
951  * pwmSetClock:
952  *      Set/Change the PWM clock. Originally my code, but changed
953  *      (for the better!) by Chris Hall, <chris@kchall.plus.com>
954  *      after further study of the manual and testing with a 'scope
955  *********************************************************************************
956  */
957
958 void pwmSetClock (int divisor)
959 {
960   uint32_t pwm_control ;
961   divisor &= 4095 ;
962
963   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
964   {
965     if (wiringPiDebug)
966       printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
967
968     pwm_control = *(pwm + PWM_CONTROL) ;                // preserve PWM_CONTROL
969
970 // We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY
971 // stays high.
972
973     *(pwm + PWM_CONTROL) = 0 ;                          // Stop PWM
974
975 // Stop PWM clock before changing divisor. The delay after this does need to
976 // this big (95uS occasionally fails, 100uS OK), it's almost as though the BUSY
977 // flag is not working properly in balanced mode. Without the delay when DIV is
978 // adjusted the clock sometimes switches to very slow, once slow further DIV
979 // adjustments do nothing and it's difficult to get out of this mode.
980
981     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;        // Stop PWM Clock
982       delayMicroseconds (110) ;                 // prevents clock going sloooow
983
984     while ((*(clk + PWMCLK_CNTL) & 0x80) != 0)  // Wait for clock to be !BUSY
985       delayMicroseconds (1) ;
986
987     *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12) ;
988
989     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;        // Start PWM clock
990     *(pwm + PWM_CONTROL) = pwm_control ;                // restore PWM_CONTROL
991
992     if (wiringPiDebug)
993       printf ("Set     to: %d. Now    : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
994   }
995 }
996
997
998 /*
999  * gpioClockSet:
1000  *      Set the freuency on a GPIO clock pin
1001  *********************************************************************************
1002  */
1003
1004 void gpioClockSet (int pin, int freq)
1005 {
1006   int divi, divr, divf ;
1007
1008   pin &= 63 ;
1009
1010   /**/ if (wiringPiMode == WPI_MODE_PINS)
1011     pin = pinToGpio [pin] ;
1012   else if (wiringPiMode == WPI_MODE_PHYS)
1013     pin = physToGpio [pin] ;
1014   else if (wiringPiMode != WPI_MODE_GPIO)
1015     return ;
1016   
1017   divi = 19200000 / freq ;
1018   divr = 19200000 % freq ;
1019   divf = (int)((double)divr * 4096.0 / 19200000.0) ;
1020
1021   if (divi > 4095)
1022     divi = 4095 ;
1023
1024   *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | GPIO_CLOCK_SOURCE ;              // Stop GPIO Clock
1025   while ((*(clk + gpioToClkCon [pin]) & 0x80) != 0)                             // ... and wait
1026     ;
1027
1028   *(clk + gpioToClkDiv [pin]) = BCM_PASSWORD | (divi << 12) | divf ;            // Set dividers
1029   *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | 0x10 | GPIO_CLOCK_SOURCE ;       // Start Clock
1030 }
1031
1032
1033 /*
1034  * wiringPiFindNode:
1035  *      Locate our device node
1036  *********************************************************************************
1037  */
1038
1039 struct wiringPiNodeStruct *wiringPiFindNode (int pin)
1040 {
1041   struct wiringPiNodeStruct *node = wiringPiNodes ;
1042
1043   while (node != NULL)
1044     if ((pin >= node->pinBase) && (pin <= node->pinMax))
1045       return node ;
1046     else
1047       node = node->next ;
1048
1049   return NULL ;
1050 }
1051
1052
1053 /*
1054  * wiringPiNewNode:
1055  *      Create a new GPIO node into the wiringPi handling system
1056  *********************************************************************************
1057  */
1058
1059 static void pinModeDummy             (struct wiringPiNodeStruct *node, int pin, int mode)  { return ; }
1060 static void pullUpDnControlDummy     (struct wiringPiNodeStruct *node, int pin, int pud)   { return ; }
1061 static int  digitalReadDummy         (struct wiringPiNodeStruct *node, int pin)            { return LOW ; }
1062 static void digitalWriteDummy        (struct wiringPiNodeStruct *node, int pin, int value) { return ; }
1063 static void pwmWriteDummy            (struct wiringPiNodeStruct *node, int pin, int value) { return ; }
1064 static int  analogReadDummy          (struct wiringPiNodeStruct *node, int pin)            { return 0 ; }
1065 static void analogWriteDummy         (struct wiringPiNodeStruct *node, int pin, int value) { return ; }
1066
1067 struct wiringPiNodeStruct *wiringPiNewNode (int pinBase, int numPins)
1068 {
1069   int    pin ;
1070   struct wiringPiNodeStruct *node ;
1071
1072 // Minimum pin base is 64
1073
1074   if (pinBase < 64)
1075     (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: pinBase of %d is < 64\n", pinBase) ;
1076
1077 // Check all pins in-case there is overlap:
1078
1079   for (pin = pinBase ; pin < (pinBase + numPins) ; ++pin)
1080     if (wiringPiFindNode (pin) != NULL)
1081       (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: Pin %d overlaps with existing definition\n", pin) ;
1082
1083   node = (struct wiringPiNodeStruct *)calloc (sizeof (struct wiringPiNodeStruct), 1) ;  // calloc zeros
1084   if (node == NULL)
1085     (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: Unable to allocate memory: %s\n", strerror (errno)) ;
1086
1087   node->pinBase         = pinBase ;
1088   node->pinMax          = pinBase + numPins - 1 ;
1089   node->pinMode         = pinModeDummy ;
1090   node->pullUpDnControl = pullUpDnControlDummy ;
1091   node->digitalRead     = digitalReadDummy ;
1092   node->digitalWrite    = digitalWriteDummy ;
1093   node->pwmWrite        = pwmWriteDummy ;
1094   node->analogRead      = analogReadDummy ;
1095   node->analogWrite     = analogWriteDummy ;
1096   node->next            = wiringPiNodes ;
1097   wiringPiNodes         = node ;
1098
1099   return node ;
1100 }
1101
1102
1103 #ifdef notYetReady
1104 /*
1105  * pinED01:
1106  * pinED10:
1107  *      Enables edge-detect mode on a pin - from a 0 to a 1 or 1 to 0
1108  *      Pin must already be in input mode with appropriate pull up/downs set.
1109  *********************************************************************************
1110  */
1111
1112 void pinEnableED01Pi (int pin)
1113 {
1114   pin = pinToGpio [pin & 63] ;
1115 }
1116 #endif
1117
1118
1119 /*
1120  *********************************************************************************
1121  * Core Functions
1122  *********************************************************************************
1123  */
1124
1125 /*
1126  * pinModeAlt:
1127  *      This is an un-documented special to let you set any pin to any mode
1128  *********************************************************************************
1129  */
1130
1131 void pinModeAlt (int pin, int mode)
1132 {
1133   int fSel, shift ;
1134
1135   if ((pin & PI_GPIO_MASK) == 0)                // On-board pin
1136   {
1137     /**/ if (wiringPiMode == WPI_MODE_PINS)
1138       pin = pinToGpio [pin] ;
1139     else if (wiringPiMode == WPI_MODE_PHYS)
1140       pin = physToGpio [pin] ;
1141     else if (wiringPiMode != WPI_MODE_GPIO)
1142       return ;
1143
1144     fSel  = gpioToGPFSEL [pin] ;
1145     shift = gpioToShift  [pin] ;
1146
1147     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | ((mode & 0x7) << shift) ;
1148   }
1149 }
1150
1151
1152 /*
1153  * pinMode:
1154  *      Sets the mode of a pin to be input, output or PWM output
1155  *********************************************************************************
1156  */
1157
1158 void pinMode (int pin, int mode)
1159 {
1160   int    fSel, shift, alt ;
1161   struct wiringPiNodeStruct *node = wiringPiNodes ;
1162   int origPin = pin ;
1163
1164   if ((pin & PI_GPIO_MASK) == 0)                // On-board pin
1165   {
1166     /**/ if (wiringPiMode == WPI_MODE_PINS)
1167       pin = pinToGpio [pin] ;
1168     else if (wiringPiMode == WPI_MODE_PHYS)
1169       pin = physToGpio [pin] ;
1170     else if (wiringPiMode != WPI_MODE_GPIO)
1171       return ;
1172
1173     softPwmStop  (origPin) ;
1174     softToneStop (origPin) ;
1175
1176     fSel    = gpioToGPFSEL [pin] ;
1177     shift   = gpioToShift  [pin] ;
1178
1179     /**/ if (mode == INPUT)
1180       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
1181     else if (mode == OUTPUT)
1182       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
1183     else if (mode == SOFT_PWM_OUTPUT)
1184       softPwmCreate (origPin, 0, 100) ;
1185     else if (mode == SOFT_TONE_OUTPUT)
1186       softToneCreate (origPin) ;
1187     else if (mode == PWM_TONE_OUTPUT)
1188     {
1189       pinMode (origPin, PWM_OUTPUT) ;   // Call myself to enable PWM mode
1190       pwmSetMode (PWM_MODE_MS) ;
1191     }
1192     else if (mode == PWM_OUTPUT)
1193     {
1194       if ((alt = gpioToPwmALT [pin]) == 0)      // Not a hardware capable PWM pin
1195         return ;
1196
1197 // Set pin to PWM mode
1198
1199       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
1200       delayMicroseconds (110) ;         // See comments in pwmSetClockWPi
1201
1202       pwmSetMode  (PWM_MODE_BAL) ;      // Pi default mode
1203       pwmSetRange (1024) ;              // Default range of 1024
1204       pwmSetClock (32) ;                // 19.2 / 32 = 600KHz - Also starts the PWM
1205     }
1206     else if (mode == GPIO_CLOCK)
1207     {
1208       if ((alt = gpioToGpClkALT0 [pin]) == 0)   // Not a GPIO_CLOCK pin
1209         return ;
1210
1211 // Set pin to GPIO_CLOCK mode and set the clock frequency to 100KHz
1212
1213       *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
1214       delayMicroseconds (110) ;
1215       gpioClockSet      (pin, 100000) ;
1216     }
1217   }
1218   else
1219   {
1220     if ((node = wiringPiFindNode (pin)) != NULL)
1221       node->pinMode (node, pin, mode) ;
1222     return ;
1223   }
1224 }
1225
1226
1227 /*
1228  * pullUpDownCtrl:
1229  *      Control the internal pull-up/down resistors on a GPIO pin
1230  *      The Arduino only has pull-ups and these are enabled by writing 1
1231  *      to a port when in input mode - this paradigm doesn't quite apply
1232  *      here though.
1233  *********************************************************************************
1234  */
1235
1236 void pullUpDnControl (int pin, int pud)
1237 {
1238   struct wiringPiNodeStruct *node = wiringPiNodes ;
1239
1240   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1241   {
1242     /**/ if (wiringPiMode == WPI_MODE_PINS)
1243       pin = pinToGpio [pin] ;
1244     else if (wiringPiMode == WPI_MODE_PHYS)
1245       pin = physToGpio [pin] ;
1246     else if (wiringPiMode != WPI_MODE_GPIO)
1247       return ;
1248
1249     *(gpio + GPPUD)              = pud & 3 ;            delayMicroseconds (5) ;
1250     *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ;    delayMicroseconds (5) ;
1251     
1252     *(gpio + GPPUD)              = 0 ;                  delayMicroseconds (5) ;
1253     *(gpio + gpioToPUDCLK [pin]) = 0 ;                  delayMicroseconds (5) ;
1254   }
1255   else                                          // Extension module
1256   {
1257     if ((node = wiringPiFindNode (pin)) != NULL)
1258       node->pullUpDnControl (node, pin, pud) ;
1259     return ;
1260   }
1261 }
1262
1263
1264 /*
1265  * digitalRead:
1266  *      Read the value of a given Pin, returning HIGH or LOW
1267  *********************************************************************************
1268  */
1269
1270 int digitalRead (int pin)
1271 {
1272   char c ;
1273   struct wiringPiNodeStruct *node = wiringPiNodes ;
1274
1275   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1276   {
1277     /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS) // Sys mode
1278     {
1279       if (sysFds [pin] == -1)
1280         return LOW ;
1281
1282       lseek  (sysFds [pin], 0L, SEEK_SET) ;
1283       read   (sysFds [pin], &c, 1) ;
1284       return (c == '0') ? LOW : HIGH ;
1285     }
1286     else if (wiringPiMode == WPI_MODE_PINS)
1287       pin = pinToGpio [pin] ;
1288     else if (wiringPiMode == WPI_MODE_PHYS)
1289       pin = physToGpio [pin] ;
1290     else if (wiringPiMode != WPI_MODE_GPIO)
1291       return LOW ;
1292
1293     if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
1294       return HIGH ;
1295     else
1296       return LOW ;
1297   }
1298   else
1299   {
1300     if ((node = wiringPiFindNode (pin)) == NULL)
1301       return LOW ;
1302     return node->digitalRead (node, pin) ;
1303   }
1304 }
1305
1306
1307 /*
1308  * digitalWrite:
1309  *      Set an output bit
1310  *********************************************************************************
1311  */
1312
1313 void digitalWrite (int pin, int value)
1314 {
1315   struct wiringPiNodeStruct *node = wiringPiNodes ;
1316
1317   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1318   {
1319     /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS) // Sys mode
1320     {
1321       if (sysFds [pin] != -1)
1322       {
1323         if (value == LOW)
1324           write (sysFds [pin], "0\n", 2) ;
1325         else
1326           write (sysFds [pin], "1\n", 2) ;
1327       }
1328       return ;
1329     }
1330     else if (wiringPiMode == WPI_MODE_PINS)
1331       pin = pinToGpio [pin] ;
1332     else if (wiringPiMode == WPI_MODE_PHYS)
1333       pin = physToGpio [pin] ;
1334     else if (wiringPiMode != WPI_MODE_GPIO)
1335       return ;
1336
1337     if (value == LOW)
1338       *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
1339     else
1340       *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
1341   }
1342   else
1343   {
1344     if ((node = wiringPiFindNode (pin)) != NULL)
1345       node->digitalWrite (node, pin, value) ;
1346   }
1347 }
1348
1349
1350 /*
1351  * pwmWrite:
1352  *      Set an output PWM value
1353  *********************************************************************************
1354  */
1355
1356 void pwmWrite (int pin, int value)
1357 {
1358   struct wiringPiNodeStruct *node = wiringPiNodes ;
1359
1360   if ((pin & PI_GPIO_MASK) == 0)                // On-Board Pin
1361   {
1362     /**/ if (wiringPiMode == WPI_MODE_PINS)
1363       pin = pinToGpio [pin] ;
1364     else if (wiringPiMode == WPI_MODE_PHYS)
1365       pin = physToGpio [pin] ;
1366     else if (wiringPiMode != WPI_MODE_GPIO)
1367       return ;
1368
1369     *(pwm + gpioToPwmPort [pin]) = value ;
1370   }
1371   else
1372   {
1373     if ((node = wiringPiFindNode (pin)) != NULL)
1374       node->pwmWrite (node, pin, value) ;
1375   }
1376 }
1377
1378
1379 /*
1380  * analogRead:
1381  *      Read the analog value of a given Pin. 
1382  *      There is no on-board Pi analog hardware,
1383  *      so this needs to go to a new node.
1384  *********************************************************************************
1385  */
1386
1387 int analogRead (int pin)
1388 {
1389   struct wiringPiNodeStruct *node = wiringPiNodes ;
1390
1391   if ((node = wiringPiFindNode (pin)) == NULL)
1392     return 0 ;
1393   else
1394     return node->analogRead (node, pin) ;
1395 }
1396
1397
1398 /*
1399  * analogWrite:
1400  *      Write the analog value to the given Pin. 
1401  *      There is no on-board Pi analog hardware,
1402  *      so this needs to go to a new node.
1403  *********************************************************************************
1404  */
1405
1406 void analogWrite (int pin, int value)
1407 {
1408   struct wiringPiNodeStruct *node = wiringPiNodes ;
1409
1410   if ((node = wiringPiFindNode (pin)) == NULL)
1411     return ;
1412
1413   node->analogWrite (node, pin, value) ;
1414 }
1415
1416
1417 /*
1418  * pwmToneWrite:
1419  *      Pi Specific.
1420  *      Output the given frequency on the Pi's PWM pin
1421  *********************************************************************************
1422  */
1423
1424 void pwmToneWrite (int pin, int freq)
1425 {
1426   int range ;
1427
1428   if (freq == 0)
1429     pwmWrite (pin, 0) ;             // Off
1430   else
1431   {
1432     range = 600000 / freq ;
1433     pwmSetRange (range) ;
1434     pwmWrite    (pin, freq / 2) ;
1435   }
1436 }
1437
1438
1439
1440 /*
1441  * digitalWriteByte:
1442  *      Pi Specific
1443  *      Write an 8-bit byte to the first 8 GPIO pins - try to do it as
1444  *      fast as possible.
1445  *      However it still needs 2 operations to set the bits, so any external
1446  *      hardware must not rely on seeing a change as there will be a change 
1447  *      to set the outputs bits to zero, then another change to set the 1's
1448  *********************************************************************************
1449  */
1450
1451 void digitalWriteByte (int value)
1452 {
1453   uint32_t pinSet = 0 ;
1454   uint32_t pinClr = 0 ;
1455   int mask = 1 ;
1456   int pin ;
1457
1458   /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
1459   {
1460     for (pin = 0 ; pin < 8 ; ++pin)
1461     {
1462       digitalWrite (pin, value & mask) ;
1463       mask <<= 1 ;
1464     }
1465     return ;
1466   }
1467   else
1468   {
1469     for (pin = 0 ; pin < 8 ; ++pin)
1470     {
1471       if ((value & mask) == 0)
1472         pinClr |= (1 << pinToGpio [pin]) ;
1473       else
1474         pinSet |= (1 << pinToGpio [pin]) ;
1475
1476       mask <<= 1 ;
1477     }
1478
1479     *(gpio + gpioToGPCLR [0]) = pinClr ;
1480     *(gpio + gpioToGPSET [0]) = pinSet ;
1481   }
1482 }
1483
1484
1485 /*
1486  * waitForInterrupt:
1487  *      Pi Specific.
1488  *      Wait for Interrupt on a GPIO pin.
1489  *      This is actually done via the /sys/class/gpio interface regardless of
1490  *      the wiringPi access mode in-use. Maybe sometime it might get a better
1491  *      way for a bit more efficiency.
1492  *********************************************************************************
1493  */
1494
1495 int waitForInterrupt (int pin, int mS)
1496 {
1497   int fd, x ;
1498   uint8_t c ;
1499   struct pollfd polls ;
1500
1501   /**/ if (wiringPiMode == WPI_MODE_PINS)
1502     pin = pinToGpio [pin] ;
1503   else if (wiringPiMode == WPI_MODE_PHYS)
1504     pin = physToGpio [pin] ;
1505
1506   if ((fd = sysFds [pin]) == -1)
1507     return -2 ;
1508
1509 // Setup poll structure
1510
1511   polls.fd     = fd ;
1512   polls.events = POLLPRI ;      // Urgent data!
1513
1514 // Wait for it ...
1515
1516   x = poll (&polls, 1, mS) ;
1517
1518 // Do a dummy read to clear the interrupt
1519 //      A one character read appars to be enough.
1520 //      Followed by a seek to reset it.
1521
1522   (void)read (fd, &c, 1) ;
1523   lseek (fd, 0, SEEK_SET) ;
1524
1525   return x ;
1526 }
1527
1528
1529 /*
1530  * interruptHandler:
1531  *      This is a thread and gets started to wait for the interrupt we're
1532  *      hoping to catch. It will call the user-function when the interrupt
1533  *      fires.
1534  *********************************************************************************
1535  */
1536
1537 static void *interruptHandler (void *arg)
1538 {
1539   int myPin ;
1540
1541   (void)piHiPri (55) ;  // Only effective if we run as root
1542
1543   myPin   = pinPass ;
1544   pinPass = -1 ;
1545
1546   for (;;)
1547     if (waitForInterrupt (myPin, -1) > 0)
1548       isrFunctions [myPin] () ;
1549
1550   return NULL ;
1551 }
1552
1553
1554 /*
1555  * wiringPiISR:
1556  *      Pi Specific.
1557  *      Take the details and create an interrupt handler that will do a call-
1558  *      back to the user supplied function.
1559  *********************************************************************************
1560  */
1561
1562 int wiringPiISR (int pin, int mode, void (*function)(void))
1563 {
1564   pthread_t threadId ;
1565   const char *modeS ;
1566   char fName   [64] ;
1567   char  pinS [8] ;
1568   pid_t pid ;
1569   int   count, i ;
1570   char  c ;
1571   int   bcmGpioPin ;
1572
1573   if ((pin < 0) || (pin > 63))
1574     return wiringPiFailure (WPI_FATAL, "wiringPiISR: pin must be 0-63 (%d)\n", pin) ;
1575
1576   /**/ if (wiringPiMode == WPI_MODE_UNINITIALISED)
1577     return wiringPiFailure (WPI_FATAL, "wiringPiISR: wiringPi has not been initialised. Unable to continue.\n") ;
1578   else if (wiringPiMode == WPI_MODE_PINS)
1579     bcmGpioPin = pinToGpio [pin] ;
1580   else if (wiringPiMode == WPI_MODE_PHYS)
1581     bcmGpioPin = physToGpio [pin] ;
1582   else
1583     bcmGpioPin = pin ;
1584
1585 // Now export the pin and set the right edge
1586 //      We're going to use the gpio program to do this, so it assumes
1587 //      a full installation of wiringPi. It's a bit 'clunky', but it
1588 //      is a way that will work when we're running in "Sys" mode, as
1589 //      a non-root user. (without sudo)
1590
1591   if (mode != INT_EDGE_SETUP)
1592   {
1593     /**/ if (mode == INT_EDGE_FALLING)
1594       modeS = "falling" ;
1595     else if (mode == INT_EDGE_RISING)
1596       modeS = "rising" ;
1597     else
1598       modeS = "both" ;
1599
1600     sprintf (pinS, "%d", bcmGpioPin) ;
1601
1602     if ((pid = fork ()) < 0)    // Fail
1603       return wiringPiFailure (WPI_FATAL, "wiringPiISR: fork failed: %s\n", strerror (errno)) ;
1604
1605     if (pid == 0)       // Child, exec
1606     {
1607       /**/ if (access ("/usr/local/bin/gpio", X_OK) == 0)
1608       {
1609         execl ("/usr/local/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
1610         return wiringPiFailure (WPI_FATAL, "wiringPiISR: execl failed: %s\n", strerror (errno)) ;
1611       }
1612       else if (access ("/usr/bin/gpio", X_OK) == 0)
1613       {
1614         execl ("/usr/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
1615         return wiringPiFailure (WPI_FATAL, "wiringPiISR: execl failed: %s\n", strerror (errno)) ;
1616       }
1617       else
1618         return wiringPiFailure (WPI_FATAL, "wiringPiISR: Can't find gpio program\n") ;
1619     }
1620     else                // Parent, wait
1621       wait (NULL) ;
1622   }
1623
1624 // Now pre-open the /sys/class node - but it may already be open if
1625 //      we are in Sys mode...
1626
1627   if (sysFds [bcmGpioPin] == -1)
1628   {
1629     sprintf (fName, "/sys/class/gpio/gpio%d/value", bcmGpioPin) ;
1630     if ((sysFds [bcmGpioPin] = open (fName, O_RDWR)) < 0)
1631       return wiringPiFailure (WPI_FATAL, "wiringPiISR: unable to open %s: %s\n", fName, strerror (errno)) ;
1632   }
1633
1634 // Clear any initial pending interrupt
1635
1636   ioctl (sysFds [bcmGpioPin], FIONREAD, &count) ;
1637   for (i = 0 ; i < count ; ++i)
1638     read (sysFds [bcmGpioPin], &c, 1) ;
1639
1640   isrFunctions [pin] = function ;
1641
1642   pthread_mutex_lock (&pinMutex) ;
1643     pinPass = pin ;
1644     pthread_create (&threadId, NULL, interruptHandler, NULL) ;
1645     while (pinPass != -1)
1646       delay (1) ;
1647   pthread_mutex_unlock (&pinMutex) ;
1648
1649   return 0 ;
1650 }
1651
1652
1653 /*
1654  * initialiseEpoch:
1655  *      Initialise our start-of-time variable to be the current unix
1656  *      time in milliseconds and microseconds.
1657  *********************************************************************************
1658  */
1659
1660 static void initialiseEpoch (void)
1661 {
1662   struct timeval tv ;
1663
1664   gettimeofday (&tv, NULL) ;
1665   epochMilli = (uint64_t)tv.tv_sec * (uint64_t)1000    + (uint64_t)(tv.tv_usec / 1000) ;
1666   epochMicro = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)(tv.tv_usec) ;
1667 }
1668
1669
1670 /*
1671  * delay:
1672  *      Wait for some number of milliseconds
1673  *********************************************************************************
1674  */
1675
1676 void delay (unsigned int howLong)
1677 {
1678   struct timespec sleeper, dummy ;
1679
1680   sleeper.tv_sec  = (time_t)(howLong / 1000) ;
1681   sleeper.tv_nsec = (long)(howLong % 1000) * 1000000 ;
1682
1683   nanosleep (&sleeper, &dummy) ;
1684 }
1685
1686
1687 /*
1688  * delayMicroseconds:
1689  *      This is somewhat intersting. It seems that on the Pi, a single call
1690  *      to nanosleep takes some 80 to 130 microseconds anyway, so while
1691  *      obeying the standards (may take longer), it's not always what we
1692  *      want!
1693  *
1694  *      So what I'll do now is if the delay is less than 100uS we'll do it
1695  *      in a hard loop, watching a built-in counter on the ARM chip. This is
1696  *      somewhat sub-optimal in that it uses 100% CPU, something not an issue
1697  *      in a microcontroller, but under a multi-tasking, multi-user OS, it's
1698  *      wastefull, however we've no real choice )-:
1699  *
1700  *      Plan B: It seems all might not be well with that plan, so changing it
1701  *      to use gettimeofday () and poll on that instead...
1702  *********************************************************************************
1703  */
1704
1705 void delayMicrosecondsHard (unsigned int howLong)
1706 {
1707   struct timeval tNow, tLong, tEnd ;
1708
1709   gettimeofday (&tNow, NULL) ;
1710   tLong.tv_sec  = howLong / 1000000 ;
1711   tLong.tv_usec = howLong % 1000000 ;
1712   timeradd (&tNow, &tLong, &tEnd) ;
1713
1714   while (timercmp (&tNow, &tEnd, <))
1715     gettimeofday (&tNow, NULL) ;
1716 }
1717
1718 void delayMicroseconds (unsigned int howLong)
1719 {
1720   struct timespec sleeper ;
1721   unsigned int uSecs = howLong % 1000000 ;
1722   unsigned int wSecs = howLong / 1000000 ;
1723
1724   /**/ if (howLong ==   0)
1725     return ;
1726   else if (howLong  < 100)
1727     delayMicrosecondsHard (howLong) ;
1728   else
1729   {
1730     sleeper.tv_sec  = wSecs ;
1731     sleeper.tv_nsec = (long)(uSecs * 1000L) ;
1732     nanosleep (&sleeper, NULL) ;
1733   }
1734 }
1735
1736
1737 /*
1738  * millis:
1739  *      Return a number of milliseconds as an unsigned int.
1740  *********************************************************************************
1741  */
1742
1743 unsigned int millis (void)
1744 {
1745   struct timeval tv ;
1746   uint64_t now ;
1747
1748   gettimeofday (&tv, NULL) ;
1749   now  = (uint64_t)tv.tv_sec * (uint64_t)1000 + (uint64_t)(tv.tv_usec / 1000) ;
1750
1751   return (uint32_t)(now - epochMilli) ;
1752 }
1753
1754
1755 /*
1756  * micros:
1757  *      Return a number of microseconds as an unsigned int.
1758  *********************************************************************************
1759  */
1760
1761 unsigned int micros (void)
1762 {
1763   struct timeval tv ;
1764   uint64_t now ;
1765
1766   gettimeofday (&tv, NULL) ;
1767   now  = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)tv.tv_usec ;
1768
1769   return (uint32_t)(now - epochMicro) ;
1770 }
1771
1772
1773 /*
1774  * wiringPiSetup:
1775  *      Must be called once at the start of your program execution.
1776  *
1777  * Default setup: Initialises the system into wiringPi Pin mode and uses the
1778  *      memory mapped hardware directly.
1779  *
1780  * Changed now to revert to "gpio" mode if we're running on a Compute Module.
1781  *********************************************************************************
1782  */
1783
1784 int wiringPiSetup (void)
1785 {
1786   int   fd ;
1787   int   boardRev ;
1788   int   model, rev, mem, maker, overVolted ;
1789
1790   if (getenv (ENV_DEBUG) != NULL)
1791     wiringPiDebug = TRUE ;
1792
1793   if (getenv (ENV_CODES) != NULL)
1794     wiringPiReturnCodes = TRUE ;
1795
1796   if (geteuid () != 0)
1797     (void)wiringPiFailure (WPI_FATAL, "wiringPiSetup: Must be root. (Did you forget sudo?)\n") ;
1798
1799   if (wiringPiDebug)
1800     printf ("wiringPi: wiringPiSetup called\n") ;
1801
1802   boardRev = piBoardRev () ;
1803
1804   /**/ if (boardRev == 1)       // A, B, Rev 1, 1.1
1805   {
1806      pinToGpio =  pinToGpioR1 ;
1807     physToGpio = physToGpioR1 ;
1808   }
1809   else                          // A, B, Rev 2, B+, CM, Pi2
1810   {
1811     if (piModel2)
1812       BCM2708_PERI_BASE = 0x3F000000 ;
1813      pinToGpio =  pinToGpioR2 ;
1814     physToGpio = physToGpioR2 ;
1815   }
1816
1817 // Open the master /dev/memory device
1818
1819   if ((fd = open ("/dev/mem", O_RDWR | O_SYNC | O_CLOEXEC) ) < 0)
1820     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: Unable to open /dev/mem: %s\n", strerror (errno)) ;
1821
1822 // GPIO:
1823
1824   gpio = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_BASE) ;
1825   if ((int32_t)gpio == -1)
1826     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (GPIO) failed: %s\n", strerror (errno)) ;
1827
1828 // PWM
1829
1830   pwm = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PWM) ;
1831   if ((int32_t)pwm == -1)
1832     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (PWM) failed: %s\n", strerror (errno)) ;
1833  
1834 // Clock control (needed for PWM)
1835
1836   clk = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, CLOCK_BASE) ;
1837   if ((int32_t)clk == -1)
1838     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (CLOCK) failed: %s\n", strerror (errno)) ;
1839  
1840 // The drive pads
1841
1842   pads = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PADS) ;
1843   if ((int32_t)pads == -1)
1844     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (PADS) failed: %s\n", strerror (errno)) ;
1845
1846 #ifdef  USE_TIMER
1847 // The system timer
1848
1849   timer = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_TIMER) ;
1850   if ((int32_t)timer == -1)
1851     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (TIMER) failed: %s\n", strerror (errno)) ;
1852
1853 // Set the timer to free-running, 1MHz.
1854 //      0xF9 is 249, the timer divide is base clock / (divide+1)
1855 //      so base clock is 250MHz / 250 = 1MHz.
1856
1857   *(timer + TIMER_CONTROL) = 0x0000280 ;
1858   *(timer + TIMER_PRE_DIV) = 0x00000F9 ;
1859   timerIrqRaw = timer + TIMER_IRQ_RAW ;
1860 #endif
1861
1862   initialiseEpoch () ;
1863
1864 // If we're running on a compute module, then wiringPi pin numbers don't really many anything...
1865
1866   piBoardId (&model, &rev, &mem, &maker, &overVolted) ;
1867   if (model == PI_MODEL_CM)
1868     wiringPiMode = WPI_MODE_GPIO ;
1869   else
1870     wiringPiMode = WPI_MODE_PINS ;
1871
1872   return 0 ;
1873 }
1874
1875
1876 /*
1877  * wiringPiSetupGpio:
1878  *      Must be called once at the start of your program execution.
1879  *
1880  * GPIO setup: Initialises the system into GPIO Pin mode and uses the
1881  *      memory mapped hardware directly.
1882  *********************************************************************************
1883  */
1884
1885 int wiringPiSetupGpio (void)
1886 {
1887   (void)wiringPiSetup () ;
1888
1889   if (wiringPiDebug)
1890     printf ("wiringPi: wiringPiSetupGpio called\n") ;
1891
1892   wiringPiMode = WPI_MODE_GPIO ;
1893
1894   return 0 ;
1895 }
1896
1897
1898 /*
1899  * wiringPiSetupPhys:
1900  *      Must be called once at the start of your program execution.
1901  *
1902  * Phys setup: Initialises the system into Physical Pin mode and uses the
1903  *      memory mapped hardware directly.
1904  *********************************************************************************
1905  */
1906
1907 int wiringPiSetupPhys (void)
1908 {
1909   (void)wiringPiSetup () ;
1910
1911   if (wiringPiDebug)
1912     printf ("wiringPi: wiringPiSetupPhys called\n") ;
1913
1914   wiringPiMode = WPI_MODE_PHYS ;
1915
1916   return 0 ;
1917 }
1918
1919
1920 /*
1921  * wiringPiSetupSys:
1922  *      Must be called once at the start of your program execution.
1923  *
1924  * Initialisation (again), however this time we are using the /sys/class/gpio
1925  *      interface to the GPIO systems - slightly slower, but always usable as
1926  *      a non-root user, assuming the devices are already exported and setup correctly.
1927  */
1928
1929 int wiringPiSetupSys (void)
1930 {
1931   int boardRev ;
1932   int pin ;
1933   char fName [128] ;
1934
1935   if (getenv (ENV_DEBUG) != NULL)
1936     wiringPiDebug = TRUE ;
1937
1938   if (getenv (ENV_CODES) != NULL)
1939     wiringPiReturnCodes = TRUE ;
1940
1941   if (wiringPiDebug)
1942     printf ("wiringPi: wiringPiSetupSys called\n") ;
1943
1944   boardRev = piBoardRev () ;
1945
1946   if (boardRev == 1)
1947   {
1948      pinToGpio =  pinToGpioR1 ;
1949     physToGpio = physToGpioR1 ;
1950   }
1951   else
1952   {
1953      pinToGpio =  pinToGpioR2 ;
1954     physToGpio = physToGpioR2 ;
1955   }
1956
1957 // Open and scan the directory, looking for exported GPIOs, and pre-open
1958 //      the 'value' interface to speed things up for later
1959   
1960   for (pin = 0 ; pin < 64 ; ++pin)
1961   {
1962     sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1963     sysFds [pin] = open (fName, O_RDWR) ;
1964   }
1965
1966   initialiseEpoch () ;
1967
1968   wiringPiMode = WPI_MODE_GPIO_SYS ;
1969
1970   return 0 ;
1971 }