Gordons Projects

--> Projects Top-Level GIT

Added a clock mode to enable the GPIo pins to be set with
[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
55 #include <stdio.h>
56 #include <stdint.h>
57 #include <stdlib.h>
58 #include <ctype.h>
59 #include <poll.h>
60 #include <unistd.h>
61 #include <errno.h>
62 #include <string.h>
63 #include <time.h>
64 #include <fcntl.h>
65 #include <pthread.h>
66 #include <sys/time.h>
67 #include <sys/mman.h>
68 #include <sys/stat.h>
69 #include <sys/wait.h>
70 #include <sys/ioctl.h>
71
72 #include "wiringPi.h"
73
74 // Function stubs
75
76 void (*pinMode)           (int pin, int mode) ;
77 int  (*getAlt)            (int pin) ;
78 void (*pullUpDnControl)   (int pin, int pud) ;
79 void (*digitalWrite)      (int pin, int value) ;
80 void (*digitalWriteByte)  (int value) ;
81 void (*pwmWrite)          (int pin, int value) ;
82 void (*gpioClockSet)      (int pin, int value) ;
83 void (*setPadDrive)       (int group, int value) ;
84 int  (*digitalRead)       (int pin) ;
85 int  (*waitForInterrupt)  (int pin, int mS) ;
86 void (*pwmSetMode)        (int mode) ;
87 void (*pwmSetRange)       (unsigned int range) ;
88 void (*pwmSetClock)       (int divisor) ;
89
90
91 #ifndef TRUE
92 #define TRUE    (1==1)
93 #define FALSE   (1==2)
94 #endif
95
96 // BCM Magic
97
98 #define BCM_PASSWORD            0x5A000000
99
100
101 // The BCM2835 has 54 GPIO pins.
102 //      BCM2835 data sheet, Page 90 onwards.
103 //      There are 6 control registers, each control the functions of a block
104 //      of 10 pins.
105 //      Each control register has 10 sets of 3 bits per GPIO pin - the ALT values
106 //
107 //      000 = GPIO Pin X is an input
108 //      001 = GPIO Pin X is an output
109 //      100 = GPIO Pin X takes alternate function 0
110 //      101 = GPIO Pin X takes alternate function 1
111 //      110 = GPIO Pin X takes alternate function 2
112 //      111 = GPIO Pin X takes alternate function 3
113 //      011 = GPIO Pin X takes alternate function 4
114 //      010 = GPIO Pin X takes alternate function 5
115 //
116 // So the 3 bits for port X are:
117 //      X / 10 + ((X % 10) * 3)
118
119 // Port function select bits
120
121 #define FSEL_INPT               0b000
122 #define FSEL_OUTP               0b001
123 #define FSEL_ALT0               0b100
124 #define FSEL_ALT0               0b100
125 #define FSEL_ALT1               0b101
126 #define FSEL_ALT2               0b110
127 #define FSEL_ALT3               0b111
128 #define FSEL_ALT4               0b011
129 #define FSEL_ALT5               0b010
130
131 // Access from ARM Running Linux
132 //      Taken from Gert/Doms code. Some of this is not in the manual
133 //      that I can find )-:
134
135 #define BCM2708_PERI_BASE                            0x20000000
136 #define GPIO_PADS               (BCM2708_PERI_BASE + 0x00100000)
137 #define CLOCK_BASE              (BCM2708_PERI_BASE + 0x00101000)
138 #define GPIO_BASE               (BCM2708_PERI_BASE + 0x00200000)
139 #define GPIO_TIMER              (BCM2708_PERI_BASE + 0x0000B000)
140 #define GPIO_PWM                (BCM2708_PERI_BASE + 0x0020C000)
141
142 #define PAGE_SIZE               (4*1024)
143 #define BLOCK_SIZE              (4*1024)
144
145 // PWM
146 //      Word offsets into the PWM control region
147
148 #define PWM_CONTROL 0
149 #define PWM_STATUS  1
150 #define PWM0_RANGE  4
151 #define PWM0_DATA   5
152 #define PWM1_RANGE  8
153 #define PWM1_DATA   9
154
155 //      Clock regsiter offsets
156
157 #define PWMCLK_CNTL     40
158 #define PWMCLK_DIV      41
159
160 #define PWM0_MS_MODE    0x0080  // Run in MS mode
161 #define PWM0_USEFIFO    0x0020  // Data from FIFO
162 #define PWM0_REVPOLAR   0x0010  // Reverse polarity
163 #define PWM0_OFFSTATE   0x0008  // Ouput Off state
164 #define PWM0_REPEATFF   0x0004  // Repeat last value if FIFO empty
165 #define PWM0_SERIAL     0x0002  // Run in serial mode
166 #define PWM0_ENABLE     0x0001  // Channel Enable
167
168 #define PWM1_MS_MODE    0x8000  // Run in MS mode
169 #define PWM1_USEFIFO    0x2000  // Data from FIFO
170 #define PWM1_REVPOLAR   0x1000  // Reverse polarity
171 #define PWM1_OFFSTATE   0x0800  // Ouput Off state
172 #define PWM1_REPEATFF   0x0400  // Repeat last value if FIFO empty
173 #define PWM1_SERIAL     0x0200  // Run in serial mode
174 #define PWM1_ENABLE     0x0100  // Channel Enable
175
176 // Timer
177 //      Word offsets
178
179 #define TIMER_LOAD      (0x400 >> 2)
180 #define TIMER_VALUE     (0x404 >> 2)
181 #define TIMER_CONTROL   (0x408 >> 2)
182 #define TIMER_IRQ_CLR   (0x40C >> 2)
183 #define TIMER_IRQ_RAW   (0x410 >> 2)
184 #define TIMER_IRQ_MASK  (0x414 >> 2)
185 #define TIMER_RELOAD    (0x418 >> 2)
186 #define TIMER_PRE_DIV   (0x41C >> 2)
187 #define TIMER_COUNTER   (0x420 >> 2)
188
189 // Locals to hold pointers to the hardware
190
191 static volatile uint32_t *gpio ;
192 static volatile uint32_t *pwm ;
193 static volatile uint32_t *clk ;
194 static volatile uint32_t *pads ;
195 static volatile uint32_t *timer ;
196 static volatile uint32_t *timerIrqRaw ;
197
198 // Time for easy calculations
199
200 static uint64_t epochMilli, epochMicro ;
201
202 // Misc
203
204 static int wiringPiMode = WPI_MODE_UNINITIALISED ;
205
206 // Debugging
207
208 int wiringPiDebug = FALSE ;
209
210 // sysFds:
211 //      Map a file descriptor from the /sys/class/gpio/gpioX/value
212
213 static int sysFds [64] ;
214
215 // ISR Data
216
217 static void (*isrFunctions [64])(void) ;
218
219
220 // Doing it the Arduino way with lookup tables...
221 //      Yes, it's probably more innefficient than all the bit-twidling, but it
222 //      does tend to make it all a bit clearer. At least to me!
223
224 // pinToGpio:
225 //      Take a Wiring pin (0 through X) and re-map it to the BCM_GPIO pin
226 //      Cope for 2 different board revieions here
227
228 static int *pinToGpio ;
229
230 static int pinToGpioR1 [64] =
231 {
232   17, 18, 21, 22, 23, 24, 25, 4,        // From the Original Wiki - GPIO 0 through 7
233    0,  1,                               // I2C  - SDA0, SCL0
234    8,  7,                               // SPI  - CE1, CE0
235   10,  9, 11,                           // SPI  - MOSI, MISO, SCLK
236   14, 15,                               // UART - Tx, Rx
237
238 // Padding:
239
240       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 31
241   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
242   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
243 } ;
244
245 static int pinToGpioR2 [64] =
246 {
247   17, 18, 27, 22, 23, 24, 25, 4,        // From the Original Wiki - GPIO 0 through 7:   wpi  0 -  7
248    2,  3,                               // I2C  - SDA0, SCL0                            wpi  8 -  9
249    8,  7,                               // SPI  - CE1, CE0                              wpi 10 - 11
250   10,  9, 11,                           // SPI  - MOSI, MISO, SCLK                      wpi 12 - 14
251   14, 15,                               // UART - Tx, Rx                                wpi 15 - 16
252   28, 29, 30, 31,                       // New GPIOs 8 though 11                        wpi 17 - 20
253
254 // Padding:
255
256                       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 31
257   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 47
258   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,       // ... 63
259 } ;
260
261
262 // gpioToGPFSEL:
263 //      Map a BCM_GPIO pin to it's control port. (GPFSEL 0-5)
264
265 static uint8_t gpioToGPFSEL [] =
266 {
267   0,0,0,0,0,0,0,0,0,0,
268   1,1,1,1,1,1,1,1,1,1,
269   2,2,2,2,2,2,2,2,2,2,
270   3,3,3,3,3,3,3,3,3,3,
271   4,4,4,4,4,4,4,4,4,4,
272   5,5,5,5,5,5,5,5,5,5,
273 } ;
274
275
276 // gpioToShift
277 //      Define the shift up for the 3 bits per pin in each GPFSEL port
278
279 static uint8_t gpioToShift [] =
280 {
281   0,3,6,9,12,15,18,21,24,27,
282   0,3,6,9,12,15,18,21,24,27,
283   0,3,6,9,12,15,18,21,24,27,
284   0,3,6,9,12,15,18,21,24,27,
285   0,3,6,9,12,15,18,21,24,27,
286 } ;
287
288
289 // gpioToGPSET:
290 //      (Word) offset to the GPIO Set registers for each GPIO pin
291
292 static uint8_t gpioToGPSET [] =
293 {
294    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,
295    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,
296 } ;
297
298
299 // gpioToGPCLR:
300 //      (Word) offset to the GPIO Clear registers for each GPIO pin
301
302 static uint8_t gpioToGPCLR [] =
303 {
304   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,
305   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,
306 } ;
307
308
309 // gpioToGPLEV:
310 //      (Word) offset to the GPIO Input level registers for each GPIO pin
311
312 static uint8_t gpioToGPLEV [] =
313 {
314   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,
315   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,
316 } ;
317
318
319 #ifdef notYetReady
320 // gpioToEDS
321 //      (Word) offset to the Event Detect Status
322
323 static uint8_t gpioToEDS [] =
324 {
325   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,
326   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,
327 } ;
328
329 // gpioToREN
330 //      (Word) offset to the Rising edgde ENable register
331
332 static uint8_t gpioToREN [] =
333 {
334   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,
335   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,
336 } ;
337
338 // gpioToFEN
339 //      (Word) offset to the Falling edgde ENable register
340
341 static uint8_t gpioToFEN [] =
342 {
343   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,
344   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,
345 } ;
346 #endif
347
348
349 // GPPUD:
350 //      GPIO Pin pull up/down register
351
352 #define GPPUD   37
353
354 // gpioToPUDCLK
355 //      (Word) offset to the Pull Up Down Clock regsiter
356
357 static uint8_t gpioToPUDCLK [] =
358 {
359   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,
360   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,
361 } ;
362
363
364 // gpioToPwmALT
365 //      the ALT value to put a GPIO pin into PWM mode
366
367 static uint8_t gpioToPwmALT [] =
368 {
369           0,         0,         0,         0,         0,         0,         0,         0,       //  0 ->  7
370           0,         0,         0,         0, FSEL_ALT0, FSEL_ALT0,         0,         0,       //  8 -> 15
371           0,         0, FSEL_ALT5, FSEL_ALT5,         0,         0,         0,         0,       // 16 -> 23
372           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
373           0,         0,         0,         0,         0,         0,         0,         0,       // 32 -> 39
374   FSEL_ALT0, FSEL_ALT0,         0,         0,         0, FSEL_ALT0,         0,         0,       // 40 -> 47
375           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
376           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
377 } ;
378
379 // gpioToPwmPort
380 //      The port value to put a GPIO pin into PWM mode
381
382 static uint8_t gpioToPwmPort [] =
383 {
384           0,         0,         0,         0,         0,         0,         0,         0,       //  0 ->  7
385           0,         0,         0,         0, PWM0_DATA, PWM1_DATA,         0,         0,       //  8 -> 15
386           0,         0, PWM0_DATA, PWM1_DATA,         0,         0,         0,         0,       // 16 -> 23
387           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
388           0,         0,         0,         0,         0,         0,         0,         0,       // 32 -> 39
389   PWM0_DATA, PWM1_DATA,         0,         0,         0, PWM1_DATA,         0,         0,       // 40 -> 47
390           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
391           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
392
393 } ;
394
395 // gpioToGpClkALT:
396 //      ALT value to put a GPIO pin into GP Clock mode.
397 //      On the Pi we can really only use BCM_GPIO_4 and BCM_GPIO_21
398 //      for clocks 0 and 1 respectivey, however I'll include the full
399 //      list for completeness - maybe one day...
400
401 #define GPIO_CLOCK_SOURCE       1
402
403 // gpioToGpClkALT0:
404
405 static uint8_t gpioToGpClkALT0 [] =
406 {
407           0,         0,         0,         0, FSEL_ALT0, FSEL_ALT0, FSEL_ALT0,         0,       //  0 ->  7
408           0,         0,         0,         0,         0,         0,         0,         0,       //  8 -> 15
409           0,         0,         0,         0, FSEL_ALT5, FSEL_ALT5,         0,         0,       // 16 -> 23
410           0,         0,         0,         0,         0,         0,         0,         0,       // 24 -> 31
411   FSEL_ALT0,         0, FSEL_ALT0,         0,         0,         0,         0,         0,       // 32 -> 39
412           0,         0, FSEL_ALT0, FSEL_ALT0, FSEL_ALT0,         0,         0,         0,       // 40 -> 47
413           0,         0,         0,         0,         0,         0,         0,         0,       // 48 -> 55
414           0,         0,         0,         0,         0,         0,         0,         0,       // 56 -> 63
415 } ;
416
417 // gpioToClk:
418 //      (word) Offsets to the clock Control and Divisor register
419
420 static uint8_t gpioToClkCon [] =
421 {
422          -1,        -1,        -1,        -1,        28,        30,        32,        -1,       //  0 ->  7
423          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       //  8 -> 15
424          -1,        -1,        -1,        -1,        28,        30,        -1,        -1,       // 16 -> 23
425          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 24 -> 31
426          28,        -1,        28,        -1,        -1,        -1,        -1,        -1,       // 32 -> 39
427          -1,        -1,        28,        30,        28,        -1,        -1,        -1,       // 40 -> 47
428          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 48 -> 55
429          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 56 -> 63
430 } ;
431
432 static uint8_t gpioToClkDiv [] =
433 {
434          -1,        -1,        -1,        -1,        29,        31,        33,        -1,       //  0 ->  7
435          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       //  8 -> 15
436          -1,        -1,        -1,        -1,        29,        31,        -1,        -1,       // 16 -> 23
437          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 24 -> 31
438          29,        -1,        29,        -1,        -1,        -1,        -1,        -1,       // 32 -> 39
439          -1,        -1,        29,        31,        29,        -1,        -1,        -1,       // 40 -> 47
440          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 48 -> 55
441          -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,       // 56 -> 63
442 } ;
443
444
445 /*
446  * Functions
447  *********************************************************************************
448  */
449
450
451 /*
452  * wpiPinToGpio:
453  *      Translate a wiringPi Pin number to native GPIO pin number.
454  *      (We don't use this here, prefering to just do the lookup directly,
455  *      but it's been requested!)
456  *********************************************************************************
457  */
458
459 int wpiPinToGpio (int wpiPin)
460 {
461   return pinToGpio [wpiPin & 63] ;
462 }
463
464
465 /*
466  * piBoardRev:
467  *      Return a number representing the hardware revision of the board.
468  *      Revision is currently 1 or 2. -1 is returned on error.
469  *
470  *      Much confusion here )-:
471  *      Seems there are some boards with 0000 in them (mistake in manufacture)
472  *      and some board with 0005 in them (another mistake in manufacture?)
473  *      So the distinction between boards that I can see is:
474  *      0000 - Error
475  *      0001 - Not used
476  *      0002 - Rev 1
477  *      0003 - Rev 1
478  *      0004 - Rev 2
479  *      0005 - Rev 2 (but error)
480  *      0006 - Rev 2
481  *      000f - Rev 2 + 512MB
482  *
483  *      A small thorn is the olde style overvolting - that will add in
484  *              1000000
485  *
486  *********************************************************************************
487  */
488
489 static void piBoardRevOops (char *why)
490 {
491   fprintf (stderr, "piBoardRev: Unable to determine board revision from /proc/cpuinfo\n") ;
492   fprintf (stderr, " -> %s\n", why) ;
493   fprintf (stderr, " ->  You may want to check:\n") ;
494   fprintf (stderr, " ->  http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
495   exit (EXIT_FAILURE) ;
496 }
497
498 int piBoardRev (void)
499 {
500   FILE *cpuFd ;
501   char line [120] ;
502   char *c, lastChar ;
503   static int  boardRev = -1 ;
504
505 // No point checking twice...
506
507   if (boardRev != -1)
508     return boardRev ;
509
510   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
511     return -1 ;
512
513   while (fgets (line, 120, cpuFd) != NULL)
514     if (strncmp (line, "Revision", 8) == 0)
515       break ;
516
517   fclose (cpuFd) ;
518
519   if (line == NULL)
520     piBoardRevOops ("No \"Revision\" line") ;
521
522   line [strlen (line) - 1] = 0 ; // Chomp LF
523   
524   if (wiringPiDebug)
525     printf ("piboardRev: Revision string: %s\n", line) ;
526
527   for (c = line ; *c ; ++c)
528     if (isdigit (*c))
529       break ;
530
531   if (!isdigit (*c))
532     piBoardRevOops ("No numeric revision string") ;
533
534 // If you have overvolted the Pi, then it appears that the revision
535 //      has 100000 added to it!
536
537   if (wiringPiDebug)
538     if (strlen (c) != 4)
539       printf ("piboardRev: This Pi has/is overvolted!\n") ;
540
541   lastChar = line [strlen (line) - 1] ;
542
543   if (wiringPiDebug)
544     printf ("piboardRev: lastChar is: '%c' (%d, 0x%02X)\n", lastChar, lastChar, lastChar) ;
545
546   /**/ if ((lastChar == '2') || (lastChar == '3'))
547     boardRev = 1 ;
548   else
549     boardRev = 2 ;
550
551   if (wiringPiDebug)
552     printf ("piBoardRev: Returning revision: %d\n", boardRev) ;
553
554   return boardRev ;
555 }
556
557
558
559 /*
560  * getAlt:
561  *      Returns the ALT bits for a given port. Only really of-use
562  *      for the gpio readall command (I think)
563  *********************************************************************************
564  */
565
566 int getAltGpio (int pin)
567 {
568   int fSel, shift, alt ;
569
570   pin &= 63 ;
571
572   fSel    = gpioToGPFSEL [pin] ;
573   shift   = gpioToShift  [pin] ;
574
575   alt = (*(gpio + fSel) >> shift) & 7 ;
576
577   return alt ;
578 }
579
580 int getAltWPi (int pin)
581 {
582   return getAltGpio (pinToGpio [pin & 63]) ;
583 }
584
585 int getAltSys (int pin)
586 {
587   return 0 ;
588 }
589
590
591 /*
592  * pwmControl:
593  *      Allow the user to control some of the PWM functions
594  *********************************************************************************
595  */
596
597 void pwmSetModeWPi (int mode)
598 {
599   if (mode == PWM_MODE_MS)
600     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
601   else
602     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
603 }
604
605 void pwmSetModeSys (int mode)
606 {
607   return ;
608 }
609
610
611 void pwmSetRangeWPi (unsigned int range)
612 {
613   *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
614   *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
615 }
616
617 void pwmSetRangeSys (unsigned int range)
618 {
619   return ;
620 }
621
622 /*
623  * pwmSetClockWPi:
624  *      Set/Change the PWM clock. Originally my code, but changed
625  *      (for the better!) by Chris Hall, <chris@kchall.plus.com>
626  *      after further study of the manual and testing with a 'scope
627  *********************************************************************************
628  */
629
630 void pwmSetClockWPi (int divisor)
631 {
632   uint32_t pwm_control ;
633   divisor &= 4095 ;
634
635   if (wiringPiDebug)
636     printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
637
638   pwm_control = *(pwm + PWM_CONTROL) ;          // preserve PWM_CONTROL
639
640 // We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY
641 // stays high.
642
643   *(pwm + PWM_CONTROL) = 0 ;                    // Stop PWM
644
645 // Stop PWM clock before changing divisor. The delay after this does need to
646 // this big (95uS occasionally fails, 100uS OK), it's almost as though the BUSY
647 // flag is not working properly in balanced mode. Without the delay when DIV is
648 // adjusted the clock sometimes switches to very slow, once slow further DIV
649 // adjustments do nothing and it's difficult to get out of this mode.
650
651   *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;  // Stop PWM Clock
652     delayMicroseconds (110) ;                   // prevents clock going sloooow
653
654   while ((*(clk + PWMCLK_CNTL) & 0x80) != 0)    // Wait for clock to be !BUSY
655     delayMicroseconds (1) ;
656
657   *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12) ;
658
659   *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;  // Start PWM clock
660   *(pwm + PWM_CONTROL) = pwm_control ;          // restore PWM_CONTROL
661
662   if (wiringPiDebug)
663     printf ("Set     to: %d. Now    : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
664 }
665
666 void pwmSetClockSys (int divisor)
667 {
668   return ;
669 }
670
671
672 #ifdef notYetReady
673 /*
674  * pinED01:
675  * pinED10:
676  *      Enables edge-detect mode on a pin - from a 0 to a 1 or 1 to 0
677  *      Pin must already be in input mode with appropriate pull up/downs set.
678  *********************************************************************************
679  */
680
681 void pinEnableED01Pi (int pin)
682 {
683   pin = pinToGpio [pin & 63] ;
684 }
685 #endif
686
687
688
689 /*
690  * digitalWrite:
691  *      Set an output bit
692  *********************************************************************************
693  */
694
695 void digitalWriteWPi (int pin, int value)
696 {
697   pin = pinToGpio [pin & 63] ;
698
699   if (value == LOW)
700     *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
701   else
702     *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
703 }
704
705 void digitalWriteGpio (int pin, int value)
706 {
707   pin &= 63 ;
708
709   if (value == LOW)
710     *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
711   else
712     *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
713 }
714
715 void digitalWriteSys (int pin, int value)
716 {
717   pin &= 63 ;
718
719   if (sysFds [pin] != -1)
720   {
721     if (value == LOW)
722       write (sysFds [pin], "0\n", 2) ;
723     else
724       write (sysFds [pin], "1\n", 2) ;
725   }
726 }
727
728
729 /*
730  * digitalWriteByte:
731  *      Write an 8-bit byte to the first 8 GPIO pins - try to do it as
732  *      fast as possible.
733  *      However it still needs 2 operations to set the bits, so any external
734  *      hardware must not rely on seeing a change as there will be a change 
735  *      to set the outputs bits to zero, then another change to set the 1's
736  *********************************************************************************
737  */
738
739 void digitalWriteByteGpio (int value)
740 {
741   uint32_t pinSet = 0 ;
742   uint32_t pinClr = 0 ;
743   int mask = 1 ;
744   int pin ;
745
746   for (pin = 0 ; pin < 8 ; ++pin)
747   {
748     if ((value & mask) == 0)
749       pinClr |= (1 << pinToGpio [pin]) ;
750     else
751       pinSet |= (1 << pinToGpio [pin]) ;
752
753     mask <<= 1 ;
754   }
755
756   *(gpio + gpioToGPCLR [0]) = pinClr ;
757   *(gpio + gpioToGPSET [0]) = pinSet ;
758 }
759
760 void digitalWriteByteSys (int value)
761 {
762   int mask = 1 ;
763   int pin ;
764
765   for (pin = 0 ; pin < 8 ; ++pin)
766   {
767     digitalWriteSys (pinToGpio [pin], value & mask) ;
768     mask <<= 1 ;
769   }
770 }
771
772
773 /*
774  * pwmWrite:
775  *      Set an output PWM value
776  *********************************************************************************
777  */
778
779 void pwmWriteGpio (int pin, int value)
780 {
781   int port ;
782
783   pin  = pin & 63 ;
784   port = gpioToPwmPort [pin] ;
785
786   *(pwm + port) = value ;
787 }
788
789 void pwmWriteWPi (int pin, int value)
790 {
791   pwmWriteGpio (pinToGpio [pin & 63], value) ;
792 }
793
794 void pwmWriteSys (int pin, int value)
795 {
796   return ;
797 }
798
799
800 /*
801  * gpioClockSet:
802  *      Set the freuency on a GPIO clock pin
803  *********************************************************************************
804  */
805
806 void gpioClockSetGpio (int pin, int freq)
807 {
808   int divi, divr, divf ;
809
810   pin &= 63 ;
811   
812   divi = 19200000 / freq ;
813   divr = 19200000 % freq ;
814   divf = (int)((double)divr * 4096.0 / 19200000.0) ;
815
816   if (divi > 4095)
817     divi = 4095 ;
818
819   *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | GPIO_CLOCK_SOURCE ;              // Stop GPIO Clock
820   while ((*(clk + gpioToClkCon [pin]) & 0x80) != 0)                             // ... and wait
821     ;
822
823   *(clk + gpioToClkDiv [pin]) = BCM_PASSWORD | (divi << 12) | divf ;            // Set dividers
824   *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | 0x10 | GPIO_CLOCK_SOURCE ;       // Start Clock
825 }
826
827 void gpioClockSetWPi (int pin, int freq)
828 {
829   gpioClockSetGpio (pinToGpio [pin & 63], freq) ;
830 }
831
832 void gpioClockSetSys (int pin, int freq)
833 {
834   return ;
835 }
836
837
838 /*
839  * setPadDrive:
840  *      Set the PAD driver value
841  *********************************************************************************
842  */
843
844 void setPadDriveWPi (int group, int value)
845 {
846   uint32_t wrVal ;
847
848   if ((group < 0) || (group > 2))
849     return ;
850
851   wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
852   *(pads + group + 11) = wrVal ;
853
854   if (wiringPiDebug)
855   {
856     printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
857     printf ("Read : %08X\n", *(pads + group + 11)) ;
858   }
859 }
860
861 void setPadDriveGpio (int group, int value)
862 {
863   setPadDriveWPi (group, value) ;
864 }
865
866 void setPadDriveSys (int group, int value)
867 {
868   return ;
869 }
870
871
872 /*
873  * digitalRead:
874  *      Read the value of a given Pin, returning HIGH or LOW
875  *********************************************************************************
876  */
877
878 int digitalReadWPi (int pin)
879 {
880   pin = pinToGpio [pin & 63] ;
881
882   if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
883     return HIGH ;
884   else
885     return LOW ;
886 }
887
888 int digitalReadGpio (int pin)
889 {
890   pin &= 63 ;
891
892   if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
893     return HIGH ;
894   else
895     return LOW ;
896 }
897
898 int digitalReadSys (int pin)
899 {
900   char c ;
901
902   pin &= 63 ;
903
904   if (sysFds [pin] == -1)
905     return 0 ;
906
907   lseek (sysFds [pin], 0L, SEEK_SET) ;
908   read  (sysFds [pin], &c, 1) ;
909   return (c == '0') ? 0 : 1 ;
910 }
911
912
913 /*
914  * pullUpDownCtrl:
915  *      Control the internal pull-up/down resistors on a GPIO pin
916  *      The Arduino only has pull-ups and these are enabled by writing 1
917  *      to a port when in input mode - this paradigm doesn't quite apply
918  *      here though.
919  *********************************************************************************
920  */
921
922 void pullUpDnControlGpio (int pin, int pud)
923 {
924   pin &= 63 ;
925   pud &=  3 ;
926
927   *(gpio + GPPUD)              = pud ;                  delayMicroseconds (5) ;
928   *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ;      delayMicroseconds (5) ;
929   
930   *(gpio + GPPUD)              = 0 ;                    delayMicroseconds (5) ;
931   *(gpio + gpioToPUDCLK [pin]) = 0 ;                    delayMicroseconds (5) ;
932 }
933
934 void pullUpDnControlWPi (int pin, int pud)
935 {
936   pullUpDnControlGpio (pinToGpio [pin & 63], pud) ;
937 }
938
939 void pullUpDnControlSys (int pin, int pud)
940 {
941   return ;
942 }
943
944
945 /*
946  * pinMode:
947  *      Sets the mode of a pin to be input, output or PWM output
948  *********************************************************************************
949  */
950
951 void pinModeGpio (int pin, int mode)
952 {
953 //  register int barrier ;
954
955   int fSel, shift, alt ;
956
957   pin &= 63 ;
958
959   fSel    = gpioToGPFSEL [pin] ;
960   shift   = gpioToShift  [pin] ;
961
962   /**/ if (mode == INPUT)
963     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
964   else if (mode == OUTPUT)
965     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
966   else if (mode == PWM_OUTPUT)
967   {
968     if ((alt = gpioToPwmALT [pin]) == 0)        // Not a PWM pin
969       return ;
970
971 // Set pin to PWM mode
972
973     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
974     delayMicroseconds (110) ;           // See comments in pwmSetClockWPi
975
976     pwmSetModeWPi  (PWM_MODE_BAL) ;     // Pi default mode
977     pwmSetRangeWPi (1024) ;             // Default range of 1024
978     pwmSetClockWPi (32) ;               // 19.2 / 32 = 600KHz - Also starts the PWM
979   }
980   else if (mode == GPIO_CLOCK)
981   {
982     if ((alt = gpioToGpClkALT0 [pin]) == 0)     // Not a GPIO_CLOCK pin
983       return ;
984
985 // Set pin to GPIO_CLOCK mode and set the clock frequency to 100KHz
986
987     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
988     delayMicroseconds (110) ;
989     gpioClockSetGpio (pin, 100000) ;
990   }
991 }
992
993 void pinModeWPi (int pin, int mode)
994 {
995   pinModeGpio (pinToGpio [pin & 63], mode) ;
996 }
997
998 void pinModeSys (int pin, int mode)
999 {
1000   return ;
1001 }
1002
1003
1004 /*
1005  * waitForInterrupt:
1006  *      Wait for Interrupt on a GPIO pin.
1007  *      This is actually done via the /sys/class/gpio interface regardless of
1008  *      the wiringPi access mode in-use. Maybe sometime it might get a better
1009  *      way for a bit more efficiency.
1010  *********************************************************************************
1011  */
1012
1013 int waitForInterruptSys (int pin, int mS)
1014 {
1015   int fd, x ;
1016   uint8_t c ;
1017   struct pollfd polls ;
1018
1019   if ((fd = sysFds [pin & 63]) == -1)
1020     return -2 ;
1021
1022 // Setup poll structure
1023
1024   polls.fd     = fd ;
1025   polls.events = POLLPRI ;      // Urgent data!
1026
1027 // Wait for it ...
1028
1029   x = poll (&polls, 1, mS) ;
1030
1031 // Do a dummy read to clear the interrupt
1032 //      A one character read appars to be enough.
1033
1034   (void)read (fd, &c, 1) ;
1035
1036   return x ;
1037 }
1038
1039 int waitForInterruptWPi (int pin, int mS)
1040 {
1041   return waitForInterruptSys (pinToGpio [pin & 63], mS) ;
1042 }
1043
1044 int waitForInterruptGpio (int pin, int mS)
1045 {
1046   return waitForInterruptSys (pin, mS) ;
1047 }
1048
1049
1050 /*
1051  * interruptHandler:
1052  *      This is a thread and gets started to wait for the interrupt we're
1053  *      hoping to catch. It will call the user-function when the interrupt
1054  *      fires.
1055  *********************************************************************************
1056  */
1057
1058 static void *interruptHandler (void *arg)
1059 {
1060   int myPin = *(int *)arg ;
1061
1062   (void)piHiPri (55) ;  // Only effective if we run as root
1063
1064   for (;;)
1065     if (waitForInterruptSys (myPin, -1) > 0)
1066       isrFunctions [myPin] () ;
1067
1068   return NULL ;
1069 }
1070
1071
1072 /*
1073  * wiringPiISR:
1074  *      Take the details and create an interrupt handler that will do a call-
1075  *      back to the user supplied function.
1076  *********************************************************************************
1077  */
1078
1079 int wiringPiISR (int pin, int mode, void (*function)(void))
1080 {
1081   pthread_t threadId ;
1082   char fName   [64] ;
1083   char *modeS ;
1084   char  pinS [8] ;
1085   pid_t pid ;
1086   int   count, i ;
1087   uint8_t c ;
1088
1089   pin &= 63 ;
1090
1091   if (wiringPiMode == WPI_MODE_UNINITIALISED)
1092   {
1093     fprintf (stderr, "wiringPiISR: wiringPi has not been initialised. Unable to continue.\n") ;
1094     exit (EXIT_FAILURE) ;
1095   }
1096   else if (wiringPiMode == WPI_MODE_PINS)
1097     pin = pinToGpio [pin] ;
1098
1099 // Now export the pin and set the right edge
1100 //      We're going to use the gpio program to do this, so it assumes
1101 //      a full installation of wiringPi. It's a bit 'clunky', but it
1102 //      is a way that will work when we're running in "Sys" mode, as
1103 //      a non-root user. (without sudo)
1104
1105   if (mode != INT_EDGE_SETUP)
1106   {
1107     /**/ if (mode == INT_EDGE_FALLING)
1108       modeS = "falling" ;
1109     else if (mode == INT_EDGE_RISING)
1110       modeS = "rising" ;
1111     else
1112       modeS = "both" ;
1113
1114     sprintf (pinS, "%d", pin) ;
1115
1116     if ((pid = fork ()) < 0)    // Fail
1117       return pid ;
1118
1119     if (pid == 0)       // Child, exec
1120     {
1121       execl ("/usr/local/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
1122       return -1 ;       // Failure ...
1123     }
1124     else                // Parent, wait
1125       wait (NULL) ;
1126   }
1127
1128 // Now pre-open the /sys/class node - it may already be open if
1129 //      we are in Sys mode, but this will do no harm.
1130
1131   sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1132   if ((sysFds [pin] = open (fName, O_RDWR)) < 0)
1133     return -1 ;
1134
1135 // Clear any initial pending interrupt
1136
1137   ioctl (sysFds [pin], FIONREAD, &count) ;
1138   for (i = 0 ; i < count ; ++i)
1139     read (sysFds [pin], &c, 1) ;
1140
1141   isrFunctions [pin] = function ;
1142
1143   pthread_create (&threadId, NULL, interruptHandler, &pin) ;
1144
1145   delay (1) ;
1146
1147   return 0 ;
1148 }
1149
1150
1151 /*
1152  * initialiseEpoch:
1153  *      Initialise our start-of-time variable to be the current unix
1154  *      time in milliseconds.
1155  *********************************************************************************
1156  */
1157
1158 static void initialiseEpoch (void)
1159 {
1160   struct timeval tv ;
1161
1162   gettimeofday (&tv, NULL) ;
1163   epochMilli = (uint64_t)tv.tv_sec * (uint64_t)1000    + (uint64_t)(tv.tv_usec / 1000) ;
1164   epochMicro = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)(tv.tv_usec) ;
1165 }
1166
1167 /*
1168  * delay:
1169  *      Wait for some number of milli seconds
1170  *********************************************************************************
1171  */
1172
1173 void delay (unsigned int howLong)
1174 {
1175   struct timespec sleeper, dummy ;
1176
1177   sleeper.tv_sec  = (time_t)(howLong / 1000) ;
1178   sleeper.tv_nsec = (long)(howLong % 1000) * 1000000 ;
1179
1180   nanosleep (&sleeper, &dummy) ;
1181 }
1182
1183
1184 /*
1185  * delayMicroseconds:
1186  *      This is somewhat intersting. It seems that on the Pi, a single call
1187  *      to nanosleep takes some 80 to 130 microseconds anyway, so while
1188  *      obeying the standards (may take longer), it's not always what we
1189  *      want!
1190  *
1191  *      So what I'll do now is if the delay is less than 100uS we'll do it
1192  *      in a hard loop, watching a built-in counter on the ARM chip. This is
1193  *      somewhat sub-optimal in that it uses 100% CPU, something not an issue
1194  *      in a microcontroller, but under a multi-tasking, multi-user OS, it's
1195  *      wastefull, however we've no real choice )-:
1196  *
1197  *      Plan B: It seems all might not be well with that plan, so changing it
1198  *      to use gettimeofday () and poll on that instead...
1199  *********************************************************************************
1200  */
1201
1202 void delayMicrosecondsHard (unsigned int howLong)
1203 {
1204   struct timeval tNow, tLong, tEnd ;
1205
1206   gettimeofday (&tNow, NULL) ;
1207   tLong.tv_sec  = howLong / 1000000 ;
1208   tLong.tv_usec = howLong % 1000000 ;
1209   timeradd (&tNow, &tLong, &tEnd) ;
1210
1211   while (timercmp (&tNow, &tEnd, <))
1212     gettimeofday (&tNow, NULL) ;
1213 }
1214
1215 void delayMicroseconds (unsigned int howLong)
1216 {
1217   struct timespec sleeper ;
1218
1219   /**/ if (howLong ==   0)
1220     return ;
1221   else if (howLong  < 100)
1222     delayMicrosecondsHard (howLong) ;
1223   else
1224   {
1225     sleeper.tv_sec  = 0 ;
1226     sleeper.tv_nsec = (long)(howLong * 1000) ;
1227     nanosleep (&sleeper, NULL) ;
1228   }
1229 }
1230
1231
1232 /*
1233  * millis:
1234  *      Return a number of milliseconds as an unsigned int.
1235  *********************************************************************************
1236  */
1237
1238 unsigned int millis (void)
1239 {
1240   struct timeval tv ;
1241   uint64_t now ;
1242
1243   gettimeofday (&tv, NULL) ;
1244   now  = (uint64_t)tv.tv_sec * (uint64_t)1000 + (uint64_t)(tv.tv_usec / 1000) ;
1245
1246   return (uint32_t)(now - epochMilli) ;
1247 }
1248
1249
1250 /*
1251  * micros:
1252  *      Return a number of microseconds as an unsigned int.
1253  *********************************************************************************
1254  */
1255
1256 unsigned int micros (void)
1257 {
1258   struct timeval tv ;
1259   uint64_t now ;
1260
1261   gettimeofday (&tv, NULL) ;
1262   now  = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)tv.tv_usec ;
1263
1264   return (uint32_t)(now - epochMicro) ;
1265 }
1266
1267
1268 /*
1269  * wiringPiSetup:
1270  *      Must be called once at the start of your program execution.
1271  *
1272  * Default setup: Initialises the system into wiringPi Pin mode and uses the
1273  *      memory mapped hardware directly.
1274  *********************************************************************************
1275  */
1276
1277 int wiringPiSetup (void)
1278 {
1279   int      fd ;
1280   int      boardRev ;
1281
1282   if (geteuid () != 0)
1283   {
1284     fprintf (stderr, "wiringPi:\n  Must be root to call wiringPiSetup().\n  (Did you forget sudo?)\n") ;
1285     exit (EXIT_FAILURE) ;
1286   }
1287
1288   if (getenv ("WIRINGPI_DEBUG") != NULL)
1289   {
1290     printf ("wiringPi: Debug mode enabled\n") ;
1291     wiringPiDebug = TRUE ;
1292   }
1293
1294   if (wiringPiDebug)
1295     printf ("wiringPi: wiringPiSetup called\n") ;
1296
1297             pinMode =           pinModeWPi ;
1298              getAlt =            getAltWPi ;
1299     pullUpDnControl =   pullUpDnControlWPi ;
1300        digitalWrite =      digitalWriteWPi ;
1301    digitalWriteByte = digitalWriteByteGpio ;    // Same code
1302        gpioClockSet =      gpioClockSetWPi ;
1303            pwmWrite =          pwmWriteWPi ;
1304         setPadDrive =       setPadDriveWPi ;
1305         digitalRead =       digitalReadWPi ;
1306    waitForInterrupt =  waitForInterruptWPi ;
1307          pwmSetMode =        pwmSetModeWPi ;
1308         pwmSetRange =       pwmSetRangeWPi ;
1309         pwmSetClock =       pwmSetClockWPi ;
1310   
1311   boardRev = piBoardRev () ;
1312
1313   if (boardRev == 1)
1314     pinToGpio = pinToGpioR1 ;
1315   else
1316     pinToGpio = pinToGpioR2 ;
1317
1318 // Open the master /dev/memory device
1319
1320   if ((fd = open ("/dev/mem", O_RDWR | O_SYNC) ) < 0)
1321   {
1322     if (wiringPiDebug)
1323     {
1324       int serr = errno ;
1325         fprintf (stderr, "wiringPiSetup: Unable to open /dev/mem: %s\n", strerror (errno)) ;
1326       errno = serr ;
1327     }
1328     return -1 ;
1329   }
1330
1331 // GPIO:
1332
1333   gpio = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_BASE) ;
1334   if ((int32_t)gpio == -1)
1335   {
1336     if (wiringPiDebug)
1337     {
1338       int serr = errno ;
1339         fprintf (stderr, "wiringPiSetup: mmap failed: %s\n", strerror (errno)) ;
1340       errno = serr ;
1341     }
1342     return -1 ;
1343   }
1344
1345 // PWM
1346
1347   pwm = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PWM) ;
1348   if ((int32_t)pwm == -1)
1349   {
1350     if (wiringPiDebug)
1351     {
1352       int serr = errno ;
1353         fprintf (stderr, "wiringPiSetup: mmap failed (pwm): %s\n", strerror (errno)) ;
1354       errno = serr ;
1355     }
1356     return -1 ;
1357   }
1358  
1359 // Clock control (needed for PWM)
1360
1361   clk = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, CLOCK_BASE) ;
1362   if ((int32_t)clk == -1)
1363   {
1364     if (wiringPiDebug)
1365     {
1366       int serr = errno ;
1367         fprintf (stderr, "wiringPiSetup: mmap failed (clk): %s\n", strerror (errno)) ;
1368       errno = serr ;
1369     }
1370     return -1 ;
1371   }
1372  
1373 // The drive pads
1374
1375   pads = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PADS) ;
1376   if ((int32_t)pads == -1)
1377   {
1378     if (wiringPiDebug)
1379     {
1380       int serr = errno ;
1381         fprintf (stderr, "wiringPiSetup: mmap failed (pads): %s\n", strerror (errno)) ;
1382       errno = serr ;
1383     }
1384     return -1 ;
1385   }
1386
1387 // The system timer
1388
1389   timer = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_TIMER) ;
1390   if ((int32_t)timer == -1)
1391   {
1392     if (wiringPiDebug)
1393     {
1394       int serr = errno ;
1395         fprintf (stderr, "wiringPiSetup: mmap failed (timer): %s\n", strerror (errno)) ;
1396       errno = serr ;
1397     }
1398     return -1 ;
1399   }
1400
1401 // Set the timer to free-running, 1MHz.
1402 //      0xF9 is 249, the timer divide is base clock / (divide+1)
1403 //      so base clock is 250MHz / 250 = 1MHz.
1404
1405   *(timer + TIMER_CONTROL) = 0x0000280 ;
1406   *(timer + TIMER_PRE_DIV) = 0x00000F9 ;
1407   timerIrqRaw = timer + TIMER_IRQ_RAW ;
1408
1409   initialiseEpoch () ;
1410
1411   wiringPiMode = WPI_MODE_PINS ;
1412
1413   return 0 ;
1414 }
1415
1416
1417 /*
1418  * wiringPiSetupGpio:
1419  *      Must be called once at the start of your program execution.
1420  *
1421  * GPIO setup: Initialises the system into GPIO Pin mode and uses the
1422  *      memory mapped hardware directly.
1423  *********************************************************************************
1424  */
1425
1426 int wiringPiSetupGpio (void)
1427 {
1428   int x  ;
1429
1430   if (geteuid () != 0)
1431   {
1432     fprintf (stderr, "Must be root to call wiringPiSetupGpio(). (Did you forget sudo?)\n") ;
1433     exit (EXIT_FAILURE) ;
1434   }
1435
1436   if ((x = wiringPiSetup ()) < 0)
1437     return x ;
1438
1439   if (wiringPiDebug)
1440     printf ("wiringPi: wiringPiSetupGpio called\n") ;
1441
1442             pinMode =           pinModeGpio ;
1443              getAlt =            getAltGpio ;
1444     pullUpDnControl =   pullUpDnControlGpio ;
1445        digitalWrite =      digitalWriteGpio ;
1446    digitalWriteByte =  digitalWriteByteGpio ;
1447        gpioClockSet =      gpioClockSetGpio ;
1448            pwmWrite =          pwmWriteGpio ;
1449         setPadDrive =       setPadDriveGpio ;
1450         digitalRead =       digitalReadGpio ;
1451    waitForInterrupt =  waitForInterruptGpio ;
1452          pwmSetMode =        pwmSetModeWPi ;
1453         pwmSetRange =       pwmSetRangeWPi ;
1454         pwmSetClock =       pwmSetClockWPi ;
1455
1456   wiringPiMode = WPI_MODE_GPIO ;
1457
1458   return 0 ;
1459 }
1460
1461
1462 /*
1463  * wiringPiSetupSys:
1464  *      Must be called once at the start of your program execution.
1465  *
1466  * Initialisation (again), however this time we are using the /sys/class/gpio
1467  *      interface to the GPIO systems - slightly slower, but always usable as
1468  *      a non-root user, assuming the devices are already exported and setup correctly.
1469  */
1470
1471 int wiringPiSetupSys (void)
1472 {
1473   int boardRev ;
1474   int pin ;
1475   char fName [128] ;
1476
1477   if (getenv ("WIRINGPI_DEBUG") != NULL)
1478     wiringPiDebug = TRUE ;
1479
1480   if (wiringPiDebug)
1481     printf ("wiringPi: wiringPiSetupSys called\n") ;
1482
1483             pinMode =           pinModeSys ;
1484              getAlt =            getAltSys ;
1485     pullUpDnControl =   pullUpDnControlSys ;
1486        digitalWrite =      digitalWriteSys ;
1487    digitalWriteByte =  digitalWriteByteSys ;
1488        gpioClockSet =      gpioClockSetSys ;
1489            pwmWrite =          pwmWriteSys ;
1490         setPadDrive =       setPadDriveSys ;
1491         digitalRead =       digitalReadSys ;
1492    waitForInterrupt =  waitForInterruptSys ;
1493          pwmSetMode =        pwmSetModeSys ;
1494         pwmSetRange =       pwmSetRangeSys ;
1495         pwmSetClock =       pwmSetClockSys ;
1496
1497   boardRev = piBoardRev () ;
1498
1499   if (boardRev == 1)
1500     pinToGpio = pinToGpioR1 ;
1501   else
1502     pinToGpio = pinToGpioR2 ;
1503
1504 // Open and scan the directory, looking for exported GPIOs, and pre-open
1505 //      the 'value' interface to speed things up for later
1506   
1507   for (pin = 0 ; pin < 64 ; ++pin)
1508   {
1509     sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1510     sysFds [pin] = open (fName, O_RDWR) ;
1511   }
1512
1513   initialiseEpoch () ;
1514
1515   wiringPiMode = WPI_MODE_GPIO_SYS ;
1516
1517   return 0 ;
1518 }