Gordons Projects

--> Projects Top-Level GIT

Updating gpio manual page
[wiringPi] / wiringPi / wiringPi.c
1 /*
2  * wiringPi:
3  *      Arduino compatable (ish) Wiring library for the Raspberry Pi
4  *      Copyright (c) 2012 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 // Pad drive current fiddling
55
56 #undef  DEBUG_PADS
57
58 #include <stdio.h>
59 #include <stdint.h>
60 #include <stdlib.h>
61 #include <ctype.h>
62 #include <poll.h>
63 #include <unistd.h>
64 #include <errno.h>
65 #include <string.h>
66 #include <time.h>
67 #include <fcntl.h>
68 #include <sys/time.h>
69 #include <sys/mman.h>
70 #include <sys/types.h>
71 #include <sys/stat.h>
72
73 #include "wiringPi.h"
74
75 // Function stubs
76
77 void (*pinMode)           (int pin, int mode) ;
78 void (*pullUpDnControl)   (int pin, int pud) ;
79 void (*digitalWrite)      (int pin, int value) ;
80 void (*pwmWrite)          (int pin, int value) ;
81 void (*setPadDrive)       (int group, int value) ;
82 int  (*digitalRead)       (int pin) ;
83 int  (*waitForInterrupt)  (int pin, int mS) ;
84 void (*delayMicroseconds) (unsigned int howLong) ;
85 void (*pwmSetMode)        (int mode) ;
86 void (*pwmSetRange)       (unsigned int range) ;
87 void (*pwmSetClock)       (int divisor) ;
88
89
90 #ifndef TRUE
91 #define TRUE    (1==1)
92 #define FALSE   (1==2)
93 #endif
94
95 // BCM Magic
96
97 #define BCM_PASSWORD            0x5A000000
98
99
100 // Port function select bits
101
102 #define FSEL_INPT               0b000
103 #define FSEL_OUTP               0b001
104 #define FSEL_ALT0               0b100
105 #define FSEL_ALT0               0b100
106 #define FSEL_ALT1               0b101
107 #define FSEL_ALT2               0b110
108 #define FSEL_ALT3               0b111
109 #define FSEL_ALT4               0b011
110 #define FSEL_ALT5               0b010
111
112 // Access from ARM Running Linux
113 //      Take from Gert/Doms code. Some of this is not in the manual
114 //      that I can find )-:
115
116 #define BCM2708_PERI_BASE                          0x20000000
117 #define GPIO_PADS               (BCM2708_PERI_BASE + 0x100000)
118 #define CLOCK_BASE              (BCM2708_PERI_BASE + 0x101000)
119 #define GPIO_BASE               (BCM2708_PERI_BASE + 0x200000)
120 #define GPIO_TIMER              (BCM2708_PERI_BASE + 0x00B000)
121 #define GPIO_PWM                (BCM2708_PERI_BASE + 0x20C000)
122
123 #define PAGE_SIZE               (4*1024)
124 #define BLOCK_SIZE              (4*1024)
125
126 // PWM
127
128 #define PWM_CONTROL 0
129 #define PWM_STATUS  1
130 #define PWM0_RANGE  4
131 #define PWM0_DATA   5
132 #define PWM1_RANGE  8
133 #define PWM1_DATA   9
134
135 #define PWMCLK_CNTL     40
136 #define PWMCLK_DIV      41
137
138 #define PWM1_MS_MODE    0x8000  // Run in MS mode
139 #define PWM1_USEFIFO    0x2000  // Data from FIFO
140 #define PWM1_REVPOLAR   0x1000  // Reverse polarity
141 #define PWM1_OFFSTATE   0x0800  // Ouput Off state
142 #define PWM1_REPEATFF   0x0400  // Repeat last value if FIFO empty
143 #define PWM1_SERIAL     0x0200  // Run in serial mode
144 #define PWM1_ENABLE     0x0100  // Channel Enable
145
146 #define PWM0_MS_MODE    0x0080  // Run in MS mode
147 #define PWM0_USEFIFO    0x0020  // Data from FIFO
148 #define PWM0_REVPOLAR   0x0010  // Reverse polarity
149 #define PWM0_OFFSTATE   0x0008  // Ouput Off state
150 #define PWM0_REPEATFF   0x0004  // Repeat last value if FIFO empty
151 #define PWM0_SERIAL     0x0002  // Run in serial mode
152 #define PWM0_ENABLE     0x0001  // Channel Enable
153
154 // Timer
155
156 #define TIMER_LOAD      (0x400 >> 2)
157 #define TIMER_VALUE     (0x404 >> 2)
158 #define TIMER_CONTROL   (0x408 >> 2)
159 #define TIMER_IRQ_CLR   (0x40C >> 2)
160 #define TIMER_IRQ_RAW   (0x410 >> 2)
161 #define TIMER_IRQ_MASK  (0x414 >> 2)
162 #define TIMER_RELOAD    (0x418 >> 2)
163 #define TIMER_PRE_DIV   (0x41C >> 2)
164 #define TIMER_COUNTER   (0x420 >> 2)
165
166 // Locals to hold pointers to the hardware
167
168 static volatile uint32_t *gpio ;
169 static volatile uint32_t *pwm ;
170 static volatile uint32_t *clk ;
171 static volatile uint32_t *pads ;
172 static volatile uint32_t *timer ;
173 static volatile uint32_t *timerIrqRaw ;
174
175 // Debugging
176
177 static int wiringPiDebug = FALSE ;
178
179 // The BCM2835 has 54 GPIO pins.
180 //      BCM2835 data sheet, Page 90 onwards.
181 //      There are 6 control registers, each control the functions of a block
182 //      of 10 pins.
183 //      Each control register has 10 sets of 3 bits per GPIO pin:
184 //
185 //      000 = GPIO Pin X is an input
186 //      001 = GPIO Pin X is an output
187 //      100 = GPIO Pin X takes alternate function 0
188 //      101 = GPIO Pin X takes alternate function 1
189 //      110 = GPIO Pin X takes alternate function 2
190 //      111 = GPIO Pin X takes alternate function 3
191 //      011 = GPIO Pin X takes alternate function 4
192 //      010 = GPIO Pin X takes alternate function 5
193 //
194 // So the 3 bits for port X are:
195 //      X / 10 + ((X % 10) * 3)
196
197 // sysFds:
198 //      Map a file descriptor from the /sys/class/gpio/gpioX/value
199
200 static int sysFds [64] ;
201
202 // Doing it the Arduino way with lookup tables...
203 //      Yes, it's probably more innefficient than all the bit-twidling, but it
204 //      does tend to make it all a bit clearer. At least to me!
205
206 // pinToGpio:
207 //      Take a Wiring pin (0 through X) and re-map it to the BCM_GPIO pin
208 //      Cope for 2 different board revieions here
209
210 static int *pinToGpio ;
211
212 static int pinToGpioR1 [64] =
213 {
214   17, 18, 21, 22, 23, 24, 25, 4,        // From the Original Wiki - GPIO 0 through 7
215    0,  1,                               // I2C  - SDA0, SCL0
216    8,  7,                               // SPI  - CE1, CE0
217   10,  9, 11,                           // SPI  - MOSI, MISO, SCLK
218   14, 15,                               // UART - Tx, Rx
219
220 // Padding:
221
222       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 31
223   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
224   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
225 } ;
226
227 static int pinToGpioR2 [64] =
228 {
229   17, 18, 27, 22, 23, 24, 25, 4,        // From the Original Wiki - GPIO 0 through 7:   wpi  0 -  7
230    2,  3,                               // I2C  - SDA0, SCL0                            wpi  8 -  9
231    8,  7,                               // SPI  - CE1, CE0                              wpi 10 - 11
232   10,  9, 11,                           // SPI  - MOSI, MISO, SCLK                      wpi 12 - 14
233   14, 15,                               // UART - Tx, Rx                                wpi 15 - 16
234   28, 29, 30, 31,                       // New GPIOs 8 though 11                        wpi 17 - 20
235
236 // Padding:
237
238                       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 31
239   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
240   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
241 } ;
242
243
244 // gpioToGPFSEL:
245 //      Map a BCM_GPIO pin to it's control port. (GPFSEL 0-5)
246
247 static uint8_t gpioToGPFSEL [] =
248 {
249   0,0,0,0,0,0,0,0,0,0,
250   1,1,1,1,1,1,1,1,1,1,
251   2,2,2,2,2,2,2,2,2,2,
252   3,3,3,3,3,3,3,3,3,3,
253   4,4,4,4,4,4,4,4,4,4,
254   5,5,5,5,5,5,5,5,5,5,
255 } ;
256
257
258 // gpioToShift
259 //      Define the shift up for the 3 bits per pin in each GPFSEL port
260
261 static uint8_t gpioToShift [] =
262 {
263   0,3,6,9,12,15,18,21,24,27,
264   0,3,6,9,12,15,18,21,24,27,
265   0,3,6,9,12,15,18,21,24,27,
266   0,3,6,9,12,15,18,21,24,27,
267   0,3,6,9,12,15,18,21,24,27,
268 } ;
269
270
271 // gpioToGPSET:
272 //      (Word) offset to the GPIO Set registers for each GPIO pin
273
274 static uint8_t gpioToGPSET [] =
275 {
276    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,
277    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,
278 } ;
279
280
281 // gpioToGPCLR:
282 //      (Word) offset to the GPIO Clear registers for each GPIO pin
283
284 static uint8_t gpioToGPCLR [] =
285 {
286   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,
287   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,
288 } ;
289
290
291 // gpioToGPLEV:
292 //      (Word) offset to the GPIO Input level registers for each GPIO pin
293
294 static uint8_t gpioToGPLEV [] =
295 {
296   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,
297   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,
298 } ;
299
300
301 #ifdef notYetReady
302 // gpioToEDS
303 //      (Word) offset to the Event Detect Status
304
305 static uint8_t gpioToEDS [] =
306 {
307   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,
308   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,
309 } ;
310
311 // gpioToREN
312 //      (Word) offset to the Rising edgde ENable register
313
314 static uint8_t gpioToREN [] =
315 {
316   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,
317   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,
318 } ;
319
320 // gpioToFEN
321 //      (Word) offset to the Falling edgde ENable register
322
323 static uint8_t gpioToFEN [] =
324 {
325   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,
326   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,
327 } ;
328 #endif
329
330
331 // gpioToPUDCLK
332 //      (Word) offset to the Pull Up Down Clock regsiter
333
334 #define GPPUD   37
335
336 static uint8_t gpioToPUDCLK [] =
337 {
338   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,
339   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,
340 } ;
341
342
343 // gpioToPwmALT
344 //      the ALT value to put a GPIO pin into PWM mode
345
346 static uint8_t gpioToPwmALT [] =
347 {
348           0,         0,         0,         0,         0,         0,         0,         0,       //  0 ->  7
349           0,         0,         0,         0, FSEL_ALT0, FSEL_ALT0,         0,         0,       //  8 -> 15
350           0,         0, FSEL_ALT5, FSEL_ALT5,         0,         0,         0,         0,       // 16 -> 23
351           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
352           0,         0,         0,         0,         0,         0,         0,         0,       // 32 -> 39
353   FSEL_ALT0, FSEL_ALT0,         0,         0,         0, FSEL_ALT0,         0,         0,       // 40 -> 47
354           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
355           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
356 } ;
357
358 static uint8_t gpioToPwmPort [] =
359 {
360           0,         0,         0,         0,         0,         0,         0,         0,       //  0 ->  7
361           0,         0,         0,         0, PWM0_DATA, PWM1_DATA,         0,         0,       //  8 -> 15
362           0,         0, PWM0_DATA, PWM1_DATA,         0,         0,         0,         0,       // 16 -> 23
363           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
364           0,         0,         0,         0,         0,         0,         0,         0,       // 32 -> 39
365   PWM0_DATA, PWM1_DATA,         0,         0,         0, PWM1_DATA,         0,         0,       // 40 -> 47
366           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
367           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
368
369 } ;
370
371
372 // Time for easy calculations
373
374 static unsigned long long epoch ;
375
376 /*
377  * Functions
378  *********************************************************************************
379  */
380
381
382 /*
383  * wpiPinToGpio:
384  *      Translate a wiringPi Pin number to native GPIO pin number.
385  *      (We don't use this here, prefering to just do the lookup directly,
386  *      but it's been requested!)
387  *********************************************************************************
388  */
389
390 int wpiPinToGpio (int wpiPin)
391 {
392   return pinToGpio [wpiPin & 63] ;
393 }
394
395
396 /*
397  * piBoardRev:
398  *      Return a number representing the hardware revision of the board.
399  *      Revision is currently 1 or 2. -1 is returned on error.
400  *********************************************************************************
401  */
402
403 int piBoardRev (void)
404 {
405   FILE *cpuFd ;
406   char line [80] ;
407   char *c ;
408   int  r = -1 ;
409   static int  boardRev = -1 ;
410
411 // No point checking twice...
412
413   if (boardRev != -1)
414     return boardRev ;
415
416   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
417     return -1 ;
418
419   while (fgets (line, 80, cpuFd) != NULL)
420     if (strncmp (line, "Revision", 8) == 0)
421       for (c = line ; *c ; ++c)
422       {
423         if (!isdigit (*c))
424           continue ;
425         r = atoi (c) ;
426         break ;
427       }
428
429   fclose (cpuFd) ;
430
431   if (r == -1)
432   {
433     fprintf (stderr, "piBoardRev: Unable to determine board revision from /proc/cpuinfo\n") ;
434     errno = 0 ;
435     return -1 ;
436   }
437
438 // If you have overvolted the Pi, then it appears that the revision
439 //      has 100000 added to it!
440
441   if (wiringPiDebug)
442     if (r > 1000)
443       printf ("piboardRev: This Pi has/is overvolted!\n") ;
444
445   r %= 100 ;
446
447   /**/ if ((r == 2) || (r == 3))
448     boardRev = 1 ;
449   else if ((r == 4) || (r == 5) || (r == 6))
450     boardRev = 2 ;
451   else
452   {
453     fprintf (stderr, "WARNING: wiringPi: Unable to determine board revision from \"%d\"\n", r) ;
454     fprintf (stderr, " -> You may want to check:\n") ;
455     fprintf (stderr, " -> http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
456     fprintf (stderr, " -> Assuming a Rev 1 board\n") ;
457     boardRev = 1 ;
458   }
459
460   if (wiringPiDebug)
461     printf ("piboardRev: Revision: %d, board revision: %d\n", r, boardRev) ;
462
463   return boardRev ;
464 }
465
466
467
468 /*
469  * pinMode:
470  *      Sets the mode of a pin to be input, output or PWM output
471  *********************************************************************************
472  */
473
474 void pinModeGpio (int pin, int mode)
475 {
476   int fSel, shift, alt ;
477
478   pin &= 63 ;
479
480   fSel    = gpioToGPFSEL [pin] ;
481   shift   = gpioToShift  [pin] ;
482
483   /**/ if (mode == INPUT)
484     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
485   else if (mode == OUTPUT)
486     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
487   else if (mode == PWM_OUTPUT)
488   {
489     if ((alt = gpioToPwmALT [pin]) == 0)        // Not a PWM pin
490       return ;
491
492 // Set pin to PWM mode
493
494     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
495
496 //  Page 107 of the BCM Peripherals manual talks about the GPIO clocks,
497 //      but I'm assuming (hoping!) that this applies to other clocks too.
498
499     *(pwm + PWM_CONTROL) = 0 ;                          // Stop PWM
500     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;        // Stop PWM Clock
501       delayMicroseconds (110) ; // See comments in pwmSetClockWPi
502
503     (void)*(pwm + PWM_CONTROL) ;
504     while ((*(pwm + PWM_CONTROL) & 0x80) != 0)  // Wait for clock to be !BUSY
505       delayMicroseconds (1) ;
506
507     *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (32 << 12) ;  // set pwm div to 32 (19.2/32 = 600KHz)
508     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;        // enable clk
509
510 // Default range regsiter of 1024
511
512     *(pwm + PWM0_DATA) = 0 ; *(pwm + PWM0_RANGE) = 1024 ;
513     *(pwm + PWM1_DATA) = 0 ; *(pwm + PWM1_RANGE) = 1024 ;
514
515 // Enable PWMs in balanced mode (default)
516
517     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
518   }
519
520 // When we change mode of any pin, we remove the pull up/downs
521 //      Or we used to... Hm. Commented out now because for some wieird reason,
522 //      it seems to block subsequent attempts to set the pull up/downs and I've
523 //      not quite gotten to the bottom of why this happens
524 //      The down-side is that the pull up/downs are rememberd in the SoC between
525 //      power cycles, so it's going to be a good idea to explicitly set them in
526 //      any new code.
527 //
528 //  pullUpDnControl (pin, PUD_OFF) ;
529
530 }
531
532 void pinModeWPi (int pin, int mode)
533 {
534   pinModeGpio (pinToGpio [pin & 63], mode) ;
535 }
536
537 void pinModeSys (int pin, int mode)
538 {
539   return ;
540 }
541
542
543 /*
544  * pwmControl:
545  *      Allow the user to control some of the PWM functions
546  *********************************************************************************
547  */
548
549 void pwmSetModeWPi (int mode)
550 {
551   if (mode == PWM_MODE_MS)
552     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
553   else
554     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
555 }
556
557 void pwmSetModeSys (int mode)
558 {
559   return ;
560 }
561
562
563 void pwmSetRangeWPi (unsigned int range)
564 {
565   *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
566   *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
567 }
568
569 void pwmSetRangeSys (unsigned int range)
570 {
571   return ;
572 }
573
574 /*
575  * pwmSetClockWPi:
576  *      Set/Change the PWM clock. Originally my code, but changed
577  *      (for the better!) by Chris Hall, <chris@kchall.plus.com>
578  *      after further study of the manual and testing with a 'scope
579  *********************************************************************************
580  */
581
582 void pwmSetClockWPi (int divisor)
583 {
584   unsigned int pwm_control ;
585   divisor &= 4095 ;
586
587   if (wiringPiDebug)
588     printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
589
590   pwm_control = *(pwm + PWM_CONTROL) ;          // preserve PWM_CONTROL
591
592 // We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY
593 // stays high.
594
595   *(pwm + PWM_CONTROL) = 0 ;                    // Stop PWM
596
597 // Stop PWM clock before changing divisor. The delay after this does need to
598 // this big (95uS occasionally fails, 100uS OK), it's almost as though the BUSY
599 // flag is not working properly in balanced mode. Without the delay when DIV is
600 // adjusted the clock sometimes switches to very slow, once slow further DIV
601 // adjustments do nothing and it's difficult to get out of this mode.
602
603   *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;  // Stop PWM Clock
604     delayMicroseconds (110) ;                   // prevents clock going sloooow
605
606   while ((*(pwm + PWM_CONTROL) & 0x80) != 0)    // Wait for clock to be !BUSY
607     delayMicroseconds (1) ;
608
609   *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12) ;
610
611   *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;  // Start PWM clock
612   *(pwm + PWM_CONTROL) = pwm_control ;          // restore PWM_CONTROL
613
614   if (wiringPiDebug)
615     printf ("Set     to: %d. Now    : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
616 }
617
618 void pwmSetClockSys (int divisor)
619 {
620   return ;
621 }
622
623
624 #ifdef notYetReady
625 /*
626  * pinED01:
627  * pinED10:
628  *      Enables edge-detect mode on a pin - from a 0 to a 1 or 1 to 0
629  *      Pin must already be in input mode with appropriate pull up/downs set.
630  *********************************************************************************
631  */
632
633 void pinEnableED01Pi (int pin)
634 {
635   pin = pinToGpio [pin & 63] ;
636 }
637 #endif
638
639
640
641 /*
642  * digitalWrite:
643  *      Set an output bit
644  *********************************************************************************
645  */
646
647 void digitalWriteWPi (int pin, int value)
648 {
649   pin = pinToGpio [pin & 63] ;
650
651   if (value == LOW)
652     *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
653   else
654     *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
655 }
656
657 void digitalWriteGpio (int pin, int value)
658 {
659   pin &= 63 ;
660
661   if (value == LOW)
662     *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
663   else
664     *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
665 }
666
667 void digitalWriteSys (int pin, int value)
668 {
669   pin &= 63 ;
670
671   if (sysFds [pin] != -1)
672   {
673     if (value == LOW)
674       write (sysFds [pin], "0\n", 2) ;
675     else
676       write (sysFds [pin], "1\n", 2) ;
677   }
678 }
679
680
681 /*
682  * pwmWrite:
683  *      Set an output PWM value
684  *********************************************************************************
685  */
686
687 void pwmWriteGpio (int pin, int value)
688 {
689   int port ;
690
691   pin  = pin & 63 ;
692   port = gpioToPwmPort [pin] ;
693
694   *(pwm + port) = value ;
695 }
696
697 void pwmWriteWPi (int pin, int value)
698 {
699   pwmWriteGpio (pinToGpio [pin & 63], value) ;
700 }
701
702 void pwmWriteSys (int pin, int value)
703 {
704   return ;
705 }
706
707
708 /*
709  * setPadDrive:
710  *      Set the PAD driver value
711  *********************************************************************************
712  */
713
714 void setPadDriveWPi (int group, int value)
715 {
716   uint32_t wrVal ;
717
718   if ((group < 0) || (group > 2))
719     return ;
720
721   wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
722   *(pads + group + 11) = wrVal ;
723
724 #ifdef  DEBUG_PADS
725   printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
726   printf ("Read : %08X\n", *(pads + group + 11)) ;
727 #endif
728 }
729
730 void setPadDriveGpio (int group, int value)
731 {
732   setPadDriveWPi (group, value) ;
733 }
734
735 void setPadDriveSys (int group, int value)
736 {
737   return ;
738 }
739
740
741 /*
742  * digitalRead:
743  *      Read the value of a given Pin, returning HIGH or LOW
744  *********************************************************************************
745  */
746
747 int digitalReadWPi (int pin)
748 {
749   pin = pinToGpio [pin & 63] ;
750
751   if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
752     return HIGH ;
753   else
754     return LOW ;
755 }
756
757 int digitalReadGpio (int pin)
758 {
759   pin &= 63 ;
760
761   if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
762     return HIGH ;
763   else
764     return LOW ;
765 }
766
767 int digitalReadSys (int pin)
768 {
769   char c ;
770
771   pin &= 63 ;
772
773   if (sysFds [pin] == -1)
774     return 0 ;
775
776   lseek (sysFds [pin], 0L, SEEK_SET) ;
777   read  (sysFds [pin], &c, 1) ;
778   return (c == '0') ? 0 : 1 ;
779 }
780
781
782 /*
783  * pullUpDownCtrl:
784  *      Control the internal pull-up/down resistors on a GPIO pin
785  *      The Arduino only has pull-ups and these are enabled by writing 1
786  *      to a port when in input mode - this paradigm doesn't quite apply
787  *      here though.
788  *********************************************************************************
789  */
790
791 void pullUpDnControlGpio (int pin, int pud)
792 {
793   pin &= 63 ;
794   pud &=  3 ;
795
796   *(gpio + GPPUD)              = pud ;                  delayMicroseconds (5) ;
797   *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ;      delayMicroseconds (5) ;
798   
799   *(gpio + GPPUD)              = 0 ;                    delayMicroseconds (5) ;
800   *(gpio + gpioToPUDCLK [pin]) = 0 ;                    delayMicroseconds (5) ;
801 }
802
803 void pullUpDnControlWPi (int pin, int pud)
804 {
805   pullUpDnControlGpio (pinToGpio [pin & 63], pud) ;
806 }
807
808 void pullUpDnControlSys (int pin, int pud)
809 {
810   return ;
811 }
812
813
814 /*
815  * waitForInterrupt:
816  *      Wait for Interrupt on a GPIO pin.
817  *      This is actually done via the /sys/class/gpio interface regardless of
818  *      the wiringPi access mode in-use. Maybe sometime it might get a better
819  *      way for a bit more efficiency.
820  *********************************************************************************
821  */
822
823 int waitForInterruptSys (int pin, int mS)
824 {
825   int fd, x ;
826   char buf [8] ;
827   struct pollfd polls ;
828
829   if ((fd = sysFds [pin & 63]) == -1)
830     return -2 ;
831
832 // Do a dummy read
833
834   x = read (fd, buf, 6) ;
835   if (x < 0)
836     return x ;
837
838 // And seek
839
840   lseek (fd, 0, SEEK_SET) ;
841
842 // Setup poll structure
843
844   polls.fd     = fd ;
845   polls.events = POLLPRI ;      // Urgent data!
846
847 // Wait for it ...
848
849   return poll (&polls, 1, mS) ;
850 }
851
852 int waitForInterruptWPi (int pin, int mS)
853 {
854   return waitForInterruptSys (pinToGpio [pin & 63], mS) ;
855 }
856
857 int waitForInterruptGpio (int pin, int mS)
858 {
859   return waitForInterruptSys (pin, mS) ;
860 }
861
862
863 /*
864  * delay:
865  *      Wait for some number of milli seconds
866  *********************************************************************************
867  */
868
869 void delay (unsigned int howLong)
870 {
871   struct timespec sleeper, dummy ;
872
873   sleeper.tv_sec  = (time_t)(howLong / 1000) ;
874   sleeper.tv_nsec = (long)(howLong % 1000) * 1000000 ;
875
876   nanosleep (&sleeper, &dummy) ;
877 }
878
879
880 /*
881  * delayMicroseconds:
882  *      This is somewhat intersting. It seems that on the Pi, a single call
883  *      to nanosleep takes some 80 to 130 microseconds anyway, so while
884  *      obeying the standards (may take longer), it's not always what we
885  *      want!
886  *
887  *      So what I'll do now is if the delay is less than 100uS we'll do it
888  *      in a hard loop, watching a built-in counter on the ARM chip. This is
889  *      somewhat sub-optimal in that it uses 100% CPU, something not an issue
890  *      in a microcontroller, but under a multi-tasking, multi-user OS, it's
891  *      wastefull, however we've no real choice )-:
892  *********************************************************************************
893  */
894
895 void delayMicrosecondsSys (unsigned int howLong)
896 {
897   struct timespec sleeper, dummy ;
898
899   sleeper.tv_sec  = 0 ;
900   sleeper.tv_nsec = (long)(howLong * 1000) ;
901
902   nanosleep (&sleeper, &dummy) ;
903 }
904
905 void delayMicrosecondsHard (unsigned int howLong)
906 {
907   *(timer + TIMER_LOAD)    = howLong ;
908   *(timer + TIMER_IRQ_CLR) = 0 ;
909
910   while (*timerIrqRaw == 0)
911     ;
912 }
913
914 void delayMicrosecondsWPi (unsigned int howLong)
915 {
916   struct timespec sleeper, dummy ;
917
918   /**/ if (howLong ==   0)
919     return ;
920   else if (howLong  < 100)
921     delayMicrosecondsHard (howLong) ;
922   else
923   {
924     sleeper.tv_sec  = 0 ;
925     sleeper.tv_nsec = (long)(howLong * 1000) ;
926     nanosleep (&sleeper, &dummy) ;
927   }
928 }
929
930
931 /*
932  * millis:
933  *      Return a number of milliseconds as an unsigned int.
934  *********************************************************************************
935  */
936
937 unsigned int millis (void)
938 {
939   struct timeval tv ;
940   unsigned long long t1 ;
941
942   gettimeofday (&tv, NULL) ;
943
944   t1 = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
945
946   return (uint32_t)(t1 - epoch) ;
947 }
948
949
950 /*
951  * wiringPiSetup:
952  *      Must be called once at the start of your program execution.
953  *
954  * Default setup: Initialises the system into wiringPi Pin mode and uses the
955  *      memory mapped hardware directly.
956  *********************************************************************************
957  */
958
959 int wiringPiSetup (void)
960 {
961   int      fd ;
962   int      boardRev ;
963   uint8_t *gpioMem, *pwmMem, *clkMem, *padsMem, *timerMem ;
964   struct timeval tv ;
965
966   if (getenv ("WIRINGPI_DEBUG") != NULL)
967     wiringPiDebug = TRUE ;
968
969   if (wiringPiDebug)
970     printf ("wiringPi: wiringPiSetup called\n") ;
971
972             pinMode =           pinModeWPi ;
973     pullUpDnControl =   pullUpDnControlWPi ;
974        digitalWrite =      digitalWriteWPi ;
975            pwmWrite =          pwmWriteWPi ;
976         setPadDrive =       setPadDriveWPi ;
977         digitalRead =       digitalReadWPi ;
978    waitForInterrupt =  waitForInterruptWPi ;
979   delayMicroseconds = delayMicrosecondsWPi ;
980          pwmSetMode =        pwmSetModeWPi ;
981         pwmSetRange =       pwmSetRangeWPi ;
982         pwmSetClock =       pwmSetClockWPi ;
983   
984   if ((boardRev = piBoardRev ()) < 0)
985     return -1 ;
986
987   if (boardRev == 1)
988     pinToGpio = pinToGpioR1 ;
989   else
990     pinToGpio = pinToGpioR2 ;
991
992 // Open the master /dev/memory device
993
994   if ((fd = open ("/dev/mem", O_RDWR | O_SYNC) ) < 0)
995   {
996     fprintf (stderr, "wiringPiSetup: Unable to open /dev/mem: %s\n", strerror (errno)) ;
997     return -1 ;
998   }
999
1000 // GPIO:
1001
1002 // Allocate 2 pages - 1 ...
1003
1004   if ((gpioMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
1005   {
1006     fprintf (stderr, "wiringPiSetup: malloc failed: %s\n", strerror (errno)) ;
1007     return -1 ;
1008   }
1009
1010 // ... presumably to make sure we can round it up to a whole page size
1011
1012   if (((uint32_t)gpioMem % PAGE_SIZE) != 0)
1013     gpioMem += PAGE_SIZE - ((uint32_t)gpioMem % PAGE_SIZE) ;
1014
1015   gpio = (uint32_t *)mmap((caddr_t)gpioMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_BASE) ;
1016
1017   if ((int32_t)gpio < 0)
1018   {
1019     fprintf (stderr, "wiringPiSetup: mmap failed: %s\n", strerror (errno)) ;
1020     return -1 ;
1021   }
1022
1023 // PWM
1024
1025   if ((pwmMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
1026   {
1027     fprintf (stderr, "wiringPiSetup: pwmMem malloc failed: %s\n", strerror (errno)) ;
1028     return -1 ;
1029   }
1030
1031   if (((uint32_t)pwmMem % PAGE_SIZE) != 0)
1032     pwmMem += PAGE_SIZE - ((uint32_t)pwmMem % PAGE_SIZE) ;
1033
1034   pwm = (uint32_t *)mmap(pwmMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_PWM) ;
1035
1036   if ((int32_t)pwm < 0)
1037   {
1038     fprintf (stderr, "wiringPiSetup: mmap failed (pwm): %s\n", strerror (errno)) ;
1039     return -1 ;
1040   }
1041  
1042 // Clock control (needed for PWM)
1043
1044   if ((clkMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
1045   {
1046     fprintf (stderr, "wiringPiSetup: clkMem malloc failed: %s\n", strerror (errno)) ;
1047     return -1 ;
1048   }
1049
1050   if (((uint32_t)clkMem % PAGE_SIZE) != 0)
1051     clkMem += PAGE_SIZE - ((uint32_t)clkMem % PAGE_SIZE) ;
1052
1053   clk = (uint32_t *)mmap(clkMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, CLOCK_BASE) ;
1054
1055   if ((int32_t)clk < 0)
1056   {
1057     fprintf (stderr, "wiringPiSetup: mmap failed (clk): %s\n", strerror (errno)) ;
1058     return -1 ;
1059   }
1060  
1061 // The drive pads
1062
1063   if ((padsMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
1064   {
1065     fprintf (stderr, "wiringPiSetup: padsMem malloc failed: %s\n", strerror (errno)) ;
1066     return -1 ;
1067   }
1068
1069   if (((uint32_t)padsMem % PAGE_SIZE) != 0)
1070     padsMem += PAGE_SIZE - ((uint32_t)padsMem % PAGE_SIZE) ;
1071
1072   pads = (uint32_t *)mmap(padsMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_PADS) ;
1073
1074   if ((int32_t)pads < 0)
1075   {
1076     fprintf (stderr, "wiringPiSetup: mmap failed (pads): %s\n", strerror (errno)) ;
1077     return -1 ;
1078   }
1079
1080 #ifdef  DEBUG_PADS
1081   printf ("Checking pads @ 0x%08X\n", (unsigned int)pads) ;
1082   printf (" -> %08X %08X %08X\n", *(pads + 11), *(pads + 12), *(pads + 13)) ;
1083 #endif
1084
1085 // The system timer
1086
1087   if ((timerMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
1088   {
1089     fprintf (stderr, "wiringPiSetup: timerMem malloc failed: %s\n", strerror (errno)) ;
1090     return -1 ;
1091   }
1092
1093   if (((uint32_t)timerMem % PAGE_SIZE) != 0)
1094     timerMem += PAGE_SIZE - ((uint32_t)timerMem % PAGE_SIZE) ;
1095
1096   timer = (uint32_t *)mmap(timerMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_TIMER) ;
1097
1098   if ((int32_t)timer < 0)
1099   {
1100     fprintf (stderr, "wiringPiSetup: mmap failed (timer): %s\n", strerror (errno)) ;
1101     return -1 ;
1102   }
1103
1104 // Set the timer to free-running, 1MHz.
1105 //      0xF9 is 249, the timer divide is base clock / (divide+1)
1106 //      so base clock is 250MHz / 250 = 1MHz.
1107
1108   *(timer + TIMER_CONTROL) = 0x0000280 ;
1109   *(timer + TIMER_PRE_DIV) = 0x00000F9 ;
1110   timerIrqRaw = timer + TIMER_IRQ_RAW ;
1111
1112 // Initialise our epoch for millis()
1113
1114   gettimeofday (&tv, NULL) ;
1115   epoch = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
1116
1117   return 0 ;
1118 }
1119
1120
1121 /*
1122  * wiringPiSetupGpio:
1123  *      Must be called once at the start of your program execution.
1124  *
1125  * GPIO setup: Initialises the system into GPIO Pin mode and uses the
1126  *      memory mapped hardware directly.
1127  *********************************************************************************
1128  */
1129
1130 int wiringPiSetupGpio (void)
1131 {
1132   int x  ;
1133
1134   if (wiringPiDebug)
1135     printf ("wiringPi: wiringPiSetupGpio called\n") ;
1136
1137   if ((x = wiringPiSetup ()) < 0)
1138     return x ;
1139
1140             pinMode =           pinModeGpio ;
1141     pullUpDnControl =   pullUpDnControlGpio ;
1142        digitalWrite =      digitalWriteGpio ;
1143            pwmWrite =          pwmWriteGpio ;
1144         setPadDrive =       setPadDriveGpio ;
1145         digitalRead =       digitalReadGpio ;
1146    waitForInterrupt =  waitForInterruptGpio ;
1147   delayMicroseconds = delayMicrosecondsWPi ;    // Same
1148          pwmSetMode =        pwmSetModeWPi ;
1149         pwmSetRange =       pwmSetRangeWPi ;
1150         pwmSetClock =       pwmSetClockWPi ;
1151
1152   return 0 ;
1153 }
1154
1155
1156 /*
1157  * wiringPiSetupSys:
1158  *      Must be called once at the start of your program execution.
1159  *
1160  * Initialisation (again), however this time we are using the /sys/class/gpio
1161  *      interface to the GPIO systems - slightly slower, but always usable as
1162  *      a non-root user, assuming the devices are already exported and setup correctly.
1163  */
1164
1165 int wiringPiSetupSys (void)
1166 {
1167   int pin ;
1168   struct timeval tv ;
1169   char fName [128] ;
1170
1171   if (wiringPiDebug)
1172     printf ("wiringPi: wiringPiSetupSys called\n") ;
1173
1174             pinMode =           pinModeSys ;
1175     pullUpDnControl =   pullUpDnControlSys ;
1176        digitalWrite =      digitalWriteSys ;
1177            pwmWrite =          pwmWriteSys ;
1178         setPadDrive =       setPadDriveSys ;
1179         digitalRead =       digitalReadSys ;
1180    waitForInterrupt =  waitForInterruptSys ;
1181   delayMicroseconds = delayMicrosecondsSys ;
1182          pwmSetMode =        pwmSetModeSys ;
1183         pwmSetRange =       pwmSetRangeSys ;
1184         pwmSetClock =       pwmSetClockSys ;
1185
1186
1187 // Open and scan the directory, looking for exported GPIOs, and pre-open
1188 //      the 'value' interface to speed things up for later
1189   
1190   for (pin = 0 ; pin < 64 ; ++pin)
1191   {
1192     sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1193     sysFds [pin] = open (fName, O_RDWR) ;
1194   }
1195
1196 // Initialise the epoch for mills() ...
1197
1198   gettimeofday (&tv, NULL) ;
1199   epoch = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
1200
1201   return 0 ;
1202 }