Gordons Projects

--> Projects Top-Level GIT

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