Gordons Projects

--> Projects Top-Level GIT

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