Gordons Projects

--> Projects Top-Level GIT

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