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 (Early reports?
 479  *      0005 - Rev 2 (but error?)
 480  *      0006 - Rev 2
 481  *      0008 - Rev 2 - Model A
 482  *      000e - Rev 2 + 512MB
 483  *      000f - Rev 2 + 512MB
 484  *
 485  *      A small thorn is the olde style overvolting - that will add in
 486  *              1000000
 487  *
 488  *********************************************************************************
 489  */
 490
 491 static void piBoardRevOops (char *why)
 492 {
 493   fprintf (stderr, "piBoardRev: Unable to determine board revision from /proc/cpuinfo\n") ;
 494   fprintf (stderr, " -> %s\n", why) ;
 495   fprintf (stderr, " ->  You may want to check:\n") ;
 496   fprintf (stderr, " ->  http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
 497   exit (EXIT_FAILURE) ;
 498 }
 499
 500 int piBoardRev (void)
 501 {
 502   FILE *cpuFd ;
 503   char line [120] ;
 504   char *c, lastChar ;
 505   static int  boardRev = -1 ;
 506
 507   if (boardRev != -1)   // No point checking twice
 508     return boardRev ;
 509
 510   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
 511     piBoardRevOops ("Unable to open /proc/cpuinfo") ;
 512
 513   while (fgets (line, 120, cpuFd) != NULL)
 514     if (strncmp (line, "Revision", 8) == 0)
 515       break ;
 516
 517   fclose (cpuFd) ;
 518
 519   if (strncmp (line, "Revision", 8) != 0)
 520     piBoardRevOops ("No \"Revision\" line") ;
 521
 522   for (c = &line [strlen (line) - 1] ; (*c == '\n') || (*c == '\r') ; --c)
 523     *c = 0 ;
 524
 525   if (wiringPiDebug)
 526     printf ("piboardRev: Revision string: %s\n", line) ;
 527
 528   for (c = line ; *c ; ++c)
 529     if (isdigit (*c))
 530       break ;
 531
 532   if (!isdigit (*c))
 533     piBoardRevOops ("No numeric revision string") ;
 534
 535 // If you have overvolted the Pi, then it appears that the revision
 536 //      has 100000 added to it!
 537
 538   if (wiringPiDebug)
 539     if (strlen (c) != 4)
 540       printf ("piboardRev: This Pi has/is overvolted!\n") ;
 541
 542   lastChar = line [strlen (line) - 1] ;
 543
 544   if (wiringPiDebug)
 545     printf ("piboardRev: lastChar is: '%c' (%d, 0x%02X)\n", lastChar, lastChar, lastChar) ;
 546
 547   /**/ if ((lastChar == '2') || (lastChar == '3'))
 548     boardRev = 1 ;
 549   else
 550     boardRev = 2 ;
 551
 552   if (wiringPiDebug)
 553     printf ("piBoardRev: Returning revision: %d\n", boardRev) ;
 554
 555   return boardRev ;
 556 }
 557
 558
 559
 560 /*
 561  * getAlt:
 562  *      Returns the ALT bits for a given port. Only really of-use
 563  *      for the gpio readall command (I think)
 564  *********************************************************************************
 565  */
 566
 567 int getAltGpio (int pin)
 568 {
 569   int fSel, shift, alt ;
 570
 571   pin &= 63 ;
 572
 573   fSel    = gpioToGPFSEL [pin] ;
 574   shift   = gpioToShift  [pin] ;
 575
 576   alt = (*(gpio + fSel) >> shift) & 7 ;
 577
 578   return alt ;
 579 }
 580
 581 int getAltWPi (int pin)
 582 {
 583   return getAltGpio (pinToGpio [pin & 63]) ;
 584 }
 585
 586 int getAltSys (int pin)
 587 {
 588   return 0 ;
 589 }
 590
 591
 592 /*
 593  * pwmControl:
 594  *      Allow the user to control some of the PWM functions
 595  *********************************************************************************
 596  */
 597
 598 void pwmSetModeWPi (int mode)
 599 {
 600   if (mode == PWM_MODE_MS)
 601     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
 602   else
 603     *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
 604 }
 605
 606 void pwmSetModeSys (int mode)
 607 {
 608   return ;
 609 }
 610
 611
 612 void pwmSetRangeWPi (unsigned int range)
 613 {
 614   *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
 615   *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
 616 }
 617
 618 void pwmSetRangeSys (unsigned int range)
 619 {
 620   return ;
 621 }
 622
 623 /*
 624  * pwmSetClockWPi:
 625  *      Set/Change the PWM clock. Originally my code, but changed
 626  *      (for the better!) by Chris Hall, <chris@kchall.plus.com>
 627  *      after further study of the manual and testing with a 'scope
 628  *********************************************************************************
 629  */
 630
 631 void pwmSetClockWPi (int divisor)
 632 {
 633   uint32_t pwm_control ;
 634   divisor &= 4095 ;
 635
 636   if (wiringPiDebug)
 637     printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
 638
 639   pwm_control = *(pwm + PWM_CONTROL) ;          // preserve PWM_CONTROL
 640
 641 // We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY
 642 // stays high.
 643
 644   *(pwm + PWM_CONTROL) = 0 ;                    // Stop PWM
 645
 646 // Stop PWM clock before changing divisor. The delay after this does need to
 647 // this big (95uS occasionally fails, 100uS OK), it's almost as though the BUSY
 648 // flag is not working properly in balanced mode. Without the delay when DIV is
 649 // adjusted the clock sometimes switches to very slow, once slow further DIV
 650 // adjustments do nothing and it's difficult to get out of this mode.
 651
 652   *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;  // Stop PWM Clock
 653     delayMicroseconds (110) ;                   // prevents clock going sloooow
 654
 655   while ((*(clk + PWMCLK_CNTL) & 0x80) != 0)    // Wait for clock to be !BUSY
 656     delayMicroseconds (1) ;
 657
 658   *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12) ;
 659
 660   *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;  // Start PWM clock
 661   *(pwm + PWM_CONTROL) = pwm_control ;          // restore PWM_CONTROL
 662
 663   if (wiringPiDebug)
 664     printf ("Set     to: %d. Now    : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
 665 }
 666
 667 void pwmSetClockSys (int divisor)
 668 {
 669   return ;
 670 }
 671
 672
 673 #ifdef notYetReady
 674 /*
 675  * pinED01:
 676  * pinED10:
 677  *      Enables edge-detect mode on a pin - from a 0 to a 1 or 1 to 0
 678  *      Pin must already be in input mode with appropriate pull up/downs set.
 679  *********************************************************************************
 680  */
 681
 682 void pinEnableED01Pi (int pin)
 683 {
 684   pin = pinToGpio [pin & 63] ;
 685 }
 686 #endif
 687
 688
 689
 690 /*
 691  * digitalWrite:
 692  *      Set an output bit
 693  *********************************************************************************
 694  */
 695
 696 void digitalWriteWPi (int pin, int value)
 697 {
 698   pin = pinToGpio [pin & 63] ;
 699
 700   if (value == LOW)
 701     *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
 702   else
 703     *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
 704 }
 705
 706 void digitalWriteGpio (int pin, int value)
 707 {
 708   pin &= 63 ;
 709
 710   if (value == LOW)
 711     *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
 712   else
 713     *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
 714 }
 715
 716 void digitalWriteSys (int pin, int value)
 717 {
 718   pin &= 63 ;
 719
 720   if (sysFds [pin] != -1)
 721   {
 722     if (value == LOW)
 723       write (sysFds [pin], "0\n", 2) ;
 724     else
 725       write (sysFds [pin], "1\n", 2) ;
 726   }
 727 }
 728
 729
 730 /*
 731  * digitalWriteByte:
 732  *      Write an 8-bit byte to the first 8 GPIO pins - try to do it as
 733  *      fast as possible.
 734  *      However it still needs 2 operations to set the bits, so any external
 735  *      hardware must not rely on seeing a change as there will be a change
 736  *      to set the outputs bits to zero, then another change to set the 1's
 737  *********************************************************************************
 738  */
 739
 740 void digitalWriteByteGpio (int value)
 741 {
 742   uint32_t pinSet = 0 ;
 743   uint32_t pinClr = 0 ;
 744   int mask = 1 ;
 745   int pin ;
 746
 747   for (pin = 0 ; pin < 8 ; ++pin)
 748   {
 749     if ((value & mask) == 0)
 750       pinClr |= (1 << pinToGpio [pin]) ;
 751     else
 752       pinSet |= (1 << pinToGpio [pin]) ;
 753
 754     mask <<= 1 ;
 755   }
 756
 757   *(gpio + gpioToGPCLR [0]) = pinClr ;
 758   *(gpio + gpioToGPSET [0]) = pinSet ;
 759 }
 760
 761 void digitalWriteByteSys (int value)
 762 {
 763   int mask = 1 ;
 764   int pin ;
 765
 766   for (pin = 0 ; pin < 8 ; ++pin)
 767   {
 768     digitalWriteSys (pinToGpio [pin], value & mask) ;
 769     mask <<= 1 ;
 770   }
 771 }
 772
 773
 774 /*
 775  * pwmWrite:
 776  *      Set an output PWM value
 777  *********************************************************************************
 778  */
 779
 780 void pwmWriteGpio (int pin, int value)
 781 {
 782   int port ;
 783
 784   pin  = pin & 63 ;
 785   port = gpioToPwmPort [pin] ;
 786
 787   *(pwm + port) = value ;
 788 }
 789
 790 void pwmWriteWPi (int pin, int value)
 791 {
 792   pwmWriteGpio (pinToGpio [pin & 63], value) ;
 793 }
 794
 795 void pwmWriteSys (int pin, int value)
 796 {
 797   return ;
 798 }
 799
 800
 801 /*
 802  * gpioClockSet:
 803  *      Set the freuency on a GPIO clock pin
 804  *********************************************************************************
 805  */
 806
 807 void gpioClockSetGpio (int pin, int freq)
 808 {
 809   int divi, divr, divf ;
 810
 811   pin &= 63 ;
 812
 813   divi = 19200000 / freq ;
 814   divr = 19200000 % freq ;
 815   divf = (int)((double)divr * 4096.0 / 19200000.0) ;
 816
 817   if (divi > 4095)
 818     divi = 4095 ;
 819
 820   *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | GPIO_CLOCK_SOURCE ;              // Stop GPIO Clock
 821   while ((*(clk + gpioToClkCon [pin]) & 0x80) != 0)                             // ... and wait
 822     ;
 823
 824   *(clk + gpioToClkDiv [pin]) = BCM_PASSWORD | (divi << 12) | divf ;            // Set dividers
 825   *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | 0x10 | GPIO_CLOCK_SOURCE ;       // Start Clock
 826 }
 827
 828 void gpioClockSetWPi (int pin, int freq)
 829 {
 830   gpioClockSetGpio (pinToGpio [pin & 63], freq) ;
 831 }
 832
 833 void gpioClockSetSys (int pin, int freq)
 834 {
 835   return ;
 836 }
 837
 838
 839 /*
 840  * setPadDrive:
 841  *      Set the PAD driver value
 842  *********************************************************************************
 843  */
 844
 845 void setPadDriveWPi (int group, int value)
 846 {
 847   uint32_t wrVal ;
 848
 849   if ((group < 0) || (group > 2))
 850     return ;
 851
 852   wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
 853   *(pads + group + 11) = wrVal ;
 854
 855   if (wiringPiDebug)
 856   {
 857     printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
 858     printf ("Read : %08X\n", *(pads + group + 11)) ;
 859   }
 860 }
 861
 862 void setPadDriveGpio (int group, int value)
 863 {
 864   setPadDriveWPi (group, value) ;
 865 }
 866
 867 void setPadDriveSys (int group, int value)
 868 {
 869   return ;
 870 }
 871
 872
 873 /*
 874  * digitalRead:
 875  *      Read the value of a given Pin, returning HIGH or LOW
 876  *********************************************************************************
 877  */
 878
 879 int digitalReadWPi (int pin)
 880 {
 881   pin = pinToGpio [pin & 63] ;
 882
 883   if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
 884     return HIGH ;
 885   else
 886     return LOW ;
 887 }
 888
 889 int digitalReadGpio (int pin)
 890 {
 891   pin &= 63 ;
 892
 893   if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
 894     return HIGH ;
 895   else
 896     return LOW ;
 897 }
 898
 899 int digitalReadSys (int pin)
 900 {
 901   char c ;
 902
 903   pin &= 63 ;
 904
 905   if (sysFds [pin] == -1)
 906     return 0 ;
 907
 908   lseek (sysFds [pin], 0L, SEEK_SET) ;
 909   read  (sysFds [pin], &c, 1) ;
 910   return (c == '0') ? 0 : 1 ;
 911 }
 912
 913
 914 /*
 915  * pullUpDownCtrl:
 916  *      Control the internal pull-up/down resistors on a GPIO pin
 917  *      The Arduino only has pull-ups and these are enabled by writing 1
 918  *      to a port when in input mode - this paradigm doesn't quite apply
 919  *      here though.
 920  *********************************************************************************
 921  */
 922
 923 void pullUpDnControlGpio (int pin, int pud)
 924 {
 925   pin &= 63 ;
 926   pud &=  3 ;
 927
 928   *(gpio + GPPUD)              = pud ;                  delayMicroseconds (5) ;
 929   *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ;      delayMicroseconds (5) ;
 930
 931   *(gpio + GPPUD)              = 0 ;                    delayMicroseconds (5) ;
 932   *(gpio + gpioToPUDCLK [pin]) = 0 ;                    delayMicroseconds (5) ;
 933 }
 934
 935 void pullUpDnControlWPi (int pin, int pud)
 936 {
 937   pullUpDnControlGpio (pinToGpio [pin & 63], pud) ;
 938 }
 939
 940 void pullUpDnControlSys (int pin, int pud)
 941 {
 942   return ;
 943 }
 944
 945
 946 /*
 947  * pinMode:
 948  *      Sets the mode of a pin to be input, output or PWM output
 949  *********************************************************************************
 950  */
 951
 952 void pinModeGpio (int pin, int mode)
 953 {
 954 //  register int barrier ;
 955
 956   int fSel, shift, alt ;
 957
 958   pin &= 63 ;
 959
 960   fSel    = gpioToGPFSEL [pin] ;
 961   shift   = gpioToShift  [pin] ;
 962
 963   /**/ if (mode == INPUT)
 964     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
 965   else if (mode == OUTPUT)
 966     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
 967   else if (mode == PWM_OUTPUT)
 968   {
 969     if ((alt = gpioToPwmALT [pin]) == 0)        // Not a PWM pin
 970       return ;
 971
 972 // Set pin to PWM mode
 973
 974     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
 975     delayMicroseconds (110) ;           // See comments in pwmSetClockWPi
 976
 977     pwmSetModeWPi  (PWM_MODE_BAL) ;     // Pi default mode
 978     pwmSetRangeWPi (1024) ;             // Default range of 1024
 979     pwmSetClockWPi (32) ;               // 19.2 / 32 = 600KHz - Also starts the PWM
 980   }
 981   else if (mode == GPIO_CLOCK)
 982   {
 983     if ((alt = gpioToGpClkALT0 [pin]) == 0)     // Not a GPIO_CLOCK pin
 984       return ;
 985
 986 // Set pin to GPIO_CLOCK mode and set the clock frequency to 100KHz
 987
 988     *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
 989     delayMicroseconds (110) ;
 990     gpioClockSetGpio (pin, 100000) ;
 991   }
 992 }
 993
 994 void pinModeWPi (int pin, int mode)
 995 {
 996   pinModeGpio (pinToGpio [pin & 63], mode) ;
 997 }
 998
 999 void pinModeSys (int pin, int mode)
1000 {
1001   return ;
1002 }
1003
1004
1005 /*
1006  * waitForInterrupt:
1007  *      Wait for Interrupt on a GPIO pin.
1008  *      This is actually done via the /sys/class/gpio interface regardless of
1009  *      the wiringPi access mode in-use. Maybe sometime it might get a better
1010  *      way for a bit more efficiency.
1011  *********************************************************************************
1012  */
1013
1014 int waitForInterruptSys (int pin, int mS)
1015 {
1016   int fd, x ;
1017   uint8_t c ;
1018   struct pollfd polls ;
1019
1020   if ((fd = sysFds [pin & 63]) == -1)
1021     return -2 ;
1022
1023 // Setup poll structure
1024
1025   polls.fd     = fd ;
1026   polls.events = POLLPRI ;      // Urgent data!
1027
1028 // Wait for it ...
1029
1030   x = poll (&polls, 1, mS) ;
1031
1032 // Do a dummy read to clear the interrupt
1033 //      A one character read appars to be enough.
1034
1035   (void)read (fd, &c, 1) ;
1036
1037   return x ;
1038 }
1039
1040 int waitForInterruptWPi (int pin, int mS)
1041 {
1042   return waitForInterruptSys (pinToGpio [pin & 63], mS) ;
1043 }
1044
1045 int waitForInterruptGpio (int pin, int mS)
1046 {
1047   return waitForInterruptSys (pin, mS) ;
1048 }
1049
1050
1051 /*
1052  * interruptHandler:
1053  *      This is a thread and gets started to wait for the interrupt we're
1054  *      hoping to catch. It will call the user-function when the interrupt
1055  *      fires.
1056  *********************************************************************************
1057  */
1058
1059 static void *interruptHandler (void *arg)
1060 {
1061   int myPin = *(int *)arg ;
1062
1063   (void)piHiPri (55) ;  // Only effective if we run as root
1064
1065   for (;;)
1066     if (waitForInterruptSys (myPin, -1) > 0)
1067       isrFunctions [myPin] () ;
1068
1069   return NULL ;
1070 }
1071
1072
1073 /*
1074  * wiringPiISR:
1075  *      Take the details and create an interrupt handler that will do a call-
1076  *      back to the user supplied function.
1077  *********************************************************************************
1078  */
1079
1080 int wiringPiISR (int pin, int mode, void (*function)(void))
1081 {
1082   pthread_t threadId ;
1083   char fName   [64] ;
1084   char *modeS ;
1085   char  pinS [8] ;
1086   pid_t pid ;
1087   int   count, i ;
1088   uint8_t c ;
1089
1090   pin &= 63 ;
1091
1092   if (wiringPiMode == WPI_MODE_UNINITIALISED)
1093   {
1094     fprintf (stderr, "wiringPiISR: wiringPi has not been initialised. Unable to continue.\n") ;
1095     exit (EXIT_FAILURE) ;
1096   }
1097   else if (wiringPiMode == WPI_MODE_PINS)
1098     pin = pinToGpio [pin] ;
1099
1100 // Now export the pin and set the right edge
1101 //      We're going to use the gpio program to do this, so it assumes
1102 //      a full installation of wiringPi. It's a bit 'clunky', but it
1103 //      is a way that will work when we're running in "Sys" mode, as
1104 //      a non-root user. (without sudo)
1105
1106   if (mode != INT_EDGE_SETUP)
1107   {
1108     /**/ if (mode == INT_EDGE_FALLING)
1109       modeS = "falling" ;
1110     else if (mode == INT_EDGE_RISING)
1111       modeS = "rising" ;
1112     else
1113       modeS = "both" ;
1114
1115     sprintf (pinS, "%d", pin) ;
1116
1117     if ((pid = fork ()) < 0)    // Fail
1118       return pid ;
1119
1120     if (pid == 0)       // Child, exec
1121     {
1122       execl ("/usr/local/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
1123       return -1 ;       // Failure ...
1124     }
1125     else                // Parent, wait
1126       wait (NULL) ;
1127   }
1128
1129 // Now pre-open the /sys/class node - it may already be open if
1130 //      we are in Sys mode, but this will do no harm.
1131
1132   sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1133   if ((sysFds [pin] = open (fName, O_RDWR)) < 0)
1134     return -1 ;
1135
1136 // Clear any initial pending interrupt
1137
1138   ioctl (sysFds [pin], FIONREAD, &count) ;
1139   for (i = 0 ; i < count ; ++i)
1140     read (sysFds [pin], &c, 1) ;
1141
1142   isrFunctions [pin] = function ;
1143
1144   pthread_create (&threadId, NULL, interruptHandler, &pin) ;
1145
1146   delay (1) ;
1147
1148   return 0 ;
1149 }
1150
1151
1152 /*
1153  * initialiseEpoch:
1154  *      Initialise our start-of-time variable to be the current unix
1155  *      time in milliseconds.
1156  *********************************************************************************
1157  */
1158
1159 static void initialiseEpoch (void)
1160 {
1161   struct timeval tv ;
1162
1163   gettimeofday (&tv, NULL) ;
1164   epochMilli = (uint64_t)tv.tv_sec * (uint64_t)1000    + (uint64_t)(tv.tv_usec / 1000) ;
1165   epochMicro = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)(tv.tv_usec) ;
1166 }
1167
1168 /*
1169  * delay:
1170  *      Wait for some number of milli seconds
1171  *********************************************************************************
1172  */
1173
1174 void delay (unsigned int howLong)
1175 {
1176   struct timespec sleeper, dummy ;
1177
1178   sleeper.tv_sec  = (time_t)(howLong / 1000) ;
1179   sleeper.tv_nsec = (long)(howLong % 1000) * 1000000 ;
1180
1181   nanosleep (&sleeper, &dummy) ;
1182 }
1183
1184
1185 /*
1186  * delayMicroseconds:
1187  *      This is somewhat intersting. It seems that on the Pi, a single call
1188  *      to nanosleep takes some 80 to 130 microseconds anyway, so while
1189  *      obeying the standards (may take longer), it's not always what we
1190  *      want!
1191  *
1192  *      So what I'll do now is if the delay is less than 100uS we'll do it
1193  *      in a hard loop, watching a built-in counter on the ARM chip. This is
1194  *      somewhat sub-optimal in that it uses 100% CPU, something not an issue
1195  *      in a microcontroller, but under a multi-tasking, multi-user OS, it's
1196  *      wastefull, however we've no real choice )-:
1197  *
1198  *      Plan B: It seems all might not be well with that plan, so changing it
1199  *      to use gettimeofday () and poll on that instead...
1200  *********************************************************************************
1201  */
1202
1203 void delayMicrosecondsHard (unsigned int howLong)
1204 {
1205   struct timeval tNow, tLong, tEnd ;
1206
1207   gettimeofday (&tNow, NULL) ;
1208   tLong.tv_sec  = howLong / 1000000 ;
1209   tLong.tv_usec = howLong % 1000000 ;
1210   timeradd (&tNow, &tLong, &tEnd) ;
1211
1212   while (timercmp (&tNow, &tEnd, <))
1213     gettimeofday (&tNow, NULL) ;
1214 }
1215
1216 void delayMicroseconds (unsigned int howLong)
1217 {
1218   struct timespec sleeper ;
1219
1220   /**/ if (howLong ==   0)
1221     return ;
1222   else if (howLong  < 100)
1223     delayMicrosecondsHard (howLong) ;
1224   else
1225   {
1226     sleeper.tv_sec  = 0 ;
1227     sleeper.tv_nsec = (long)(howLong * 1000) ;
1228     nanosleep (&sleeper, NULL) ;
1229   }
1230 }
1231
1232
1233 /*
1234  * millis:
1235  *      Return a number of milliseconds as an unsigned int.
1236  *********************************************************************************
1237  */
1238
1239 unsigned int millis (void)
1240 {
1241   struct timeval tv ;
1242   uint64_t now ;
1243
1244   gettimeofday (&tv, NULL) ;
1245   now  = (uint64_t)tv.tv_sec * (uint64_t)1000 + (uint64_t)(tv.tv_usec / 1000) ;
1246
1247   return (uint32_t)(now - epochMilli) ;
1248 }
1249
1250
1251 /*
1252  * micros:
1253  *      Return a number of microseconds as an unsigned int.
1254  *********************************************************************************
1255  */
1256
1257 unsigned int micros (void)
1258 {
1259   struct timeval tv ;
1260   uint64_t now ;
1261
1262   gettimeofday (&tv, NULL) ;
1263   now  = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)tv.tv_usec ;
1264
1265   return (uint32_t)(now - epochMicro) ;
1266 }
1267
1268
1269 /*
1270  * wiringPiSetup:
1271  *      Must be called once at the start of your program execution.
1272  *
1273  * Default setup: Initialises the system into wiringPi Pin mode and uses the
1274  *      memory mapped hardware directly.
1275  *********************************************************************************
1276  */
1277
1278 int wiringPiSetup (void)
1279 {
1280   int      fd ;
1281   int      boardRev ;
1282
1283   if (geteuid () != 0)
1284   {
1285     fprintf (stderr, "wiringPi:\n  Must be root to call wiringPiSetup().\n  (Did you forget sudo?)\n") ;
1286     exit (EXIT_FAILURE) ;
1287   }
1288
1289   if (getenv ("WIRINGPI_DEBUG") != NULL)
1290   {
1291     printf ("wiringPi: Debug mode enabled\n") ;
1292     wiringPiDebug = TRUE ;
1293   }
1294
1295   if (wiringPiDebug)
1296     printf ("wiringPi: wiringPiSetup called\n") ;
1297
1298             pinMode =           pinModeWPi ;
1299              getAlt =            getAltWPi ;
1300     pullUpDnControl =   pullUpDnControlWPi ;
1301        digitalWrite =      digitalWriteWPi ;
1302    digitalWriteByte = digitalWriteByteGpio ;    // Same code
1303        gpioClockSet =      gpioClockSetWPi ;
1304            pwmWrite =          pwmWriteWPi ;
1305         setPadDrive =       setPadDriveWPi ;
1306         digitalRead =       digitalReadWPi ;
1307    waitForInterrupt =  waitForInterruptWPi ;
1308          pwmSetMode =        pwmSetModeWPi ;
1309         pwmSetRange =       pwmSetRangeWPi ;
1310         pwmSetClock =       pwmSetClockWPi ;
1311
1312   boardRev = piBoardRev () ;
1313
1314   if (boardRev == 1)
1315     pinToGpio = pinToGpioR1 ;
1316   else
1317     pinToGpio = pinToGpioR2 ;
1318
1319 // Open the master /dev/memory device
1320
1321   if ((fd = open ("/dev/mem", O_RDWR | O_SYNC) ) < 0)
1322   {
1323     if (wiringPiDebug)
1324     {
1325       int serr = errno ;
1326         fprintf (stderr, "wiringPiSetup: Unable to open /dev/mem: %s\n", strerror (errno)) ;
1327       errno = serr ;
1328     }
1329     return -1 ;
1330   }
1331
1332 // GPIO:
1333
1334   gpio = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_BASE) ;
1335   if ((int32_t)gpio == -1)
1336   {
1337     if (wiringPiDebug)
1338     {
1339       int serr = errno ;
1340         fprintf (stderr, "wiringPiSetup: mmap failed: %s\n", strerror (errno)) ;
1341       errno = serr ;
1342     }
1343     return -1 ;
1344   }
1345
1346 // PWM
1347
1348   pwm = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PWM) ;
1349   if ((int32_t)pwm == -1)
1350   {
1351     if (wiringPiDebug)
1352     {
1353       int serr = errno ;
1354         fprintf (stderr, "wiringPiSetup: mmap failed (pwm): %s\n", strerror (errno)) ;
1355       errno = serr ;
1356     }
1357     return -1 ;
1358   }
1359
1360 // Clock control (needed for PWM)
1361
1362   clk = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, CLOCK_BASE) ;
1363   if ((int32_t)clk == -1)
1364   {
1365     if (wiringPiDebug)
1366     {
1367       int serr = errno ;
1368         fprintf (stderr, "wiringPiSetup: mmap failed (clk): %s\n", strerror (errno)) ;
1369       errno = serr ;
1370     }
1371     return -1 ;
1372   }
1373
1374 // The drive pads
1375
1376   pads = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PADS) ;
1377   if ((int32_t)pads == -1)
1378   {
1379     if (wiringPiDebug)
1380     {
1381       int serr = errno ;
1382         fprintf (stderr, "wiringPiSetup: mmap failed (pads): %s\n", strerror (errno)) ;
1383       errno = serr ;
1384     }
1385     return -1 ;
1386   }
1387
1388 // The system timer
1389
1390   timer = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_TIMER) ;
1391   if ((int32_t)timer == -1)
1392   {
1393     if (wiringPiDebug)
1394     {
1395       int serr = errno ;
1396         fprintf (stderr, "wiringPiSetup: mmap failed (timer): %s\n", strerror (errno)) ;
1397       errno = serr ;
1398     }
1399     return -1 ;
1400   }
1401
1402 // Set the timer to free-running, 1MHz.
1403 //      0xF9 is 249, the timer divide is base clock / (divide+1)
1404 //      so base clock is 250MHz / 250 = 1MHz.
1405
1406   *(timer + TIMER_CONTROL) = 0x0000280 ;
1407   *(timer + TIMER_PRE_DIV) = 0x00000F9 ;
1408   timerIrqRaw = timer + TIMER_IRQ_RAW ;
1409
1410   initialiseEpoch () ;
1411
1412   wiringPiMode = WPI_MODE_PINS ;
1413
1414   return 0 ;
1415 }
1416
1417
1418 /*
1419  * wiringPiSetupGpio:
1420  *      Must be called once at the start of your program execution.
1421  *
1422  * GPIO setup: Initialises the system into GPIO Pin mode and uses the
1423  *      memory mapped hardware directly.
1424  *********************************************************************************
1425  */
1426
1427 int wiringPiSetupGpio (void)
1428 {
1429   int x  ;
1430
1431   if (geteuid () != 0)
1432   {
1433     fprintf (stderr, "Must be root to call wiringPiSetupGpio(). (Did you forget sudo?)\n") ;
1434     exit (EXIT_FAILURE) ;
1435   }
1436
1437   if ((x = wiringPiSetup ()) < 0)
1438     return x ;
1439
1440   if (wiringPiDebug)
1441     printf ("wiringPi: wiringPiSetupGpio called\n") ;
1442
1443             pinMode =           pinModeGpio ;
1444              getAlt =            getAltGpio ;
1445     pullUpDnControl =   pullUpDnControlGpio ;
1446        digitalWrite =      digitalWriteGpio ;
1447    digitalWriteByte =  digitalWriteByteGpio ;
1448        gpioClockSet =      gpioClockSetGpio ;
1449            pwmWrite =          pwmWriteGpio ;
1450         setPadDrive =       setPadDriveGpio ;
1451         digitalRead =       digitalReadGpio ;
1452    waitForInterrupt =  waitForInterruptGpio ;
1453          pwmSetMode =        pwmSetModeWPi ;
1454         pwmSetRange =       pwmSetRangeWPi ;
1455         pwmSetClock =       pwmSetClockWPi ;
1456
1457   wiringPiMode = WPI_MODE_GPIO ;
1458
1459   return 0 ;
1460 }
1461
1462
1463 /*
1464  * wiringPiSetupSys:
1465  *      Must be called once at the start of your program execution.
1466  *
1467  * Initialisation (again), however this time we are using the /sys/class/gpio
1468  *      interface to the GPIO systems - slightly slower, but always usable as
1469  *      a non-root user, assuming the devices are already exported and setup correctly.
1470  */
1471
1472 int wiringPiSetupSys (void)
1473 {
1474   int boardRev ;
1475   int pin ;
1476   char fName [128] ;
1477
1478   if (getenv ("WIRINGPI_DEBUG") != NULL)
1479     wiringPiDebug = TRUE ;
1480
1481   if (wiringPiDebug)
1482     printf ("wiringPi: wiringPiSetupSys called\n") ;
1483
1484             pinMode =           pinModeSys ;
1485              getAlt =            getAltSys ;
1486     pullUpDnControl =   pullUpDnControlSys ;
1487        digitalWrite =      digitalWriteSys ;
1488    digitalWriteByte =  digitalWriteByteSys ;
1489        gpioClockSet =      gpioClockSetSys ;
1490            pwmWrite =          pwmWriteSys ;
1491         setPadDrive =       setPadDriveSys ;
1492         digitalRead =       digitalReadSys ;
1493    waitForInterrupt =  waitForInterruptSys ;
1494          pwmSetMode =        pwmSetModeSys ;
1495         pwmSetRange =       pwmSetRangeSys ;
1496         pwmSetClock =       pwmSetClockSys ;
1497
1498   boardRev = piBoardRev () ;
1499
1500   if (boardRev == 1)
1501     pinToGpio = pinToGpioR1 ;
1502   else
1503     pinToGpio = pinToGpioR2 ;
1504
1505 // Open and scan the directory, looking for exported GPIOs, and pre-open
1506 //      the 'value' interface to speed things up for later
1507
1508   for (pin = 0 ; pin < 64 ; ++pin)
1509   {
1510     sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1511     sysFds [pin] = open (fName, O_RDWR) ;
1512   }
1513
1514   initialiseEpoch () ;
1515
1516   wiringPiMode = WPI_MODE_GPIO_SYS ;
1517
1518   return 0 ;
1519 }