Gordons Projects

--> Projects Top-Level GIT

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