Gordons Projects

--> Projects Top-Level GIT

9fe3ab1b33d409376cb1c6938cce8cd3fbe9a7cb
[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  *      Much confusion here )-:
402  *      Seems there ar esome boards with 0000 in them (mistake in manufacture)
403  *      and some board with 0005 in them (another mistake in manufacture).
404  *      So the distinction between boards that I can see is:
405  *      0000 - Error
406  *      0001 - Not used
407  *      0002 - Rev 1
408  *      0003 - Rev 1
409  *      0004 - Rev 2
410  *      0005 - Rev 2
411  *      0006 - Rev 2
412  *      000f - Rev 2 + 512MB
413  *
414  *      A small thorn is the olde style overvolting - that will add in
415  *              1000000
416  *
417  *********************************************************************************
418  */
419
420 int piBoardRev (void)
421 {
422   FILE *cpuFd ;
423   char line [120] ;
424   char *c, lastChar ;
425   static int  boardRev = -1 ;
426
427 // No point checking twice...
428
429   if (boardRev != -1)
430     return boardRev ;
431
432   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
433     return -1 ;
434
435   while (fgets (line, 120, cpuFd) != NULL)
436     if (strncmp (line, "Revision", 8) == 0)
437       break ;
438
439   fclose (cpuFd) ;
440
441   if (line == NULL)
442   {
443     fprintf (stderr, "piBoardRev: Unable to determine board revision from /proc/cpuinfo\n") ;
444     fprintf (stderr, "  (No \"Revision\" line)\n") ;
445     errno = 0 ;
446     return -1 ;
447   }
448   
449   for (c = line ; *c ; ++c)
450     if (isdigit (*c))
451       break ;
452
453   if (!isdigit (*c))
454   {
455     fprintf (stderr, "piBoardRev: Unable to determine board revision from /proc/cpuinfo\n") ;
456     fprintf (stderr, "  (No numeric revision string in: \"%s\"\n", line) ;
457     errno = 0 ;
458     return -1 ;
459   }
460
461 // If you have overvolted the Pi, then it appears that the revision
462 //      has 100000 added to it!
463
464   if (wiringPiDebug)
465     if (strlen (c) != 4)
466       printf ("piboardRev: This Pi has/is overvolted!\n") ;
467
468   lastChar = c [strlen (c) - 2] ;
469
470   /**/ if ((lastChar == '2') || (lastChar == '3'))
471     boardRev = 1 ;
472   else
473     boardRev = 2 ;
474
475 #ifdef  DO_WE_CARE_ABOUT_THIS_NOW
476   else
477   {
478     fprintf (stderr, "WARNING: wiringPi: Unable to determine board revision from \"%d\"\n", r) ;
479     fprintf (stderr, " -> You may want to check:\n") ;
480     fprintf (stderr, " -> http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
481     fprintf (stderr, " -> Assuming a Rev 1 board\n") ;
482     boardRev = 1 ;
483   }
484 #endif
485
486   if (wiringPiDebug)
487     printf ("piboardRev: Revision string: %s, board revision: %d\n", c, boardRev) ;
488
489   return boardRev ;
490 }
491
492
493
494 /*
495  * pinMode:
496  *      Sets the mode of a pin to be input, output or PWM output
497  *********************************************************************************
498  */
499
500 void pinModeGpio (int pin, int mode)
501 {
502   int fSel, shift, alt ;
503
504   pin &= 63 ;
505
506   fSel    = gpioToGPFSEL [pin] ;
507   shift   = gpioToShift  [pin] ;
508
509   /**/ if (mode == INPUT)
510     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
511   else if (mode == OUTPUT)
512     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
513   else if (mode == PWM_OUTPUT)
514   {
515     if ((alt = gpioToPwmALT [pin]) == 0)        // Not a PWM pin
516       return ;
517
518 // Set pin to PWM mode
519
520     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
521
522 //  Page 107 of the BCM Peripherals manual talks about the GPIO clocks,
523 //      but I'm assuming (hoping!) that this applies to other clocks too.
524
525     *(pwm + PWM_CONTROL) = 0 ;                          // Stop PWM
526     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;        // Stop PWM Clock
527       delayMicroseconds (110) ; // See comments in pwmSetClockWPi
528
529     (void)*(pwm + PWM_CONTROL) ;
530     while ((*(pwm + PWM_CONTROL) & 0x80) != 0)  // Wait for clock to be !BUSY
531       delayMicroseconds (1) ;
532
533     *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (32 << 12) ;  // set pwm div to 32 (19.2/32 = 600KHz)
534     *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;        // enable clk
535
536 // Default range regsiter of 1024
537
538     *(pwm + PWM0_DATA) = 0 ; *(pwm + PWM0_RANGE) = 1024 ;
539     *(pwm + PWM1_DATA) = 0 ; *(pwm + PWM1_RANGE) = 1024 ;
540
541 // Enable PWMs in balanced mode (default)
542
543     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
544   }
545
546 // When we change mode of any pin, we remove the pull up/downs
547 //      Or we used to... Hm. Commented out now because for some wieird reason,
548 //      it seems to block subsequent attempts to set the pull up/downs and I've
549 //      not quite gotten to the bottom of why this happens
550 //      The down-side is that the pull up/downs are rememberd in the SoC between
551 //      power cycles, so it's going to be a good idea to explicitly set them in
552 //      any new code.
553 //
554 //  pullUpDnControl (pin, PUD_OFF) ;
555
556 }
557
558 void pinModeWPi (int pin, int mode)
559 {
560   pinModeGpio (pinToGpio [pin & 63], mode) ;
561 }
562
563 void pinModeSys (int pin, int mode)
564 {
565   return ;
566 }
567
568
569 /*
570  * pwmControl:
571  *      Allow the user to control some of the PWM functions
572  *********************************************************************************
573  */
574
575 void pwmSetModeWPi (int mode)
576 {
577   if (mode == PWM_MODE_MS)
578     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
579   else
580     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
581 }
582
583 void pwmSetModeSys (int mode)
584 {
585   return ;
586 }
587
588
589 void pwmSetRangeWPi (unsigned int range)
590 {
591   *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
592   *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
593 }
594
595 void pwmSetRangeSys (unsigned int range)
596 {
597   return ;
598 }
599
600 /*
601  * pwmSetClockWPi:
602  *      Set/Change the PWM clock. Originally my code, but changed
603  *      (for the better!) by Chris Hall, <chris@kchall.plus.com>
604  *      after further study of the manual and testing with a 'scope
605  *********************************************************************************
606  */
607
608 void pwmSetClockWPi (int divisor)
609 {
610   unsigned int pwm_control ;
611   divisor &= 4095 ;
612
613   if (wiringPiDebug)
614     printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
615
616   pwm_control = *(pwm + PWM_CONTROL) ;          // preserve PWM_CONTROL
617
618 // We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY
619 // stays high.
620
621   *(pwm + PWM_CONTROL) = 0 ;                    // Stop PWM
622
623 // Stop PWM clock before changing divisor. The delay after this does need to
624 // this big (95uS occasionally fails, 100uS OK), it's almost as though the BUSY
625 // flag is not working properly in balanced mode. Without the delay when DIV is
626 // adjusted the clock sometimes switches to very slow, once slow further DIV
627 // adjustments do nothing and it's difficult to get out of this mode.
628
629   *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;  // Stop PWM Clock
630     delayMicroseconds (110) ;                   // prevents clock going sloooow
631
632   while ((*(pwm + PWM_CONTROL) & 0x80) != 0)    // Wait for clock to be !BUSY
633     delayMicroseconds (1) ;
634
635   *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12) ;
636
637   *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;  // Start PWM clock
638   *(pwm + PWM_CONTROL) = pwm_control ;          // restore PWM_CONTROL
639
640   if (wiringPiDebug)
641     printf ("Set     to: %d. Now    : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
642 }
643
644 void pwmSetClockSys (int divisor)
645 {
646   return ;
647 }
648
649
650 #ifdef notYetReady
651 /*
652  * pinED01:
653  * pinED10:
654  *      Enables edge-detect mode on a pin - from a 0 to a 1 or 1 to 0
655  *      Pin must already be in input mode with appropriate pull up/downs set.
656  *********************************************************************************
657  */
658
659 void pinEnableED01Pi (int pin)
660 {
661   pin = pinToGpio [pin & 63] ;
662 }
663 #endif
664
665
666
667 /*
668  * digitalWrite:
669  *      Set an output bit
670  *********************************************************************************
671  */
672
673 void digitalWriteWPi (int pin, int value)
674 {
675   pin = pinToGpio [pin & 63] ;
676
677   if (value == LOW)
678     *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
679   else
680     *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
681 }
682
683 void digitalWriteGpio (int pin, int value)
684 {
685   pin &= 63 ;
686
687   if (value == LOW)
688     *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
689   else
690     *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
691 }
692
693 void digitalWriteSys (int pin, int value)
694 {
695   pin &= 63 ;
696
697   if (sysFds [pin] != -1)
698   {
699     if (value == LOW)
700       write (sysFds [pin], "0\n", 2) ;
701     else
702       write (sysFds [pin], "1\n", 2) ;
703   }
704 }
705
706
707 /*
708  * pwmWrite:
709  *      Set an output PWM value
710  *********************************************************************************
711  */
712
713 void pwmWriteGpio (int pin, int value)
714 {
715   int port ;
716
717   pin  = pin & 63 ;
718   port = gpioToPwmPort [pin] ;
719
720   *(pwm + port) = value ;
721 }
722
723 void pwmWriteWPi (int pin, int value)
724 {
725   pwmWriteGpio (pinToGpio [pin & 63], value) ;
726 }
727
728 void pwmWriteSys (int pin, int value)
729 {
730   return ;
731 }
732
733
734 /*
735  * setPadDrive:
736  *      Set the PAD driver value
737  *********************************************************************************
738  */
739
740 void setPadDriveWPi (int group, int value)
741 {
742   uint32_t wrVal ;
743
744   if ((group < 0) || (group > 2))
745     return ;
746
747   wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
748   *(pads + group + 11) = wrVal ;
749
750 #ifdef  DEBUG_PADS
751   printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
752   printf ("Read : %08X\n", *(pads + group + 11)) ;
753 #endif
754 }
755
756 void setPadDriveGpio (int group, int value)
757 {
758   setPadDriveWPi (group, value) ;
759 }
760
761 void setPadDriveSys (int group, int value)
762 {
763   return ;
764 }
765
766
767 /*
768  * digitalRead:
769  *      Read the value of a given Pin, returning HIGH or LOW
770  *********************************************************************************
771  */
772
773 int digitalReadWPi (int pin)
774 {
775   pin = pinToGpio [pin & 63] ;
776
777   if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
778     return HIGH ;
779   else
780     return LOW ;
781 }
782
783 int digitalReadGpio (int pin)
784 {
785   pin &= 63 ;
786
787   if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
788     return HIGH ;
789   else
790     return LOW ;
791 }
792
793 int digitalReadSys (int pin)
794 {
795   char c ;
796
797   pin &= 63 ;
798
799   if (sysFds [pin] == -1)
800     return 0 ;
801
802   lseek (sysFds [pin], 0L, SEEK_SET) ;
803   read  (sysFds [pin], &c, 1) ;
804   return (c == '0') ? 0 : 1 ;
805 }
806
807
808 /*
809  * pullUpDownCtrl:
810  *      Control the internal pull-up/down resistors on a GPIO pin
811  *      The Arduino only has pull-ups and these are enabled by writing 1
812  *      to a port when in input mode - this paradigm doesn't quite apply
813  *      here though.
814  *********************************************************************************
815  */
816
817 void pullUpDnControlGpio (int pin, int pud)
818 {
819   pin &= 63 ;
820   pud &=  3 ;
821
822   *(gpio + GPPUD)              = pud ;                  delayMicroseconds (5) ;
823   *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ;      delayMicroseconds (5) ;
824   
825   *(gpio + GPPUD)              = 0 ;                    delayMicroseconds (5) ;
826   *(gpio + gpioToPUDCLK [pin]) = 0 ;                    delayMicroseconds (5) ;
827 }
828
829 void pullUpDnControlWPi (int pin, int pud)
830 {
831   pullUpDnControlGpio (pinToGpio [pin & 63], pud) ;
832 }
833
834 void pullUpDnControlSys (int pin, int pud)
835 {
836   return ;
837 }
838
839
840 /*
841  * waitForInterrupt:
842  *      Wait for Interrupt on a GPIO pin.
843  *      This is actually done via the /sys/class/gpio interface regardless of
844  *      the wiringPi access mode in-use. Maybe sometime it might get a better
845  *      way for a bit more efficiency.
846  *********************************************************************************
847  */
848
849 int waitForInterruptSys (int pin, int mS)
850 {
851   int fd, x ;
852   char buf [8] ;
853   struct pollfd polls ;
854
855   if ((fd = sysFds [pin & 63]) == -1)
856     return -2 ;
857
858 // Do a dummy read
859
860   x = read (fd, buf, 6) ;
861   if (x < 0)
862     return x ;
863
864 // And seek
865
866   lseek (fd, 0, SEEK_SET) ;
867
868 // Setup poll structure
869
870   polls.fd     = fd ;
871   polls.events = POLLPRI ;      // Urgent data!
872
873 // Wait for it ...
874
875   return poll (&polls, 1, mS) ;
876 }
877
878 int waitForInterruptWPi (int pin, int mS)
879 {
880   return waitForInterruptSys (pinToGpio [pin & 63], mS) ;
881 }
882
883 int waitForInterruptGpio (int pin, int mS)
884 {
885   return waitForInterruptSys (pin, mS) ;
886 }
887
888
889 /*
890  * delay:
891  *      Wait for some number of milli seconds
892  *********************************************************************************
893  */
894
895 void delay (unsigned int howLong)
896 {
897   struct timespec sleeper, dummy ;
898
899   sleeper.tv_sec  = (time_t)(howLong / 1000) ;
900   sleeper.tv_nsec = (long)(howLong % 1000) * 1000000 ;
901
902   nanosleep (&sleeper, &dummy) ;
903 }
904
905
906 /*
907  * delayMicroseconds:
908  *      This is somewhat intersting. It seems that on the Pi, a single call
909  *      to nanosleep takes some 80 to 130 microseconds anyway, so while
910  *      obeying the standards (may take longer), it's not always what we
911  *      want!
912  *
913  *      So what I'll do now is if the delay is less than 100uS we'll do it
914  *      in a hard loop, watching a built-in counter on the ARM chip. This is
915  *      somewhat sub-optimal in that it uses 100% CPU, something not an issue
916  *      in a microcontroller, but under a multi-tasking, multi-user OS, it's
917  *      wastefull, however we've no real choice )-:
918  *********************************************************************************
919  */
920
921 void delayMicrosecondsSys (unsigned int howLong)
922 {
923   struct timespec sleeper, dummy ;
924
925   sleeper.tv_sec  = 0 ;
926   sleeper.tv_nsec = (long)(howLong * 1000) ;
927
928   nanosleep (&sleeper, &dummy) ;
929 }
930
931 void delayMicrosecondsHard (unsigned int howLong)
932 {
933   *(timer + TIMER_LOAD)    = howLong ;
934   *(timer + TIMER_IRQ_CLR) = 0 ;
935
936   while (*timerIrqRaw == 0)
937     ;
938 }
939
940 void delayMicrosecondsWPi (unsigned int howLong)
941 {
942   struct timespec sleeper, dummy ;
943
944   /**/ if (howLong ==   0)
945     return ;
946   else if (howLong  < 100)
947     delayMicrosecondsHard (howLong) ;
948   else
949   {
950     sleeper.tv_sec  = 0 ;
951     sleeper.tv_nsec = (long)(howLong * 1000) ;
952     nanosleep (&sleeper, &dummy) ;
953   }
954 }
955
956
957 /*
958  * millis:
959  *      Return a number of milliseconds as an unsigned int.
960  *********************************************************************************
961  */
962
963 unsigned int millis (void)
964 {
965   struct timeval tv ;
966   unsigned long long t1 ;
967
968   gettimeofday (&tv, NULL) ;
969
970   t1 = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
971
972   return (uint32_t)(t1 - epoch) ;
973 }
974
975
976 /*
977  * wiringPiSetup:
978  *      Must be called once at the start of your program execution.
979  *
980  * Default setup: Initialises the system into wiringPi Pin mode and uses the
981  *      memory mapped hardware directly.
982  *********************************************************************************
983  */
984
985 int wiringPiSetup (void)
986 {
987   int      fd ;
988   int      boardRev ;
989   uint8_t *gpioMem, *pwmMem, *clkMem, *padsMem, *timerMem ;
990   struct timeval tv ;
991
992   if (getenv ("WIRINGPI_DEBUG") != NULL)
993     wiringPiDebug = TRUE ;
994
995   if (wiringPiDebug)
996     printf ("wiringPi: wiringPiSetup called\n") ;
997
998             pinMode =           pinModeWPi ;
999     pullUpDnControl =   pullUpDnControlWPi ;
1000        digitalWrite =      digitalWriteWPi ;
1001            pwmWrite =          pwmWriteWPi ;
1002         setPadDrive =       setPadDriveWPi ;
1003         digitalRead =       digitalReadWPi ;
1004    waitForInterrupt =  waitForInterruptWPi ;
1005   delayMicroseconds = delayMicrosecondsWPi ;
1006          pwmSetMode =        pwmSetModeWPi ;
1007         pwmSetRange =       pwmSetRangeWPi ;
1008         pwmSetClock =       pwmSetClockWPi ;
1009   
1010   if ((boardRev = piBoardRev ()) < 0)
1011     return -1 ;
1012
1013   if (boardRev == 1)
1014     pinToGpio = pinToGpioR1 ;
1015   else
1016     pinToGpio = pinToGpioR2 ;
1017
1018 // Open the master /dev/memory device
1019
1020   if ((fd = open ("/dev/mem", O_RDWR | O_SYNC) ) < 0)
1021   {
1022     fprintf (stderr, "wiringPiSetup: Unable to open /dev/mem: %s\n", strerror (errno)) ;
1023     return -1 ;
1024   }
1025
1026 // GPIO:
1027
1028 // Allocate 2 pages - 1 ...
1029
1030   if ((gpioMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
1031   {
1032     fprintf (stderr, "wiringPiSetup: malloc failed: %s\n", strerror (errno)) ;
1033     return -1 ;
1034   }
1035
1036 // ... presumably to make sure we can round it up to a whole page size
1037
1038   if (((uint32_t)gpioMem % PAGE_SIZE) != 0)
1039     gpioMem += PAGE_SIZE - ((uint32_t)gpioMem % PAGE_SIZE) ;
1040
1041   gpio = (uint32_t *)mmap((caddr_t)gpioMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_BASE) ;
1042
1043   if ((int32_t)gpio < 0)
1044   {
1045     fprintf (stderr, "wiringPiSetup: mmap failed: %s\n", strerror (errno)) ;
1046     return -1 ;
1047   }
1048
1049 // PWM
1050
1051   if ((pwmMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
1052   {
1053     fprintf (stderr, "wiringPiSetup: pwmMem malloc failed: %s\n", strerror (errno)) ;
1054     return -1 ;
1055   }
1056
1057   if (((uint32_t)pwmMem % PAGE_SIZE) != 0)
1058     pwmMem += PAGE_SIZE - ((uint32_t)pwmMem % PAGE_SIZE) ;
1059
1060   pwm = (uint32_t *)mmap(pwmMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_PWM) ;
1061
1062   if ((int32_t)pwm < 0)
1063   {
1064     fprintf (stderr, "wiringPiSetup: mmap failed (pwm): %s\n", strerror (errno)) ;
1065     return -1 ;
1066   }
1067  
1068 // Clock control (needed for PWM)
1069
1070   if ((clkMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
1071   {
1072     fprintf (stderr, "wiringPiSetup: clkMem malloc failed: %s\n", strerror (errno)) ;
1073     return -1 ;
1074   }
1075
1076   if (((uint32_t)clkMem % PAGE_SIZE) != 0)
1077     clkMem += PAGE_SIZE - ((uint32_t)clkMem % PAGE_SIZE) ;
1078
1079   clk = (uint32_t *)mmap(clkMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, CLOCK_BASE) ;
1080
1081   if ((int32_t)clk < 0)
1082   {
1083     fprintf (stderr, "wiringPiSetup: mmap failed (clk): %s\n", strerror (errno)) ;
1084     return -1 ;
1085   }
1086  
1087 // The drive pads
1088
1089   if ((padsMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
1090   {
1091     fprintf (stderr, "wiringPiSetup: padsMem malloc failed: %s\n", strerror (errno)) ;
1092     return -1 ;
1093   }
1094
1095   if (((uint32_t)padsMem % PAGE_SIZE) != 0)
1096     padsMem += PAGE_SIZE - ((uint32_t)padsMem % PAGE_SIZE) ;
1097
1098   pads = (uint32_t *)mmap(padsMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_PADS) ;
1099
1100   if ((int32_t)pads < 0)
1101   {
1102     fprintf (stderr, "wiringPiSetup: mmap failed (pads): %s\n", strerror (errno)) ;
1103     return -1 ;
1104   }
1105
1106 #ifdef  DEBUG_PADS
1107   printf ("Checking pads @ 0x%08X\n", (unsigned int)pads) ;
1108   printf (" -> %08X %08X %08X\n", *(pads + 11), *(pads + 12), *(pads + 13)) ;
1109 #endif
1110
1111 // The system timer
1112
1113   if ((timerMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
1114   {
1115     fprintf (stderr, "wiringPiSetup: timerMem malloc failed: %s\n", strerror (errno)) ;
1116     return -1 ;
1117   }
1118
1119   if (((uint32_t)timerMem % PAGE_SIZE) != 0)
1120     timerMem += PAGE_SIZE - ((uint32_t)timerMem % PAGE_SIZE) ;
1121
1122   timer = (uint32_t *)mmap(timerMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_TIMER) ;
1123
1124   if ((int32_t)timer < 0)
1125   {
1126     fprintf (stderr, "wiringPiSetup: mmap failed (timer): %s\n", strerror (errno)) ;
1127     return -1 ;
1128   }
1129
1130 // Set the timer to free-running, 1MHz.
1131 //      0xF9 is 249, the timer divide is base clock / (divide+1)
1132 //      so base clock is 250MHz / 250 = 1MHz.
1133
1134   *(timer + TIMER_CONTROL) = 0x0000280 ;
1135   *(timer + TIMER_PRE_DIV) = 0x00000F9 ;
1136   timerIrqRaw = timer + TIMER_IRQ_RAW ;
1137
1138 // Initialise our epoch for millis()
1139
1140   gettimeofday (&tv, NULL) ;
1141   epoch = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
1142
1143   return 0 ;
1144 }
1145
1146
1147 /*
1148  * wiringPiSetupGpio:
1149  *      Must be called once at the start of your program execution.
1150  *
1151  * GPIO setup: Initialises the system into GPIO Pin mode and uses the
1152  *      memory mapped hardware directly.
1153  *********************************************************************************
1154  */
1155
1156 int wiringPiSetupGpio (void)
1157 {
1158   int x  ;
1159
1160   if (wiringPiDebug)
1161     printf ("wiringPi: wiringPiSetupGpio called\n") ;
1162
1163   if ((x = wiringPiSetup ()) < 0)
1164     return x ;
1165
1166             pinMode =           pinModeGpio ;
1167     pullUpDnControl =   pullUpDnControlGpio ;
1168        digitalWrite =      digitalWriteGpio ;
1169            pwmWrite =          pwmWriteGpio ;
1170         setPadDrive =       setPadDriveGpio ;
1171         digitalRead =       digitalReadGpio ;
1172    waitForInterrupt =  waitForInterruptGpio ;
1173   delayMicroseconds = delayMicrosecondsWPi ;    // Same
1174          pwmSetMode =        pwmSetModeWPi ;
1175         pwmSetRange =       pwmSetRangeWPi ;
1176         pwmSetClock =       pwmSetClockWPi ;
1177
1178   return 0 ;
1179 }
1180
1181
1182 /*
1183  * wiringPiSetupSys:
1184  *      Must be called once at the start of your program execution.
1185  *
1186  * Initialisation (again), however this time we are using the /sys/class/gpio
1187  *      interface to the GPIO systems - slightly slower, but always usable as
1188  *      a non-root user, assuming the devices are already exported and setup correctly.
1189  */
1190
1191 int wiringPiSetupSys (void)
1192 {
1193   int pin ;
1194   struct timeval tv ;
1195   char fName [128] ;
1196
1197   if (wiringPiDebug)
1198     printf ("wiringPi: wiringPiSetupSys called\n") ;
1199
1200             pinMode =           pinModeSys ;
1201     pullUpDnControl =   pullUpDnControlSys ;
1202        digitalWrite =      digitalWriteSys ;
1203            pwmWrite =          pwmWriteSys ;
1204         setPadDrive =       setPadDriveSys ;
1205         digitalRead =       digitalReadSys ;
1206    waitForInterrupt =  waitForInterruptSys ;
1207   delayMicroseconds = delayMicrosecondsSys ;
1208          pwmSetMode =        pwmSetModeSys ;
1209         pwmSetRange =       pwmSetRangeSys ;
1210         pwmSetClock =       pwmSetClockSys ;
1211
1212
1213 // Open and scan the directory, looking for exported GPIOs, and pre-open
1214 //      the 'value' interface to speed things up for later
1215   
1216   for (pin = 0 ; pin < 64 ; ++pin)
1217   {
1218     sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1219     sysFds [pin] = open (fName, O_RDWR) ;
1220   }
1221
1222 // Initialise the epoch for mills() ...
1223
1224   gettimeofday (&tv, NULL) ;
1225   epoch = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
1226
1227   return 0 ;
1228 }