wiringPi/wiringPi.c

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