Gordons Projects

--> Projects Top-Level GIT

Pushing to 2.39 as I have have not done the last one rightly...
[wiringPi] / wiringPi / wiringPi.c
index 066f842..ba86f41 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * wiringPi:
- *     Arduino compatable (ish) Wiring library for the Raspberry Pi
- *     Copyright (c) 2012 Gordon Henderson
+ *     Arduino look-a-like Wiring library for the Raspberry Pi
+ *     Copyright (c) 2012-2017 Gordon Henderson
  *     Additional code for pwmSetClock by Chris Hall <chris@kchall.plus.com>
  *
  *     Thanks to code samples from Gert Jan van Loo and the
 //             Added in the 2 UART pins
 //             Change maxPins to numPins to more accurately reflect purpose
 
-// Pad drive current fiddling
-
-#undef DEBUG_PADS
 
 #include <stdio.h>
+#include <stdarg.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <pthread.h>
 #include <sys/time.h>
 #include <sys/mman.h>
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
+#include <sys/ioctl.h>
+#include <asm/ioctl.h>
+
+#include "softPwm.h"
+#include "softTone.h"
 
 #include "wiringPi.h"
+#include "../version.h"
 
-// Function stubs
-
-void (*pinMode)           (int pin, int mode) ;
-void (*pullUpDnControl)   (int pin, int pud) ;
-void (*digitalWrite)      (int pin, int value) ;
-void (*digitalWriteByte)  (int value) ;
-void (*pwmWrite)          (int pin, int value) ;
-void (*setPadDrive)       (int group, int value) ;
-int  (*digitalRead)       (int pin) ;
-int  (*waitForInterrupt)  (int pin, int mS) ;
-void (*delayMicroseconds) (unsigned int howLong) ;
-void (*pwmSetMode)        (int mode) ;
-void (*pwmSetRange)       (unsigned int range) ;
-void (*pwmSetClock)       (int divisor) ;
-
-
-#ifndef        TRUE
-#define        TRUE    (1==1)
-#define        FALSE   (1==2)
-#endif
+// Environment Variables
+
+#define        ENV_DEBUG       "WIRINGPI_DEBUG"
+#define        ENV_CODES       "WIRINGPI_CODES"
+#define        ENV_GPIOMEM     "WIRINGPI_GPIOMEM"
+
+
+// Mask for the bottom 64 pins which belong to the Raspberry Pi
+//     The others are available for the other devices
+
+#define        PI_GPIO_MASK    (0xFFFFFFC0)
+
+struct wiringPiNodeStruct *wiringPiNodes = NULL ;
 
 // BCM Magic
 
 #define        BCM_PASSWORD            0x5A000000
 
 
+// The BCM2835 has 54 GPIO pins.
+//     BCM2835 data sheet, Page 90 onwards.
+//     There are 6 control registers, each control the functions of a block
+//     of 10 pins.
+//     Each control register has 10 sets of 3 bits per GPIO pin - the ALT values
+//
+//     000 = GPIO Pin X is an input
+//     001 = GPIO Pin X is an output
+//     100 = GPIO Pin X takes alternate function 0
+//     101 = GPIO Pin X takes alternate function 1
+//     110 = GPIO Pin X takes alternate function 2
+//     111 = GPIO Pin X takes alternate function 3
+//     011 = GPIO Pin X takes alternate function 4
+//     010 = GPIO Pin X takes alternate function 5
+//
+// So the 3 bits for port X are:
+//     X / 10 + ((X % 10) * 3)
+
 // Port function select bits
 
 #define        FSEL_INPT               0b000
 #define        FSEL_OUTP               0b001
 #define        FSEL_ALT0               0b100
-#define        FSEL_ALT0               0b100
 #define        FSEL_ALT1               0b101
 #define        FSEL_ALT2               0b110
 #define        FSEL_ALT3               0b111
@@ -113,20 +126,23 @@ void (*pwmSetClock)       (int divisor) ;
 #define        FSEL_ALT5               0b010
 
 // Access from ARM Running Linux
-//     Take from Gert/Doms code. Some of this is not in the manual
+//     Taken from Gert/Doms code. Some of this is not in the manual
 //     that I can find )-:
+//
+// Updates in September 2015 - all now static variables (and apologies for the caps)
+//     due to the Pi v2, v3, etc. and the new /dev/gpiomem interface
 
-#define BCM2708_PERI_BASE                         0x20000000
-#define GPIO_PADS              (BCM2708_PERI_BASE + 0x100000)
-#define CLOCK_BASE             (BCM2708_PERI_BASE + 0x101000)
-#define GPIO_BASE              (BCM2708_PERI_BASE + 0x200000)
-#define GPIO_TIMER             (BCM2708_PERI_BASE + 0x00B000)
-#define GPIO_PWM               (BCM2708_PERI_BASE + 0x20C000)
+static volatile unsigned int GPIO_PADS ;
+static volatile unsigned int GPIO_CLOCK_BASE ;
+static volatile unsigned int GPIO_BASE ;
+static volatile unsigned int GPIO_TIMER ;
+static volatile unsigned int GPIO_PWM ;
 
 #define        PAGE_SIZE               (4*1024)
 #define        BLOCK_SIZE              (4*1024)
 
 // PWM
+//     Word offsets into the PWM control region
 
 #define        PWM_CONTROL 0
 #define        PWM_STATUS  1
@@ -135,17 +151,11 @@ void (*pwmSetClock)       (int divisor) ;
 #define        PWM1_RANGE  8
 #define        PWM1_DATA   9
 
+//     Clock regsiter offsets
+
 #define        PWMCLK_CNTL     40
 #define        PWMCLK_DIV      41
 
-#define        PWM1_MS_MODE    0x8000  // Run in MS mode
-#define        PWM1_USEFIFO    0x2000  // Data from FIFO
-#define        PWM1_REVPOLAR   0x1000  // Reverse polarity
-#define        PWM1_OFFSTATE   0x0800  // Ouput Off state
-#define        PWM1_REPEATFF   0x0400  // Repeat last value if FIFO empty
-#define        PWM1_SERIAL     0x0200  // Run in serial mode
-#define        PWM1_ENABLE     0x0100  // Channel Enable
-
 #define        PWM0_MS_MODE    0x0080  // Run in MS mode
 #define        PWM0_USEFIFO    0x0020  // Data from FIFO
 #define        PWM0_REVPOLAR   0x0010  // Reverse polarity
@@ -154,7 +164,16 @@ void (*pwmSetClock)       (int divisor) ;
 #define        PWM0_SERIAL     0x0002  // Run in serial mode
 #define        PWM0_ENABLE     0x0001  // Channel Enable
 
+#define        PWM1_MS_MODE    0x8000  // Run in MS mode
+#define        PWM1_USEFIFO    0x2000  // Data from FIFO
+#define        PWM1_REVPOLAR   0x1000  // Reverse polarity
+#define        PWM1_OFFSTATE   0x0800  // Ouput Off state
+#define        PWM1_REPEATFF   0x0400  // Repeat last value if FIFO empty
+#define        PWM1_SERIAL     0x0200  // Run in serial mode
+#define        PWM1_ENABLE     0x0100  // Channel Enable
+
 // Timer
+//     Word offsets
 
 #define        TIMER_LOAD      (0x400 >> 2)
 #define        TIMER_VALUE     (0x404 >> 2)
@@ -172,43 +191,126 @@ static volatile uint32_t *gpio ;
 static volatile uint32_t *pwm ;
 static volatile uint32_t *clk ;
 static volatile uint32_t *pads ;
+
+#ifdef USE_TIMER
 static volatile uint32_t *timer ;
 static volatile uint32_t *timerIrqRaw ;
+#endif
+
+// Data for use with the boardId functions.
+//     The order of entries here to correspond with the PI_MODEL_X
+//     and PI_VERSION_X defines in wiringPi.h
+//     Only intended for the gpio command - use at your own risk!
+
+// piGpioBase:
+//     The base address of the GPIO memory mapped hardware IO
+
+#define        GPIO_PERI_BASE_OLD      0x20000000
+#define        GPIO_PERI_BASE_NEW      0x3F000000
+
+static volatile unsigned int piGpioBase = 0 ;
+
+const char *piModelNames [16] =
+{
+  "Model A",   //  0
+  "Model B",   //  1
+  "Model A+",  //  2
+  "Model B+",  //  3
+  "Pi 2",      //  4
+  "Alpha",     //  5
+  "CM",                //  6
+  "Unknown07", // 07
+  "Pi 3",      // 08
+  "Pi Zero",   // 09
+  "CM3",       // 10
+  "Unknown11", // 11
+  "Unknown12", // 12
+  "Unknown13", // 13
+  "Unknown14", // 14
+  "Unknown15", // 15
+} ;
+
+const char *piRevisionNames [16] =
+{
+  "00",
+  "01",
+  "02",
+  "03",
+  "04",
+  "05",
+  "06",
+  "07",
+  "08",
+  "09",
+  "10",
+  "11",
+  "12",
+  "13",
+  "14",
+  "15",
+} ;
+
+const char *piMakerNames [16] =
+{
+  "Sony",      //       0
+  "Egoman",    //       1
+  "Embest",    //       2
+  "Unknown",   //       3
+  "Embest",    //       4
+  "Unknown05", //       5
+  "Unknown06", //       6
+  "Unknown07", //       7
+  "Unknown08", //       8
+  "Unknown09", //       9
+  "Unknown10", //      10
+  "Unknown11", //      11
+  "Unknown12", //      12
+  "Unknown13", //      13
+  "Unknown14", //      14
+  "Unknown15", //      15
+} ;
+
+const int piMemorySize [8] =
+{
+   256,                //       0
+   512,                //       1
+  1024,                //       2
+     0,                //       3
+     0,                //       4
+     0,                //       5
+     0,                //       6
+     0,                //       7
+} ;
 
 // Time for easy calculations
 
-static unsigned long long epoch ;
+static uint64_t epochMilli, epochMicro ;
 
 // Misc
 
 static int wiringPiMode = WPI_MODE_UNINITIALISED ;
+static volatile int    pinPass = -1 ;
+static pthread_mutex_t pinMutex ;
 
-// Debugging
+// Debugging & Return codes
 
-int wiringPiDebug = FALSE ;
+int wiringPiDebug       = FALSE ;
+int wiringPiReturnCodes = FALSE ;
 
-// The BCM2835 has 54 GPIO pins.
-//     BCM2835 data sheet, Page 90 onwards.
-//     There are 6 control registers, each control the functions of a block
-//     of 10 pins.
-//     Each control register has 10 sets of 3 bits per GPIO pin:
-//
-//     000 = GPIO Pin X is an input
-//     001 = GPIO Pin X is an output
-//     100 = GPIO Pin X takes alternate function 0
-//     101 = GPIO Pin X takes alternate function 1
-//     110 = GPIO Pin X takes alternate function 2
-//     111 = GPIO Pin X takes alternate function 3
-//     011 = GPIO Pin X takes alternate function 4
-//     010 = GPIO Pin X takes alternate function 5
-//
-// So the 3 bits for port X are:
-//     X / 10 + ((X % 10) * 3)
+// Use /dev/gpiomem ?
+
+int wiringPiTryGpioMem  = FALSE ;
 
 // sysFds:
 //     Map a file descriptor from the /sys/class/gpio/gpioX/value
 
-static int sysFds [64] ;
+static int sysFds [64] =
+{
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+} ;
 
 // ISR Data
 
@@ -221,17 +323,19 @@ static void (*isrFunctions [64])(void) ;
 
 // pinToGpio:
 //     Take a Wiring pin (0 through X) and re-map it to the BCM_GPIO pin
-//     Cope for 2 different board revieions here
+//     Cope for 3 different board revisions here.
 
 static int *pinToGpio ;
 
+// Revision 1, 1.1:
+
 static int pinToGpioR1 [64] =
 {
-  17, 18, 21, 22, 23, 24, 25, 4,       // From the Original Wiki - GPIO 0 through 7
-   0,  1,                              // I2C  - SDA0, SCL0
-   8,  7,                              // SPI  - CE1, CE0
-  10,  9, 11,                          // SPI  - MOSI, MISO, SCLK
-  14, 15,                              // UART - Tx, Rx
+  17, 18, 21, 22, 23, 24, 25, 4,       // From the Original Wiki - GPIO 0 through 7:   wpi  0 -  7
+   0,  1,                              // I2C  - SDA1, SCL1                            wpi  8 -  9
+   8,  7,                              // SPI  - CE1, CE0                              wpi 10 - 11
+  10,  9, 11,                          // SPI  - MOSI, MISO, SCLK                      wpi 12 - 14
+  14, 15,                              // UART - Tx, Rx                                wpi 15 - 16
 
 // Padding:
 
@@ -240,6 +344,8 @@ static int pinToGpioR1 [64] =
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,      // ... 63
 } ;
 
+// Revision 2:
+
 static int pinToGpioR2 [64] =
 {
   17, 18, 27, 22, 23, 24, 25, 4,       // From the Original Wiki - GPIO 0 through 7:   wpi  0 -  7
@@ -247,18 +353,93 @@ static int pinToGpioR2 [64] =
    8,  7,                              // SPI  - CE1, CE0                              wpi 10 - 11
   10,  9, 11,                          // SPI  - MOSI, MISO, SCLK                      wpi 12 - 14
   14, 15,                              // UART - Tx, Rx                                wpi 15 - 16
-  28, 29, 30, 31,                      // New GPIOs 8 though 11                        wpi 17 - 20
+  28, 29, 30, 31,                      // Rev 2: New GPIOs 8 though 11                 wpi 17 - 20
+   5,  6, 13, 19, 26,                  // B+                                           wpi 21, 22, 23, 24, 25
+  12, 16, 20, 21,                      // B+                                           wpi 26, 27, 28, 29
+   0,  1,                              // B+                                           wpi 30, 31
 
 // Padding:
 
-                      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,      // ... 31
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,      // ... 47
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,      // ... 63
 } ;
 
 
+// physToGpio:
+//     Take a physical pin (1 through 26) and re-map it to the BCM_GPIO pin
+//     Cope for 2 different board revisions here.
+//     Also add in the P5 connector, so the P5 pins are 3,4,5,6, so 53,54,55,56
+
+static int *physToGpio ;
+
+static int physToGpioR1 [64] =
+{
+  -1,          // 0
+  -1, -1,      // 1, 2
+   0, -1,
+   1, -1,
+   4, 14,
+  -1, 15,
+  17, 18,
+  21, -1,
+  22, 23,
+  -1, 24,
+  10, -1,
+   9, 25,
+  11,  8,
+  -1,  7,      // 25, 26
+
+                                              -1, -1, -1, -1, -1,      // ... 31
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,      // ... 47
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,      // ... 63
+} ;
+
+static int physToGpioR2 [64] =
+{
+  -1,          // 0
+  -1, -1,      // 1, 2
+   2, -1,
+   3, -1,
+   4, 14,
+  -1, 15,
+  17, 18,
+  27, -1,
+  22, 23,
+  -1, 24,
+  10, -1,
+   9, 25,
+  11,  8,
+  -1,  7,      // 25, 26
+
+// B+
+
+   0,  1,
+   5, -1,
+   6, 12,
+  13, -1,
+  19, 16,
+  26, 20,
+  -1, 21,
+
+// the P5 connector on the Rev 2 boards:
+
+  -1, -1,
+  -1, -1,
+  -1, -1,
+  -1, -1,
+  -1, -1,
+  28, 29,
+  30, 31,
+  -1, -1,
+  -1, -1,
+  -1, -1,
+  -1, -1,
+} ;
+
 // gpioToGPFSEL:
-//     Map a BCM_GPIO pin to it's control port. (GPFSEL 0-5)
+//     Map a BCM_GPIO pin to it's Function Selection
+//     control port. (GPFSEL 0-5)
+//     Groups of 10 - 3 bits per Function - 30 bits per port
 
 static uint8_t gpioToGPFSEL [] =
 {
@@ -281,6 +462,7 @@ static uint8_t gpioToShift [] =
   0,3,6,9,12,15,18,21,24,27,
   0,3,6,9,12,15,18,21,24,27,
   0,3,6,9,12,15,18,21,24,27,
+  0,3,6,9,12,15,18,21,24,27,
 } ;
 
 
@@ -293,7 +475,6 @@ static uint8_t gpioToGPSET [] =
    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,
 } ;
 
-
 // gpioToGPCLR:
 //     (Word) offset to the GPIO Clear registers for each GPIO pin
 
@@ -325,7 +506,7 @@ static uint8_t gpioToEDS [] =
 } ;
 
 // gpioToREN
-//     (Word) offset to the Rising edgde ENable register
+//     (Word) offset to the Rising edge ENable register
 
 static uint8_t gpioToREN [] =
 {
@@ -344,11 +525,14 @@ static uint8_t gpioToFEN [] =
 #endif
 
 
-// gpioToPUDCLK
-//     (Word) offset to the Pull Up Down Clock regsiter
+// GPPUD:
+//     GPIO Pin pull up/down register
 
 #define        GPPUD   37
 
+// gpioToPUDCLK
+//     (Word) offset to the Pull Up Down Clock regsiter
+
 static uint8_t gpioToPUDCLK [] =
 {
   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,
@@ -371,6 +555,10 @@ static uint8_t gpioToPwmALT [] =
           0,         0,         0,         0,         0,         0,         0,         0,      // 56 -> 63
 } ;
 
+
+// gpioToPwmPort
+//     The port value to put a GPIO pin into PWM mode
+
 static uint8_t gpioToPwmPort [] =
 {
           0,         0,         0,         0,         0,         0,         0,         0,      //  0 ->  7
@@ -384,6 +572,55 @@ static uint8_t gpioToPwmPort [] =
 
 } ;
 
+// gpioToGpClkALT:
+//     ALT value to put a GPIO pin into GP Clock mode.
+//     On the Pi we can really only use BCM_GPIO_4 and BCM_GPIO_21
+//     for clocks 0 and 1 respectively, however I'll include the full
+//     list for completeness - maybe one day...
+
+#define        GPIO_CLOCK_SOURCE       1
+
+// gpioToGpClkALT0:
+
+static uint8_t gpioToGpClkALT0 [] =
+{
+          0,         0,         0,         0, FSEL_ALT0, FSEL_ALT0, FSEL_ALT0,         0,      //  0 ->  7
+          0,         0,         0,         0,         0,         0,         0,         0,      //  8 -> 15
+          0,         0,         0,         0, FSEL_ALT5, FSEL_ALT5,         0,         0,      // 16 -> 23
+          0,         0,         0,         0,         0,         0,         0,         0,      // 24 -> 31
+  FSEL_ALT0,         0, FSEL_ALT0,         0,         0,         0,         0,         0,      // 32 -> 39
+          0,         0, FSEL_ALT0, FSEL_ALT0, FSEL_ALT0,         0,         0,         0,      // 40 -> 47
+          0,         0,         0,         0,         0,         0,         0,         0,      // 48 -> 55
+          0,         0,         0,         0,         0,         0,         0,         0,      // 56 -> 63
+} ;
+
+// gpioToClk:
+//     (word) Offsets to the clock Control and Divisor register
+
+static uint8_t gpioToClkCon [] =
+{
+         -1,        -1,        -1,        -1,        28,        30,        32,        -1,      //  0 ->  7
+         -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,      //  8 -> 15
+         -1,        -1,        -1,        -1,        28,        30,        -1,        -1,      // 16 -> 23
+         -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,      // 24 -> 31
+         28,        -1,        28,        -1,        -1,        -1,        -1,        -1,      // 32 -> 39
+         -1,        -1,        28,        30,        28,        -1,        -1,        -1,      // 40 -> 47
+         -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,      // 48 -> 55
+         -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,      // 56 -> 63
+} ;
+
+static uint8_t gpioToClkDiv [] =
+{
+         -1,        -1,        -1,        -1,        29,        31,        33,        -1,      //  0 ->  7
+         -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,      //  8 -> 15
+         -1,        -1,        -1,        -1,        29,        31,        -1,        -1,      // 16 -> 23
+         -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,      // 24 -> 31
+         29,        -1,        29,        -1,        -1,        -1,        -1,        -1,      // 32 -> 39
+         -1,        -1,        29,        31,        29,        -1,        -1,        -1,      // 40 -> 47
+         -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,      // 48 -> 55
+         -1,        -1,        -1,        -1,        -1,        -1,        -1,        -1,      // 56 -> 63
+} ;
+
 
 /*
  * Functions
@@ -392,253 +629,536 @@ static uint8_t gpioToPwmPort [] =
 
 
 /*
- * wpiPinToGpio:
- *     Translate a wiringPi Pin number to native GPIO pin number.
- *     (We don't use this here, prefering to just do the lookup directly,
- *     but it's been requested!)
+ * wiringPiFailure:
+ *     Fail. Or not.
  *********************************************************************************
  */
 
-int wpiPinToGpio (int wpiPin)
+int wiringPiFailure (int fatal, const char *message, ...)
 {
-  return pinToGpio [wpiPin & 63] ;
+  va_list argp ;
+  char buffer [1024] ;
+
+  if (!fatal && wiringPiReturnCodes)
+    return -1 ;
+
+  va_start (argp, message) ;
+    vsnprintf (buffer, 1023, message, argp) ;
+  va_end (argp) ;
+
+  fprintf (stderr, "%s", buffer) ;
+  exit (EXIT_FAILURE) ;
+
+  return 0 ;
 }
 
 
 /*
- * piBoardRev:
+ * piGpioLayout:
  *     Return a number representing the hardware revision of the board.
- *     Revision is currently 1 or 2. -1 is returned on error.
+ *     This is not strictly the board revision but is used to check the
+ *     layout of the GPIO connector - and there are 2 types that we are
+ *     really interested in here. The very earliest Pi's and the
+ *     ones that came after that which switched some pins ....
  *
- *     Much confusion here )-:
- *     Seems there are some boards with 0000 in them (mistake in manufacture)
- *     and some board with 0005 in them (another mistake in manufacture?)
- *     So the distinction between boards that I can see is:
- *     0000 - Error
- *     0001 - Not used
- *     0002 - Rev 1
- *     0003 - Rev 1
- *     0004 - Rev 2
- *     0005 - Rev 2 (but error)
- *     0006 - Rev 2
- *     000f - Rev 2 + 512MB
+ *     Revision 1 really means the early Model A and B's.
+ *     Revision 2 is everything else - it covers the B, B+ and CM.
+ *             ... and the Pi 2 - which is a B+ ++  ...
+ *             ... and the Pi 0 - which is an A+ ...
  *
- *     A small thorn is the olde style overvolting - that will add in
- *             1000000
+ *     The main difference between the revision 1 and 2 system that I use here
+ *     is the mapping of the GPIO pins. From revision 2, the Pi Foundation changed
+ *     3 GPIO pins on the (original) 26-way header - BCM_GPIO 22 was dropped and
+ *     replaced with 27, and 0 + 1 - I2C bus 0 was changed to 2 + 3; I2C bus 1.
+ *
+ *     Additionally, here we set the piModel2 flag too. This is again, nothing to
+ *     do with the actual model, but the major version numbers - the GPIO base
+ *     hardware address changed at model 2 and above (not the Zero though)
  *
  *********************************************************************************
  */
 
-static void piBoardRevOops (char *why)
+static void piGpioLayoutOops (const char *why)
 {
-  fprintf (stderr, "piBoardRev: Unable to determine board revision from /proc/cpuinfo\n") ;
+  fprintf (stderr, "Oops: Unable to determine board revision from /proc/cpuinfo\n") ;
   fprintf (stderr, " -> %s\n", why) ;
-  fprintf (stderr, " ->  You may want to check:\n") ;
-  fprintf (stderr, " ->  http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
+  fprintf (stderr, " ->  You'd best google the error to find out why.\n") ;
+//fprintf (stderr, " ->  http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
   exit (EXIT_FAILURE) ;
 }
 
-int piBoardRev (void)
+int piGpioLayout (void)
 {
   FILE *cpuFd ;
   char line [120] ;
-  char *c, lastChar ;
-  static int  boardRev = -1 ;
-
-// No point checking twice...
+  char *c ;
+  static int  gpioLayout = -1 ;
 
-  if (boardRev != -1)
-    return boardRev ;
+  if (gpioLayout != -1)        // No point checking twice
+    return gpioLayout ;
 
   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
-    return -1 ;
+    piGpioLayoutOops ("Unable to open /proc/cpuinfo") ;
+
+// Start by looking for the Architecture to make sure we're really running
+//     on a Pi. I'm getting fed-up with people whinging at me because
+//     they can't get it to work on weirdFruitPi boards...
+
+  while (fgets (line, 120, cpuFd) != NULL)
+    if (strncmp (line, "Hardware", 8) == 0)
+      break ;
+
+  if (strncmp (line, "Hardware", 8) != 0)
+    piGpioLayoutOops ("No \"Hardware\" line") ;
+
+  if (wiringPiDebug)
+    printf ("piGpioLayout: Hardware: %s\n", line) ;
+
+// See if it's BCM2708 or BCM2709 or the new BCM2835.
+
+// OK. As of Kernel 4.8,  we have BCM2835 only, regardless of model.
+//     However I still want to check because it will trap the cheapskates and rip-
+//     off merchants who want to use wiringPi on non-Raspberry Pi platforms - which
+//     I do not support so don't email me your bleating whinges about anything
+//     other than a genuine Raspberry Pi.
+
+  if (! (strstr (line, "BCM2708") || strstr (line, "BCM2709") || strstr (line, "BCM2835")))
+  {
+    fprintf (stderr, "Unable to determine hardware version. I see: %s,\n", line) ;
+    fprintf (stderr, " - expecting BCM2708, BCM2709 or BCM2835.\n") ;
+    fprintf (stderr, "If this is a genuine Raspberry Pi then please report this\n") ;
+    fprintf (stderr, "to projects@drogon.net. If this is not a Raspberry Pi then you\n") ;
+    fprintf (stderr, "are on your own as wiringPi is designed to support the\n") ;
+    fprintf (stderr, "Raspberry Pi ONLY.\n") ;
+    exit (EXIT_FAILURE) ;
+  }
+
+// Right - we're Probably on a Raspberry Pi. Check the revision field for the real
+//     hardware type
+//     In-future, I ought to use the device tree as there are now Pi entries in
+//     /proc/device-tree/ ...
+//     but I'll leave that for the next revision.
+
+// Isolate the Revision line
 
+  rewind (cpuFd) ;
   while (fgets (line, 120, cpuFd) != NULL)
     if (strncmp (line, "Revision", 8) == 0)
       break ;
 
   fclose (cpuFd) ;
 
-  if (line == NULL)
-    piBoardRevOops ("No \"Revision\" line") ;
+  if (strncmp (line, "Revision", 8) != 0)
+    piGpioLayoutOops ("No \"Revision\" line") ;
 
-  line [strlen (line) - 1] = 0 ; // Chomp LF
+// Chomp trailing CR/NL
+
+  for (c = &line [strlen (line) - 1] ; (*c == '\n') || (*c == '\r') ; --c)
+    *c = 0 ;
   
   if (wiringPiDebug)
-    printf ("piboardRev: Revision string: %s\n", line) ;
+    printf ("piGpioLayout: Revision string: %s\n", line) ;
+
+// Scan to the first character of the revision number
 
   for (c = line ; *c ; ++c)
-    if (isdigit (*c))
+    if (*c == ':')
       break ;
 
-  if (!isdigit (*c))
-    piBoardRevOops ("No numeric revision string") ;
+  if (*c != ':')
+    piGpioLayoutOops ("Bogus \"Revision\" line (no colon)") ;
 
-// If you have overvolted the Pi, then it appears that the revision
-//     has 100000 added to it!
+// Chomp spaces
 
-  if (wiringPiDebug)
-    if (strlen (c) != 4)
-      printf ("piboardRev: This Pi has/is overvolted!\n") ;
+  ++c ;
+  while (isspace (*c))
+    ++c ;
+
+  if (!isxdigit (*c))
+    piGpioLayoutOops ("Bogus \"Revision\" line (no hex digit at start of revision)") ;
 
-  lastChar = line [strlen (line) - 1] ;
+// Make sure its long enough
+
+  if (strlen (c) < 4)
+    piGpioLayoutOops ("Bogus revision line (too small)") ;
+
+// Isolate  last 4 characters: (in-case of overvolting or new encoding scheme)
+
+  c = c + strlen (c) - 4 ;
 
   if (wiringPiDebug)
-    printf ("piboardRev: lastChar is: '%c' (%d, 0x%02X)\n", lastChar, lastChar, lastChar) ;
+    printf ("piGpioLayout: last4Chars are: \"%s\"\n", c) ;
 
-  /**/ if ((lastChar == '2') || (lastChar == '3'))
-    boardRev = 1 ;
+  if ( (strcmp (c, "0002") == 0) || (strcmp (c, "0003") == 0))
+    gpioLayout = 1 ;
   else
-    boardRev = 2 ;
+    gpioLayout = 2 ;   // Covers everything else from the B revision 2 to the B+, the Pi v2, v3, zero and CM's.
 
   if (wiringPiDebug)
-    printf ("piBoardRev: Returning revision: %d\n", boardRev) ;
+    printf ("piGpioLayoutOops: Returning revision: %d\n", gpioLayout) ;
+
+  return gpioLayout ;
+}
+
+/*
+ * piBoardRev:
+ *     Deprecated, but does the same as piGpioLayout
+ *********************************************************************************
+ */
 
-  return boardRev ;
+int piBoardRev (void)
+{
+  return piGpioLayout () ;
 }
 
 
 
 /*
- * pinMode:
- *     Sets the mode of a pin to be input, output or PWM output
+ * piBoardId:
+ *     Return the real details of the board we have.
+ *
+ *     This is undocumented and really only intended for the GPIO command.
+ *     Use at your own risk!
+ *
+ *     Seems there are some boards with 0000 in them (mistake in manufacture)
+ *     So the distinction between boards that I can see is:
+ *
+ *             0000 - Error
+ *             0001 - Not used 
+ *
+ *     Original Pi boards:
+ *             0002 - Model B,  Rev 1,   256MB, Egoman
+ *             0003 - Model B,  Rev 1.1, 256MB, Egoman, Fuses/D14 removed.
+ *
+ *     Newer Pi's with remapped GPIO:
+ *             0004 - Model B,  Rev 1.2, 256MB, Sony
+ *             0005 - Model B,  Rev 1.2, 256MB, Egoman
+ *             0006 - Model B,  Rev 1.2, 256MB, Egoman
+ *
+ *             0007 - Model A,  Rev 1.2, 256MB, Egoman
+ *             0008 - Model A,  Rev 1.2, 256MB, Sony
+ *             0009 - Model A,  Rev 1.2, 256MB, Egoman
+ *
+ *             000d - Model B,  Rev 1.2, 512MB, Egoman (Red Pi, Blue Pi?)
+ *             000e - Model B,  Rev 1.2, 512MB, Sony
+ *             000f - Model B,  Rev 1.2, 512MB, Egoman
+ *
+ *             0010 - Model B+, Rev 1.2, 512MB, Sony
+ *             0013 - Model B+  Rev 1.2, 512MB, Embest
+ *             0016 - Model B+  Rev 1.2, 512MB, Sony
+ *             0019 - Model B+  Rev 1.2, 512MB, Egoman
+ *
+ *             0011 - Pi CM,    Rev 1.1, 512MB, Sony
+ *             0014 - Pi CM,    Rev 1.1, 512MB, Embest
+ *             0017 - Pi CM,    Rev 1.1, 512MB, Sony
+ *             001a - Pi CM,    Rev 1.1, 512MB, Egoman
+ *
+ *             0012 - Model A+  Rev 1.1, 256MB, Sony
+ *             0015 - Model A+  Rev 1.1, 512MB, Embest
+ *             0018 - Model A+  Rev 1.1, 256MB, Sony
+ *             001b - Model A+  Rev 1.1, 256MB, Egoman
+ *
+ *     A small thorn is the olde style overvolting - that will add in
+ *             1000000
+ *
+ *     The Pi compute module has an revision of 0011 or 0014 - since we only
+ *     check the last digit, then it's 1, therefore it'll default to not 2 or
+ *     3 for a Rev 1, so will appear as a Rev 2. This is fine for the most part, but
+ *     we'll properly detect the Compute Module later and adjust accordingly.
+ *
+ * And then things changed with the introduction of the v2...
+ *
+ * For Pi v2 and subsequent models - e.g. the Zero:
+ *
+ *   [USER:8] [NEW:1] [MEMSIZE:3] [MANUFACTURER:4] [PROCESSOR:4] [TYPE:8] [REV:4]
+ *   NEW          23: will be 1 for the new scheme, 0 for the old scheme
+ *   MEMSIZE      20: 0=256M 1=512M 2=1G
+ *   MANUFACTURER 16: 0=SONY 1=EGOMAN 2=EMBEST
+ *   PROCESSOR    12: 0=2835 1=2836
+ *   TYPE         04: 0=MODELA 1=MODELB 2=MODELA+ 3=MODELB+ 4=Pi2 MODEL B 5=ALPHA 6=CM
+ *   REV          00: 0=REV0 1=REV1 2=REV2
  *********************************************************************************
  */
 
-void pinModeGpio (int pin, int mode)
+void piBoardId (int *model, int *rev, int *mem, int *maker, int *warranty)
 {
-//  register int barrier ;
+  FILE *cpuFd ;
+  char line [120] ;
+  char *c ;
+  unsigned int revision ;
+  int bRev, bType, bProc, bMfg, bMem, bWarranty ;
 
-  int fSel, shift, alt ;
+//     Will deal with the properly later on - for now, lets just get it going...
+//  unsigned int modelNum ;
 
-  pin &= 63 ;
+  (void)piGpioLayout () ;      // Call this first to make sure all's OK. Don't care about the result.
 
-  fSel    = gpioToGPFSEL [pin] ;
-  shift   = gpioToShift  [pin] ;
+  if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
+    piGpioLayoutOops ("Unable to open /proc/cpuinfo") ;
 
-  /**/ if (mode == INPUT)
-    *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
-  else if (mode == OUTPUT)
-    *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
-  else if (mode == PWM_OUTPUT)
-  {
-    if ((alt = gpioToPwmALT [pin]) == 0)       // Not a PWM pin
-      return ;
+  while (fgets (line, 120, cpuFd) != NULL)
+    if (strncmp (line, "Revision", 8) == 0)
+      break ;
 
-// Set pin to PWM mode
+  fclose (cpuFd) ;
+
+  if (strncmp (line, "Revision", 8) != 0)
+    piGpioLayoutOops ("No \"Revision\" line") ;
 
-    *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
+// Chomp trailing CR/NL
 
-    delayMicroseconds (110) ;                          // See comments in pwmSetClockWPi
-    *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
+  for (c = &line [strlen (line) - 1] ; (*c == '\n') || (*c == '\r') ; --c)
+    *c = 0 ;
+  
+  if (wiringPiDebug)
+    printf ("piBoardId: Revision string: %s\n", line) ;
 
-//  Page 107 of the BCM Peripherals manual talks about the GPIO clocks,
-//     but I'm assuming (hoping!) that this applies to other clocks too.
+// Need to work out if it's using the new or old encoding scheme:
 
-    *(pwm + PWM_CONTROL) = 0 ;                         // Stop PWM
+// Scan to the first character of the revision number
 
-    *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;       // Stop PWM Clock
-    delayMicroseconds (110) ;                          // See comments in pwmSetClockWPi
+  for (c = line ; *c ; ++c)
+    if (*c == ':')
+      break ;
 
-    while ((*(clk + PWMCLK_CNTL) & 0x80) != 0)         // Wait for clock to be !BUSY
-      delayMicroseconds (1) ;
+  if (*c != ':')
+    piGpioLayoutOops ("Bogus \"Revision\" line (no colon)") ;
 
-    *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (32 << 12) ; // set pwm div to 32 (19.2/32 = 600KHz)
-    *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;       // enable clk
+// Chomp spaces
 
-    delayMicroseconds (110) ;                          // See comments in pwmSetClockWPi
+  ++c ;
+  while (isspace (*c))
+    ++c ;
 
-// Default range register of 1024
+  if (!isxdigit (*c))
+    piGpioLayoutOops ("Bogus \"Revision\" line (no hex digit at start of revision)") ;
 
-    *(pwm + PWM0_RANGE) = 1024 ; delayMicroseconds (10) ;
-    *(pwm + PWM1_RANGE) = 1024 ; delayMicroseconds (10) ;
-    *(pwm + PWM0_DATA)  =    0 ; delayMicroseconds (10) ;
-    *(pwm + PWM1_DATA)  =    0 ; delayMicroseconds (10) ;
+  revision = (unsigned int)strtol (c, NULL, 16) ; // Hex number with no leading 0x
 
-// Enable PWMs in balanced mode (default)
+// Check for new way:
 
-    *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
+  if ((revision &  (1 << 23)) != 0)    // New way
+  {
+    if (wiringPiDebug)
+      printf ("piBoardId: New Way: revision is: 0x%08X\n", revision) ;
+
+    bRev      = (revision & (0x0F <<  0)) >>  0 ;
+    bType     = (revision & (0xFF <<  4)) >>  4 ;
+    bProc     = (revision & (0x0F << 12)) >> 12 ;      // Not used for now.
+    bMfg      = (revision & (0x0F << 16)) >> 16 ;
+    bMem      = (revision & (0x07 << 20)) >> 20 ;
+    bWarranty = (revision & (0x03 << 24)) != 0 ;
+    
+    *model    = bType ;
+    *rev      = bRev ;
+    *mem      = bMem ;
+    *maker    = bMfg  ;
+    *warranty = bWarranty ;
 
-    delay (100) ;
+    if (wiringPiDebug)
+      printf ("piBoardId: rev: %d, type: %d, proc: %d, mfg: %d, mem: %d, warranty: %d\n",
+               bRev, bType, bProc, bMfg, bMem, bWarranty) ;
   }
+  else                                 // Old way
+  {
+    if (wiringPiDebug)
+      printf ("piBoardId: Old Way: revision is: %s\n", c) ;
 
+    if (!isdigit (*c))
+      piGpioLayoutOops ("Bogus \"Revision\" line (no digit at start of revision)") ;
 
-// When we change mode of any pin, we remove the pull up/downs
-//     Or we used to... Hm. Commented out now because for some wieird reason,
-//     it seems to block subsequent attempts to set the pull up/downs and I've
-//     not quite gotten to the bottom of why this happens
-//     The down-side is that the pull up/downs are rememberd in the SoC between
-//     power cycles, so it's going to be a good idea to explicitly set them in
-//     any new code.
-//
-//  pullUpDnControl (pin, PUD_OFF) ;
+// Make sure its long enough
 
-}
+    if (strlen (c) < 4)
+      piGpioLayoutOops ("Bogus \"Revision\" line (not long enough)") ;
 
-void pinModeWPi (int pin, int mode)
-{
-  pinModeGpio (pinToGpio [pin & 63], mode) ;
-}
+// If longer than 4, we'll assume it's been overvolted
 
-void pinModeSys (int pin, int mode)
-{
-  return ;
+    *warranty = strlen (c) > 4 ;
+  
+// Extract last 4 characters:
+
+    c = c + strlen (c) - 4 ;
+
+// Fill out the replys as appropriate
+
+    /**/ if (strcmp (c, "0002") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1   ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
+    else if (strcmp (c, "0003") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_1 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
+
+    else if (strcmp (c, "0004") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_SONY    ; }
+    else if (strcmp (c, "0005") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
+    else if (strcmp (c, "0006") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
+
+    else if (strcmp (c, "0007") == 0) { *model = PI_MODEL_A  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
+    else if (strcmp (c, "0008") == 0) { *model = PI_MODEL_A  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_SONY ;  ; }
+    else if (strcmp (c, "0009") == 0) { *model = PI_MODEL_A  ; *rev = PI_VERSION_1_2 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
+
+    else if (strcmp (c, "000d") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_EGOMAN  ; }
+    else if (strcmp (c, "000e") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_SONY    ; }
+    else if (strcmp (c, "000f") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_EGOMAN  ; }
+
+    else if (strcmp (c, "0010") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_SONY    ; }
+    else if (strcmp (c, "0013") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_EMBEST  ; }
+    else if (strcmp (c, "0016") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_SONY    ; }
+    else if (strcmp (c, "0019") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 1 ; *maker = PI_MAKER_EGOMAN  ; }
+
+    else if (strcmp (c, "0011") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_1 ; *mem = 1 ; *maker = PI_MAKER_SONY    ; }
+    else if (strcmp (c, "0014") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_1 ; *mem = 1 ; *maker = PI_MAKER_EMBEST  ; }
+    else if (strcmp (c, "0017") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_1 ; *mem = 1 ; *maker = PI_MAKER_SONY    ; }
+    else if (strcmp (c, "001a") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_1 ; *mem = 1 ; *maker = PI_MAKER_EGOMAN  ; }
+
+    else if (strcmp (c, "0012") == 0) { *model = PI_MODEL_AP ; *rev = PI_VERSION_1_1 ; *mem = 0 ; *maker = PI_MAKER_SONY    ; }
+    else if (strcmp (c, "0015") == 0) { *model = PI_MODEL_AP ; *rev = PI_VERSION_1_1 ; *mem = 1 ; *maker = PI_MAKER_EMBEST  ; }
+    else if (strcmp (c, "0018") == 0) { *model = PI_MODEL_AP ; *rev = PI_VERSION_1_1 ; *mem = 0 ; *maker = PI_MAKER_SONY    ; }
+    else if (strcmp (c, "001b") == 0) { *model = PI_MODEL_AP ; *rev = PI_VERSION_1_1 ; *mem = 0 ; *maker = PI_MAKER_EGOMAN  ; }
+
+    else                              { *model = 0           ; *rev = 0              ; *mem =   0 ; *maker = 0 ;               }
+  }
 }
 
 
 /*
- * pwmControl:
- *     Allow the user to control some of the PWM functions
+ * wpiPinToGpio:
+ *     Translate a wiringPi Pin number to native GPIO pin number.
+ *     Provided for external support.
  *********************************************************************************
  */
 
-void pwmSetModeWPi (int mode)
+int wpiPinToGpio (int wpiPin)
 {
-  if (mode == PWM_MODE_MS)
-    *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
-  else
-    *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
+  return pinToGpio [wpiPin & 63] ;
 }
 
-void pwmSetModeSys (int mode)
-{
-  return ;
-}
 
+/*
+ * physPinToGpio:
+ *     Translate a physical Pin number to native GPIO pin number.
+ *     Provided for external support.
+ *********************************************************************************
+ */
 
-void pwmSetRangeWPi (unsigned int range)
+int physPinToGpio (int physPin)
 {
-  *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
-  *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
+  return physToGpio [physPin & 63] ;
 }
 
-void pwmSetRangeSys (unsigned int range)
-{
-  return ;
-}
 
 /*
- * pwmSetClockWPi:
- *     Set/Change the PWM clock. Originally my code, but changed
- *     (for the better!) by Chris Hall, <chris@kchall.plus.com>
- *     after further study of the manual and testing with a 'scope
+ * setPadDrive:
+ *     Set the PAD driver value
  *********************************************************************************
  */
 
-void pwmSetClockWPi (int divisor)
+void setPadDrive (int group, int value)
 {
-  unsigned int pwm_control ;
-  divisor &= 4095 ;
+  uint32_t wrVal ;
 
-  if (wiringPiDebug)
-    printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
+  if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
+  {
+    if ((group < 0) || (group > 2))
+      return ;
+
+    wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
+    *(pads + group + 11) = wrVal ;
+
+    if (wiringPiDebug)
+    {
+      printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
+      printf ("Read : %08X\n", *(pads + group + 11)) ;
+    }
+  }
+}
+
+
+/*
+ * getAlt:
+ *     Returns the ALT bits for a given port. Only really of-use
+ *     for the gpio readall command (I think)
+ *********************************************************************************
+ */
+
+int getAlt (int pin)
+{
+  int fSel, shift, alt ;
+
+  pin &= 63 ;
+
+  /**/ if (wiringPiMode == WPI_MODE_PINS)
+    pin = pinToGpio [pin] ;
+  else if (wiringPiMode == WPI_MODE_PHYS)
+    pin = physToGpio [pin] ;
+  else if (wiringPiMode != WPI_MODE_GPIO)
+    return 0 ;
+
+  fSel    = gpioToGPFSEL [pin] ;
+  shift   = gpioToShift  [pin] ;
+
+  alt = (*(gpio + fSel) >> shift) & 7 ;
+
+  return alt ;
+}
+
+
+/*
+ * pwmSetMode:
+ *     Select the native "balanced" mode, or standard mark:space mode
+ *********************************************************************************
+ */
+
+void pwmSetMode (int mode)
+{
+  if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
+  {
+    if (mode == PWM_MODE_MS)
+      *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
+    else
+      *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
+  }
+}
+
+
+/*
+ * pwmSetRange:
+ *     Set the PWM range register. We set both range registers to the same
+ *     value. If you want different in your own code, then write your own.
+ *********************************************************************************
+ */
+
+void pwmSetRange (unsigned int range)
+{
+  if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
+  {
+    *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
+    *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
+  }
+}
+
+
+/*
+ * pwmSetClock:
+ *     Set/Change the PWM clock. Originally my code, but changed
+ *     (for the better!) by Chris Hall, <chris@kchall.plus.com>
+ *     after further study of the manual and testing with a 'scope
+ *********************************************************************************
+ */
+
+void pwmSetClock (int divisor)
+{
+  uint32_t pwm_control ;
+  divisor &= 4095 ;
+
+  if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
+  {
+    if (wiringPiDebug)
+      printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
 
-  pwm_control = *(pwm + PWM_CONTROL) ;         // preserve PWM_CONTROL
+    pwm_control = *(pwm + PWM_CONTROL) ;               // preserve PWM_CONTROL
 
 // We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY
 // stays high.
 
-  *(pwm + PWM_CONTROL) = 0 ;                   // Stop PWM
+    *(pwm + PWM_CONTROL) = 0 ;                         // Stop PWM
 
 // Stop PWM clock before changing divisor. The delay after this does need to
 // this big (95uS occasionally fails, 100uS OK), it's almost as though the BUSY
@@ -646,24 +1166,125 @@ void pwmSetClockWPi (int divisor)
 // adjusted the clock sometimes switches to very slow, once slow further DIV
 // adjustments do nothing and it's difficult to get out of this mode.
 
-  *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ; // Stop PWM Clock
-    delayMicroseconds (110) ;                  // prevents clock going sloooow
+    *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;       // Stop PWM Clock
+      delayMicroseconds (110) ;                        // prevents clock going sloooow
 
-  while ((*(clk + PWMCLK_CNTL) & 0x80) != 0)   // Wait for clock to be !BUSY
-    delayMicroseconds (1) ;
+    while ((*(clk + PWMCLK_CNTL) & 0x80) != 0) // Wait for clock to be !BUSY
+      delayMicroseconds (1) ;
 
-  *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12) ;
+    *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12) ;
 
-  *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ; // Start PWM clock
-  *(pwm + PWM_CONTROL) = pwm_control ;         // restore PWM_CONTROL
+    *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;       // Start PWM clock
+    *(pwm + PWM_CONTROL) = pwm_control ;               // restore PWM_CONTROL
 
-  if (wiringPiDebug)
-    printf ("Set     to: %d. Now    : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
+    if (wiringPiDebug)
+      printf ("Set     to: %d. Now    : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
+  }
 }
 
-void pwmSetClockSys (int divisor)
+
+/*
+ * gpioClockSet:
+ *     Set the freuency on a GPIO clock pin
+ *********************************************************************************
+ */
+
+void gpioClockSet (int pin, int freq)
 {
-  return ;
+  int divi, divr, divf ;
+
+  pin &= 63 ;
+
+  /**/ if (wiringPiMode == WPI_MODE_PINS)
+    pin = pinToGpio [pin] ;
+  else if (wiringPiMode == WPI_MODE_PHYS)
+    pin = physToGpio [pin] ;
+  else if (wiringPiMode != WPI_MODE_GPIO)
+    return ;
+  
+  divi = 19200000 / freq ;
+  divr = 19200000 % freq ;
+  divf = (int)((double)divr * 4096.0 / 19200000.0) ;
+
+  if (divi > 4095)
+    divi = 4095 ;
+
+  *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | GPIO_CLOCK_SOURCE ;             // Stop GPIO Clock
+  while ((*(clk + gpioToClkCon [pin]) & 0x80) != 0)                            // ... and wait
+    ;
+
+  *(clk + gpioToClkDiv [pin]) = BCM_PASSWORD | (divi << 12) | divf ;           // Set dividers
+  *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | 0x10 | GPIO_CLOCK_SOURCE ;      // Start Clock
+}
+
+
+/*
+ * wiringPiFindNode:
+ *      Locate our device node
+ *********************************************************************************
+ */
+
+struct wiringPiNodeStruct *wiringPiFindNode (int pin)
+{
+  struct wiringPiNodeStruct *node = wiringPiNodes ;
+
+  while (node != NULL)
+    if ((pin >= node->pinBase) && (pin <= node->pinMax))
+      return node ;
+    else
+      node = node->next ;
+
+  return NULL ;
+}
+
+
+/*
+ * wiringPiNewNode:
+ *     Create a new GPIO node into the wiringPi handling system
+ *********************************************************************************
+ */
+
+static void pinModeDummy             (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int mode)  { return ; }
+static void pullUpDnControlDummy     (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int pud)   { return ; }
+static int  digitalReadDummy         (UNU struct wiringPiNodeStruct *node, UNU int UNU pin)            { return LOW ; }
+static void digitalWriteDummy        (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int value) { return ; }
+static void pwmWriteDummy            (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int value) { return ; }
+static int  analogReadDummy          (UNU struct wiringPiNodeStruct *node, UNU int pin)            { return 0 ; }
+static void analogWriteDummy         (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int value) { return ; }
+
+struct wiringPiNodeStruct *wiringPiNewNode (int pinBase, int numPins)
+{
+  int    pin ;
+  struct wiringPiNodeStruct *node ;
+
+// Minimum pin base is 64
+
+  if (pinBase < 64)
+    (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: pinBase of %d is < 64\n", pinBase) ;
+
+// Check all pins in-case there is overlap:
+
+  for (pin = pinBase ; pin < (pinBase + numPins) ; ++pin)
+    if (wiringPiFindNode (pin) != NULL)
+      (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: Pin %d overlaps with existing definition\n", pin) ;
+
+  node = (struct wiringPiNodeStruct *)calloc (sizeof (struct wiringPiNodeStruct), 1) ; // calloc zeros
+  if (node == NULL)
+    (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: Unable to allocate memory: %s\n", strerror (errno)) ;
+
+  node->pinBase         = pinBase ;
+  node->pinMax          = pinBase + numPins - 1 ;
+  node->pinMode         = pinModeDummy ;
+  node->pullUpDnControl = pullUpDnControlDummy ;
+  node->digitalRead     = digitalReadDummy ;
+  node->digitalWrite    = digitalWriteDummy ;
+  node->pwmWrite        = pwmWriteDummy ;
+  node->analogRead      = analogReadDummy ;
+  node->analogWrite     = analogWriteDummy ;
+  node->next            = wiringPiNodes ;
+  wiringPiNodes         = node ;
+
+  return node ;
 }
 
 
@@ -683,87 +1304,233 @@ void pinEnableED01Pi (int pin)
 #endif
 
 
+/*
+ *********************************************************************************
+ * Core Functions
+ *********************************************************************************
+ */
 
 /*
- * digitalWrite:
- *     Set an output bit
+ * pinModeAlt:
+ *     This is an un-documented special to let you set any pin to any mode
  *********************************************************************************
  */
 
-void digitalWriteWPi (int pin, int value)
+void pinModeAlt (int pin, int mode)
 {
-  pin = pinToGpio [pin & 63] ;
+  int fSel, shift ;
 
-  if (value == LOW)
-    *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
-  else
-    *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
+  if ((pin & PI_GPIO_MASK) == 0)               // On-board pin
+  {
+    /**/ if (wiringPiMode == WPI_MODE_PINS)
+      pin = pinToGpio [pin] ;
+    else if (wiringPiMode == WPI_MODE_PHYS)
+      pin = physToGpio [pin] ;
+    else if (wiringPiMode != WPI_MODE_GPIO)
+      return ;
+
+    fSel  = gpioToGPFSEL [pin] ;
+    shift = gpioToShift  [pin] ;
+
+    *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | ((mode & 0x7) << shift) ;
+  }
 }
 
-void digitalWriteGpio (int pin, int value)
+
+/*
+ * pinMode:
+ *     Sets the mode of a pin to be input, output or PWM output
+ *********************************************************************************
+ */
+
+void pinMode (int pin, int mode)
 {
-  pin &= 63 ;
+  int    fSel, shift, alt ;
+  struct wiringPiNodeStruct *node = wiringPiNodes ;
+  int origPin = pin ;
 
-  if (value == LOW)
-    *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
+  if ((pin & PI_GPIO_MASK) == 0)               // On-board pin
+  {
+    /**/ if (wiringPiMode == WPI_MODE_PINS)
+      pin = pinToGpio [pin] ;
+    else if (wiringPiMode == WPI_MODE_PHYS)
+      pin = physToGpio [pin] ;
+    else if (wiringPiMode != WPI_MODE_GPIO)
+      return ;
+
+    softPwmStop  (origPin) ;
+    softToneStop (origPin) ;
+
+    fSel    = gpioToGPFSEL [pin] ;
+    shift   = gpioToShift  [pin] ;
+
+    /**/ if (mode == INPUT)
+      *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
+    else if (mode == OUTPUT)
+      *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
+    else if (mode == SOFT_PWM_OUTPUT)
+      softPwmCreate (origPin, 0, 100) ;
+    else if (mode == SOFT_TONE_OUTPUT)
+      softToneCreate (origPin) ;
+    else if (mode == PWM_TONE_OUTPUT)
+    {
+      pinMode (origPin, PWM_OUTPUT) ;  // Call myself to enable PWM mode
+      pwmSetMode (PWM_MODE_MS) ;
+    }
+    else if (mode == PWM_OUTPUT)
+    {
+      if ((alt = gpioToPwmALT [pin]) == 0)     // Not a hardware capable PWM pin
+       return ;
+
+// Set pin to PWM mode
+
+      *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
+      delayMicroseconds (110) ;                // See comments in pwmSetClockWPi
+
+      pwmSetMode  (PWM_MODE_BAL) ;     // Pi default mode
+      pwmSetRange (1024) ;             // Default range of 1024
+      pwmSetClock (32) ;               // 19.2 / 32 = 600KHz - Also starts the PWM
+    }
+    else if (mode == GPIO_CLOCK)
+    {
+      if ((alt = gpioToGpClkALT0 [pin]) == 0)  // Not a GPIO_CLOCK pin
+       return ;
+
+// Set pin to GPIO_CLOCK mode and set the clock frequency to 100KHz
+
+      *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
+      delayMicroseconds (110) ;
+      gpioClockSet      (pin, 100000) ;
+    }
+  }
   else
-    *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
+  {
+    if ((node = wiringPiFindNode (pin)) != NULL)
+      node->pinMode (node, pin, mode) ;
+    return ;
+  }
 }
 
-void digitalWriteSys (int pin, int value)
+
+/*
+ * pullUpDownCtrl:
+ *     Control the internal pull-up/down resistors on a GPIO pin
+ *     The Arduino only has pull-ups and these are enabled by writing 1
+ *     to a port when in input mode - this paradigm doesn't quite apply
+ *     here though.
+ *********************************************************************************
+ */
+
+void pullUpDnControl (int pin, int pud)
 {
-  pin &= 63 ;
+  struct wiringPiNodeStruct *node = wiringPiNodes ;
 
-  if (sysFds [pin] != -1)
+  if ((pin & PI_GPIO_MASK) == 0)               // On-Board Pin
   {
-    if (value == LOW)
-      write (sysFds [pin], "0\n", 2) ;
-    else
-      write (sysFds [pin], "1\n", 2) ;
+    /**/ if (wiringPiMode == WPI_MODE_PINS)
+      pin = pinToGpio [pin] ;
+    else if (wiringPiMode == WPI_MODE_PHYS)
+      pin = physToGpio [pin] ;
+    else if (wiringPiMode != WPI_MODE_GPIO)
+      return ;
+
+    *(gpio + GPPUD)              = pud & 3 ;           delayMicroseconds (5) ;
+    *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ;   delayMicroseconds (5) ;
+    
+    *(gpio + GPPUD)              = 0 ;                 delayMicroseconds (5) ;
+    *(gpio + gpioToPUDCLK [pin]) = 0 ;                 delayMicroseconds (5) ;
+  }
+  else                                         // Extension module
+  {
+    if ((node = wiringPiFindNode (pin)) != NULL)
+      node->pullUpDnControl (node, pin, pud) ;
+    return ;
   }
 }
 
 
 /*
- * digitalWriteByte:
- *     Write an 8-bit byte to the first 8 GPIO pins - try to do it as
- *     fast as possible.
- *     However it still needs 2 operations to set the bits, so any external
- *     hardware must not rely on seeing a change as there will be a change 
- *     to set the outputs bits to zero, then another change to set the 1's
+ * digitalRead:
+ *     Read the value of a given Pin, returning HIGH or LOW
  *********************************************************************************
  */
 
-void digitalWriteByteGpio (int value)
+int digitalRead (int pin)
 {
-  uint32_t pinSet = 0 ;
-  uint32_t pinClr = 0 ;
-  int mask = 1 ;
-  int pin ;
+  char c ;
+  struct wiringPiNodeStruct *node = wiringPiNodes ;
 
-  for (pin = 0 ; pin < 8 ; ++pin)
+  if ((pin & PI_GPIO_MASK) == 0)               // On-Board Pin
   {
-    if ((value & mask) == 0)
-      pinClr |= (1 << pinToGpio [pin]) ;
-    else
-      pinSet |= (1 << pinToGpio [pin]) ;
+    /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)        // Sys mode
+    {
+      if (sysFds [pin] == -1)
+       return LOW ;
 
-    mask <<= 1 ;
+      lseek  (sysFds [pin], 0L, SEEK_SET) ;
+      read   (sysFds [pin], &c, 1) ;
+      return (c == '0') ? LOW : HIGH ;
+    }
+    else if (wiringPiMode == WPI_MODE_PINS)
+      pin = pinToGpio [pin] ;
+    else if (wiringPiMode == WPI_MODE_PHYS)
+      pin = physToGpio [pin] ;
+    else if (wiringPiMode != WPI_MODE_GPIO)
+      return LOW ;
+
+    if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
+      return HIGH ;
+    else
+      return LOW ;
+  }
+  else
+  {
+    if ((node = wiringPiFindNode (pin)) == NULL)
+      return LOW ;
+    return node->digitalRead (node, pin) ;
   }
-
-  *(gpio + gpioToGPCLR [0]) = pinClr ;
-  *(gpio + gpioToGPSET [0]) = pinSet ;
 }
 
-void digitalWriteByteSys (int value)
+
+/*
+ * digitalWrite:
+ *     Set an output bit
+ *********************************************************************************
+ */
+
+void digitalWrite (int pin, int value)
 {
-  int mask = 1 ;
-  int pin ;
+  struct wiringPiNodeStruct *node = wiringPiNodes ;
 
-  for (pin = 0 ; pin < 8 ; ++pin)
+  if ((pin & PI_GPIO_MASK) == 0)               // On-Board Pin
   {
-    digitalWriteSys (pinToGpio [pin], value & mask) ;
-    mask <<= 1 ;
+    /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)        // Sys mode
+    {
+      if (sysFds [pin] != -1)
+      {
+       if (value == LOW)
+         write (sysFds [pin], "0\n", 2) ;
+       else
+         write (sysFds [pin], "1\n", 2) ;
+      }
+      return ;
+    }
+    else if (wiringPiMode == WPI_MODE_PINS)
+      pin = pinToGpio [pin] ;
+    else if (wiringPiMode == WPI_MODE_PHYS)
+      pin = physToGpio [pin] ;
+    else if (wiringPiMode != WPI_MODE_GPIO)
+      return ;
+
+    if (value == LOW)
+      *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
+    else
+      *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
+  }
+  else
+  {
+    if ((node = wiringPiFindNode (pin)) != NULL)
+      node->digitalWrite (node, pin, value) ;
   }
 }
 
@@ -774,135 +1541,220 @@ void digitalWriteByteSys (int value)
  *********************************************************************************
  */
 
-void pwmWriteGpio (int pin, int value)
+void pwmWrite (int pin, int value)
 {
-  int port ;
+  struct wiringPiNodeStruct *node = wiringPiNodes ;
 
-  pin  = pin & 63 ;
-  port = gpioToPwmPort [pin] ;
+  if ((pin & PI_GPIO_MASK) == 0)               // On-Board Pin
+  {
+    /**/ if (wiringPiMode == WPI_MODE_PINS)
+      pin = pinToGpio [pin] ;
+    else if (wiringPiMode == WPI_MODE_PHYS)
+      pin = physToGpio [pin] ;
+    else if (wiringPiMode != WPI_MODE_GPIO)
+      return ;
 
-  *(pwm + port) = value ;
+    *(pwm + gpioToPwmPort [pin]) = value ;
+  }
+  else
+  {
+    if ((node = wiringPiFindNode (pin)) != NULL)
+      node->pwmWrite (node, pin, value) ;
+  }
 }
 
-void pwmWriteWPi (int pin, int value)
-{
-  pwmWriteGpio (pinToGpio [pin & 63], value) ;
-}
 
-void pwmWriteSys (int pin, int value)
+/*
+ * analogRead:
+ *     Read the analog value of a given Pin. 
+ *     There is no on-board Pi analog hardware,
+ *     so this needs to go to a new node.
+ *********************************************************************************
+ */
+
+int analogRead (int pin)
 {
-  return ;
+  struct wiringPiNodeStruct *node = wiringPiNodes ;
+
+  if ((node = wiringPiFindNode (pin)) == NULL)
+    return 0 ;
+  else
+    return node->analogRead (node, pin) ;
 }
 
 
 /*
- * setPadDrive:
- *     Set the PAD driver value
+ * analogWrite:
+ *     Write the analog value to the given Pin. 
+ *     There is no on-board Pi analog hardware,
+ *     so this needs to go to a new node.
  *********************************************************************************
  */
 
-void setPadDriveWPi (int group, int value)
+void analogWrite (int pin, int value)
 {
-  uint32_t wrVal ;
+  struct wiringPiNodeStruct *node = wiringPiNodes ;
 
-  if ((group < 0) || (group > 2))
+  if ((node = wiringPiFindNode (pin)) == NULL)
     return ;
 
-  wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
-  *(pads + group + 11) = wrVal ;
-
-#ifdef DEBUG_PADS
-  printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
-  printf ("Read : %08X\n", *(pads + group + 11)) ;
-#endif
+  node->analogWrite (node, pin, value) ;
 }
 
-void setPadDriveGpio (int group, int value)
-{
-  setPadDriveWPi (group, value) ;
-}
 
-void setPadDriveSys (int group, int value)
+/*
+ * pwmToneWrite:
+ *     Pi Specific.
+ *      Output the given frequency on the Pi's PWM pin
+ *********************************************************************************
+ */
+
+void pwmToneWrite (int pin, int freq)
 {
-  return ;
+  int range ;
+
+  if (freq == 0)
+    pwmWrite (pin, 0) ;             // Off
+  else
+  {
+    range = 600000 / freq ;
+    pwmSetRange (range) ;
+    pwmWrite    (pin, freq / 2) ;
+  }
 }
 
 
+
 /*
- * digitalRead:
- *     Read the value of a given Pin, returning HIGH or LOW
+ * digitalWriteByte:
+ * digitalReadByte:
+ *     Pi Specific
+ *     Write an 8-bit byte to the first 8 GPIO pins - try to do it as
+ *     fast as possible.
+ *     However it still needs 2 operations to set the bits, so any external
+ *     hardware must not rely on seeing a change as there will be a change 
+ *     to set the outputs bits to zero, then another change to set the 1's
+ *     Reading is just bit fiddling.
+ *     These are wiringPi pin numbers 0..7, or BCM_GPIO pin numbers
+ *     17, 18, 22, 23, 24, 24, 4 on a Pi v1 rev 0-3
+ *     17, 18, 27, 23, 24, 24, 4 on a Pi v1 rev 3 onwards or B+, 2, 3, zero
  *********************************************************************************
  */
 
-int digitalReadWPi (int pin)
+void digitalWriteByte (const int value)
 {
-  pin = pinToGpio [pin & 63] ;
+  uint32_t pinSet = 0 ;
+  uint32_t pinClr = 0 ;
+  int mask = 1 ;
+  int pin ;
 
-  if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
-    return HIGH ;
+  /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
+  {
+    for (pin = 0 ; pin < 8 ; ++pin)
+    {
+      digitalWrite (pinToGpio [pin], value & mask) ;
+      mask <<= 1 ;
+    }
+    return ;
+  }
   else
-    return LOW ;
-}
+  {
+    for (pin = 0 ; pin < 8 ; ++pin)
+    {
+      if ((value & mask) == 0)
+       pinClr |= (1 << pinToGpio [pin]) ;
+      else
+       pinSet |= (1 << pinToGpio [pin]) ;
 
-int digitalReadGpio (int pin)
-{
-  pin &= 63 ;
+      mask <<= 1 ;
+    }
 
-  if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
-    return HIGH ;
-  else
-    return LOW ;
+    *(gpio + gpioToGPCLR [0]) = pinClr ;
+    *(gpio + gpioToGPSET [0]) = pinSet ;
+  }
 }
 
-int digitalReadSys (int pin)
+unsigned int digitalReadByte (void)
 {
-  char c ;
-
-  pin &= 63 ;
+  int pin, x ;
+  uint32_t raw ;
+  uint32_t data = 0 ;
 
-  if (sysFds [pin] == -1)
-    return 0 ;
-
-  lseek (sysFds [pin], 0L, SEEK_SET) ;
-  read  (sysFds [pin], &c, 1) ;
-  return (c == '0') ? 0 : 1 ;
+  /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
+  {
+    for (pin = 0 ; pin < 8 ; ++pin)
+    {
+      x = digitalRead (pinToGpio [pin]) ;
+      data = (data << 1) | x ;
+    }
+  }
+  else 
+  {
+    raw = *(gpio + gpioToGPLEV [0]) ; // First bank for these pins
+    for (pin = 0 ; pin < 8 ; ++pin)
+    {
+      x = pinToGpio [pin] ;
+      data = (data << 1) | (((raw & (1 << x)) == 0) ? 0 : 1) ;
+    }
+  }
+  return data ;
 }
 
 
 /*
- * pullUpDownCtrl:
- *     Control the internal pull-up/down resistors on a GPIO pin
- *     The Arduino only has pull-ups and these are enabled by writing 1
- *     to a port when in input mode - this paradigm doesn't quite apply
- *     here though.
+ * digitalWriteByte2:
+ * digitalReadByte2:
+ *     Pi Specific
+ *     Write an 8-bit byte to the second set of 8 GPIO pins. This is marginally
+ *     faster than the first lot as these are consecutive BCM_GPIO pin numbers.
+ *     However they overlap with the original read/write bytes.
  *********************************************************************************
  */
 
-void pullUpDnControlGpio (int pin, int pud)
+void digitalWriteByte2 (const int value)
 {
-  pin &= 63 ;
-  pud &=  3 ;
+  register int mask = 1 ;
+  register int pin ;
 
-  *(gpio + GPPUD)              = pud ;                 delayMicroseconds (5) ;
-  *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ;     delayMicroseconds (5) ;
-  
-  *(gpio + GPPUD)              = 0 ;                   delayMicroseconds (5) ;
-  *(gpio + gpioToPUDCLK [pin]) = 0 ;                   delayMicroseconds (5) ;
+  /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
+  {
+    for (pin = 20 ; pin < 28 ; ++pin)
+    {
+      digitalWrite (pin, value & mask) ;
+      mask <<= 1 ;
+    }
+    return ;
+  }
+  else
+  {
+    *(gpio + gpioToGPCLR [0]) = (~value & 0xFF) << 20 ; // 0x0FF00000; ILJ > CHANGE: Old causes glitch
+    *(gpio + gpioToGPSET [0]) = ( value & 0xFF) << 20 ;
+  }
 }
 
-void pullUpDnControlWPi (int pin, int pud)
+unsigned int digitalReadByte2 (void)
 {
-  pullUpDnControlGpio (pinToGpio [pin & 63], pud) ;
-}
+  int pin, x ;
+  uint32_t data = 0 ;
 
-void pullUpDnControlSys (int pin, int pud)
-{
-  return ;
+  /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
+  {
+    for (pin = 20 ; pin < 28 ; ++pin)
+    {
+      x = digitalRead (pin) ;
+      data = (data << 1) | x ;
+    }
+  }
+  else 
+    data = ((*(gpio + gpioToGPLEV [0])) >> 20) & 0xFF ; // First bank for these pins
+
+  return data ;
 }
 
 
 /*
  * waitForInterrupt:
+ *     Pi Specific.
  *     Wait for Interrupt on a GPIO pin.
  *     This is actually done via the /sys/class/gpio interface regardless of
  *     the wiringPi access mode in-use. Maybe sometime it might get a better
@@ -910,43 +1762,39 @@ void pullUpDnControlSys (int pin, int pud)
  *********************************************************************************
  */
 
-int waitForInterruptSys (int pin, int mS)
+int waitForInterrupt (int pin, int mS)
 {
   int fd, x ;
-  char buf [8] ;
+  uint8_t c ;
   struct pollfd polls ;
 
-  if ((fd = sysFds [pin & 63]) == -1)
-    return -2 ;
-
-// Do a dummy read
-
-  x = read (fd, buf, 6) ;
-  if (x < 0)
-    return x ;
-
-// And seek
+  /**/ if (wiringPiMode == WPI_MODE_PINS)
+    pin = pinToGpio [pin] ;
+  else if (wiringPiMode == WPI_MODE_PHYS)
+    pin = physToGpio [pin] ;
 
-  lseek (fd, 0, SEEK_SET) ;
+  if ((fd = sysFds [pin]) == -1)
+    return -2 ;
 
 // Setup poll structure
 
   polls.fd     = fd ;
-  polls.events = POLLPRI ;     // Urgent data!
+  polls.events = POLLPRI | POLLERR ;
 
 // Wait for it ...
 
-  return poll (&polls, 1, mS) ;
-}
+  x = poll (&polls, 1, mS) ;
 
-int waitForInterruptWPi (int pin, int mS)
-{
-  return waitForInterruptSys (pinToGpio [pin & 63], mS) ;
-}
+// If no error, do a dummy read to clear the interrupt
+//     A one character read appars to be enough.
 
-int waitForInterruptGpio (int pin, int mS)
-{
-  return waitForInterruptSys (pin, mS) ;
+  if (x > 0)
+  {
+    lseek (fd, 0, SEEK_SET) ;  // Rewind
+    (void)read (fd, &c, 1) ;   // Read & clear
+  }
+
+  return x ;
 }
 
 
@@ -958,14 +1806,17 @@ int waitForInterruptGpio (int pin, int mS)
  *********************************************************************************
  */
 
-static void *interruptHandler (void *arg)
+static void *interruptHandler (UNU void *arg)
 {
-  int myPin = *(int *)arg ;
+  int myPin ;
 
   (void)piHiPri (55) ; // Only effective if we run as root
 
+  myPin   = pinPass ;
+  pinPass = -1 ;
+
   for (;;)
-    if (waitForInterruptSys (myPin, -1) > 0)
+    if (waitForInterrupt (myPin, -1) > 0)
       isrFunctions [myPin] () ;
 
   return NULL ;
@@ -974,6 +1825,7 @@ static void *interruptHandler (void *arg)
 
 /*
  * wiringPiISR:
+ *     Pi Specific.
  *     Take the details and create an interrupt handler that will do a call-
  *     back to the user supplied function.
  *********************************************************************************
@@ -982,20 +1834,25 @@ static void *interruptHandler (void *arg)
 int wiringPiISR (int pin, int mode, void (*function)(void))
 {
   pthread_t threadId ;
+  const char *modeS ;
   char fName   [64] ;
-  char *modeS ;
   char  pinS [8] ;
   pid_t pid ;
+  int   count, i ;
+  char  c ;
+  int   bcmGpioPin ;
 
-  pin &= 63 ;
+  if ((pin < 0) || (pin > 63))
+    return wiringPiFailure (WPI_FATAL, "wiringPiISR: pin must be 0-63 (%d)\n", pin) ;
 
-  if (wiringPiMode == WPI_MODE_UNINITIALISED)
-  {
-    fprintf (stderr, "wiringPiISR: wiringPi has not been initialised. Unable to continue.\n") ;
-    exit (EXIT_FAILURE) ;
-  }
+  /**/ if (wiringPiMode == WPI_MODE_UNINITIALISED)
+    return wiringPiFailure (WPI_FATAL, "wiringPiISR: wiringPi has not been initialised. Unable to continue.\n") ;
   else if (wiringPiMode == WPI_MODE_PINS)
-    pin = pinToGpio [pin] ;
+    bcmGpioPin = pinToGpio [pin] ;
+  else if (wiringPiMode == WPI_MODE_PHYS)
+    bcmGpioPin = physToGpio [pin] ;
+  else
+    bcmGpioPin = pin ;
 
 // Now export the pin and set the right edge
 //     We're going to use the gpio program to do this, so it assumes
@@ -1012,40 +1869,87 @@ int wiringPiISR (int pin, int mode, void (*function)(void))
     else
       modeS = "both" ;
 
-    sprintf (pinS, "%d", pin) ;
+    sprintf (pinS, "%d", bcmGpioPin) ;
 
     if ((pid = fork ()) < 0)   // Fail
-      return pid ;
+      return wiringPiFailure (WPI_FATAL, "wiringPiISR: fork failed: %s\n", strerror (errno)) ;
 
     if (pid == 0)      // Child, exec
     {
-      execl ("/usr/local/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
-      return -1 ;      // Failure ...
+      /**/ if (access ("/usr/local/bin/gpio", X_OK) == 0)
+      {
+       execl ("/usr/local/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
+       return wiringPiFailure (WPI_FATAL, "wiringPiISR: execl failed: %s\n", strerror (errno)) ;
+      }
+      else if (access ("/usr/bin/gpio", X_OK) == 0)
+      {
+       execl ("/usr/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
+       return wiringPiFailure (WPI_FATAL, "wiringPiISR: execl failed: %s\n", strerror (errno)) ;
+      }
+      else
+       return wiringPiFailure (WPI_FATAL, "wiringPiISR: Can't find gpio program\n") ;
     }
     else               // Parent, wait
       wait (NULL) ;
   }
 
-// Now pre-open the /sys/class node - it may already be open if
-//     we had set it up earlier, but this will do no harm.
+// Now pre-open the /sys/class node - but it may already be open if
+//     we are in Sys mode...
 
-  sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
-  if ((sysFds [pin] = open (fName, O_RDWR)) < 0)
-    return -1 ;
+  if (sysFds [bcmGpioPin] == -1)
+  {
+    sprintf (fName, "/sys/class/gpio/gpio%d/value", bcmGpioPin) ;
+    if ((sysFds [bcmGpioPin] = open (fName, O_RDWR)) < 0)
+      return wiringPiFailure (WPI_FATAL, "wiringPiISR: unable to open %s: %s\n", fName, strerror (errno)) ;
+  }
 
-  isrFunctions [pin] = function ;
+// Clear any initial pending interrupt
 
-  pthread_create (&threadId, NULL, interruptHandler, &pin) ;
+  ioctl (sysFds [bcmGpioPin], FIONREAD, &count) ;
+  for (i = 0 ; i < count ; ++i)
+    read (sysFds [bcmGpioPin], &c, 1) ;
+
+  isrFunctions [pin] = function ;
 
-  delay (1) ;
+  pthread_mutex_lock (&pinMutex) ;
+    pinPass = pin ;
+    pthread_create (&threadId, NULL, interruptHandler, NULL) ;
+    while (pinPass != -1)
+      delay (1) ;
+  pthread_mutex_unlock (&pinMutex) ;
 
   return 0 ;
 }
 
 
 /*
+ * initialiseEpoch:
+ *     Initialise our start-of-time variable to be the current unix
+ *     time in milliseconds and microseconds.
+ *********************************************************************************
+ */
+
+static void initialiseEpoch (void)
+{
+#ifdef OLD_WAY
+  struct timeval tv ;
+
+  gettimeofday (&tv, NULL) ;
+  epochMilli = (uint64_t)tv.tv_sec * (uint64_t)1000    + (uint64_t)(tv.tv_usec / 1000) ;
+  epochMicro = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)(tv.tv_usec) ;
+#else
+  struct timespec ts ;
+
+  clock_gettime (CLOCK_MONOTONIC_RAW, &ts) ;
+  epochMilli = (uint64_t)ts.tv_sec * (uint64_t)1000    + (uint64_t)(ts.tv_nsec / 1000000L) ;
+  epochMicro = (uint64_t)ts.tv_sec * (uint64_t)1000000 + (uint64_t)(ts.tv_nsec /    1000L) ;
+#endif
+}
+
+
+/*
  * delay:
- *     Wait for some number of milli seconds
+ *     Wait for some number of milliseconds
  *********************************************************************************
  */
 
@@ -1078,28 +1982,8 @@ void delay (unsigned int howLong)
  *********************************************************************************
  */
 
-void delayMicrosecondsSys (unsigned int howLong)
-{
-  struct timespec sleeper, dummy ;
-
-  sleeper.tv_sec  = 0 ;
-  sleeper.tv_nsec = (long)(howLong * 1000) ;
-
-  nanosleep (&sleeper, &dummy) ;
-}
-
 void delayMicrosecondsHard (unsigned int howLong)
 {
-#ifdef  HARD_TIMER
-  volatile unsigned int dummy ;
-
-  *(timer + TIMER_LOAD)    = howLong ;
-  *(timer + TIMER_IRQ_CLR) = 0 ;
-
-  dummy = *timerIrqRaw ;
-  while (dummy == 0)
-    dummy = *timerIrqRaw ;
-#else
   struct timeval tNow, tLong, tEnd ;
 
   gettimeofday (&tNow, NULL) ;
@@ -1109,12 +1993,13 @@ void delayMicrosecondsHard (unsigned int howLong)
 
   while (timercmp (&tNow, &tEnd, <))
     gettimeofday (&tNow, NULL) ;
-#endif
 }
 
-void delayMicrosecondsWPi (unsigned int howLong)
+void delayMicroseconds (unsigned int howLong)
 {
   struct timespec sleeper ;
+  unsigned int uSecs = howLong % 1000000 ;
+  unsigned int wSecs = howLong / 1000000 ;
 
   /**/ if (howLong ==   0)
     return ;
@@ -1122,8 +2007,8 @@ void delayMicrosecondsWPi (unsigned int howLong)
     delayMicrosecondsHard (howLong) ;
   else
   {
-    sleeper.tv_sec  = 0 ;
-    sleeper.tv_nsec = (long)(howLong * 1000) ;
+    sleeper.tv_sec  = wSecs ;
+    sleeper.tv_nsec = (long)(uSecs * 1000L) ;
     nanosleep (&sleeper, NULL) ;
   }
 }
@@ -1132,195 +2017,196 @@ void delayMicrosecondsWPi (unsigned int howLong)
 /*
  * millis:
  *     Return a number of milliseconds as an unsigned int.
+ *     Wraps at 49 days.
  *********************************************************************************
  */
 
 unsigned int millis (void)
 {
+  uint64_t now ;
+
+#ifdef OLD_WAY
   struct timeval tv ;
-  unsigned long long t1 ;
 
   gettimeofday (&tv, NULL) ;
+  now  = (uint64_t)tv.tv_sec * (uint64_t)1000 + (uint64_t)(tv.tv_usec / 1000) ;
 
-  t1 = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
+#else
+  struct  timespec ts ;
+
+  clock_gettime (CLOCK_MONOTONIC_RAW, &ts) ;
+  now  = (uint64_t)ts.tv_sec * (uint64_t)1000 + (uint64_t)(ts.tv_nsec / 1000000L) ;
+#endif
 
-  return (uint32_t)(t1 - epoch) ;
+  return (uint32_t)(now - epochMilli) ;
 }
 
 
 /*
- * wiringPiSetup:
- *     Must be called once at the start of your program execution.
- *
- * Default setup: Initialises the system into wiringPi Pin mode and uses the
- *     memory mapped hardware directly.
+ * micros:
+ *     Return a number of microseconds as an unsigned int.
+ *     Wraps after 71 minutes.
  *********************************************************************************
  */
 
-int wiringPiSetup (void)
+unsigned int micros (void)
 {
-  int      fd ;
-  int      boardRev ;
-  uint8_t *gpioMem, *pwmMem, *clkMem, *padsMem, *timerMem ;
+  uint64_t now ;
+#ifdef OLD_WAY
   struct timeval tv ;
 
-  if (geteuid () != 0)
-  {
-    fprintf (stderr, "wiringPi:\n  Must be root to call wiringPiSetup().\n  (Did you forget sudo?)\n") ;
-    exit (EXIT_FAILURE) ;
-  }
+  gettimeofday (&tv, NULL) ;
+  now  = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)tv.tv_usec ;
+#else
+  struct  timespec ts ;
 
-  if (getenv ("WIRINGPI_DEBUG") != NULL)
-  {
-    printf ("wiringPi: Debug mode enabled\n") ;
-    wiringPiDebug = TRUE ;
-  }
+  clock_gettime (CLOCK_MONOTONIC_RAW, &ts) ;
+  now  = (uint64_t)ts.tv_sec * (uint64_t)1000000 + (uint64_t)(ts.tv_nsec / 1000) ;
+#endif
 
-  if (wiringPiDebug)
-    printf ("wiringPi: wiringPiSetup called\n") ;
 
-            pinMode =           pinModeWPi ;
-    pullUpDnControl =   pullUpDnControlWPi ;
-       digitalWrite =      digitalWriteWPi ;
-   digitalWriteByte = digitalWriteByteGpio ;   // Same code
-           pwmWrite =          pwmWriteWPi ;
-        setPadDrive =       setPadDriveWPi ;
-        digitalRead =       digitalReadWPi ;
-   waitForInterrupt =  waitForInterruptWPi ;
-  delayMicroseconds = delayMicrosecondsWPi ;
-         pwmSetMode =        pwmSetModeWPi ;
-        pwmSetRange =       pwmSetRangeWPi ;
-        pwmSetClock =       pwmSetClockWPi ;
-  
-  boardRev = piBoardRev () ;
+  return (uint32_t)(now - epochMicro) ;
+}
 
-  if (boardRev == 1)
-    pinToGpio = pinToGpioR1 ;
-  else
-    pinToGpio = pinToGpioR2 ;
+/*
+ * wiringPiVersion:
+ *     Return our current version number
+ *********************************************************************************
+ */
 
-// Open the master /dev/memory device
+void wiringPiVersion (int *major, int *minor)
+{
+  *major = VERSION_MAJOR ;
+  *minor = VERSION_MINOR ;
+}
 
-  if ((fd = open ("/dev/mem", O_RDWR | O_SYNC) ) < 0)
-  {
-    if (wiringPiDebug)
-      fprintf (stderr, "wiringPiSetup: Unable to open /dev/mem: %s\n", strerror (errno)) ;
-    return -1 ;
-  }
 
-// GPIO:
+/*
+ * wiringPiSetup:
+ *     Must be called once at the start of your program execution.
+ *
+ * Default setup: Initialises the system into wiringPi Pin mode and uses the
+ *     memory mapped hardware directly.
+ *
+ * Changed now to revert to "gpio" mode if we're running on a Compute Module.
+ *********************************************************************************
+ */
 
-// Allocate 2 pages - 1 ...
+int wiringPiSetup (void)
+{
+  int   fd ;
+  int   model, rev, mem, maker, overVolted ;
+  static int alreadyDoneThis = FALSE ;
 
-  if ((gpioMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
-  {
-    if (wiringPiDebug)
-      fprintf (stderr, "wiringPiSetup: malloc failed: %s\n", strerror (errno)) ;
-    return -1 ;
-  }
+// It's actually a fatal error to call any of the wiringPiSetup routines more than once,
+//     (you run out of file handles!) but I'm fed-up with the useless twats who email
+//     me bleating that there is a bug in my code, so screw-em.
 
-// ... presumably to make sure we can round it up to a whole page size
+  if (alreadyDoneThis)
+    return 0 ;
 
-  if (((uint32_t)gpioMem % PAGE_SIZE) != 0)
-    gpioMem += PAGE_SIZE - ((uint32_t)gpioMem % PAGE_SIZE) ;
+  alreadyDoneThis = TRUE ;
 
-  gpio = (uint32_t *)mmap((caddr_t)gpioMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_BASE) ;
+  if (getenv (ENV_DEBUG) != NULL)
+    wiringPiDebug = TRUE ;
 
-  if ((int32_t)gpio < 0)
-  {
-    if (wiringPiDebug)
-      fprintf (stderr, "wiringPiSetup: mmap failed: %s\n", strerror (errno)) ;
-    return -1 ;
-  }
+  if (getenv (ENV_CODES) != NULL)
+    wiringPiReturnCodes = TRUE ;
 
-// PWM
+  if (wiringPiDebug)
+    printf ("wiringPi: wiringPiSetup called\n") ;
 
-  if ((pwmMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
-  {
-    if (wiringPiDebug)
-      fprintf (stderr, "wiringPiSetup: pwmMem malloc failed: %s\n", strerror (errno)) ;
-    return -1 ;
-  }
+// Get the board ID information. We're not really using the information here,
+//     but it will give us information like the GPIO layout scheme (2 variants
+//     on the older 26-pin Pi's) and the GPIO peripheral base address.
+//     and if we're running on a compute module, then wiringPi pin numbers
+//     don't really many anything, so force native BCM mode anyway.
 
-  if (((uint32_t)pwmMem % PAGE_SIZE) != 0)
-    pwmMem += PAGE_SIZE - ((uint32_t)pwmMem % PAGE_SIZE) ;
+  piBoardId (&model, &rev, &mem, &maker, &overVolted) ;
 
-  pwm = (uint32_t *)mmap(pwmMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_PWM) ;
+  if ((model == PI_MODEL_CM) || (model == PI_MODEL_CM3))
+    wiringPiMode = WPI_MODE_GPIO ;
+  else
+    wiringPiMode = WPI_MODE_PINS ;
 
-  if ((int32_t)pwm < 0)
+  /**/ if (piGpioLayout () == 1)       // A, B, Rev 1, 1.1
   {
-    if (wiringPiDebug)
-      fprintf (stderr, "wiringPiSetup: mmap failed (pwm): %s\n", strerror (errno)) ;
-    return -1 ;
+     pinToGpio =  pinToGpioR1 ;
+    physToGpio = physToGpioR1 ;
   }
-// Clock control (needed for PWM)
-
-  if ((clkMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
+  else                                         // A2, B2, A+, B+, CM, Pi2, Pi3, Zero
   {
-    if (wiringPiDebug)
-      fprintf (stderr, "wiringPiSetup: clkMem malloc failed: %s\n", strerror (errno)) ;
-    return -1 ;
+     pinToGpio =  pinToGpioR2 ;
+    physToGpio = physToGpioR2 ;
   }
 
-  if (((uint32_t)clkMem % PAGE_SIZE) != 0)
-    clkMem += PAGE_SIZE - ((uint32_t)clkMem % PAGE_SIZE) ;
+// ...
 
-  clk = (uint32_t *)mmap(clkMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, CLOCK_BASE) ;
-
-  if ((int32_t)clk < 0)
+  switch (model)
   {
-    if (wiringPiDebug)
-      fprintf (stderr, "wiringPiSetup: mmap failed (clk): %s\n", strerror (errno)) ;
-    return -1 ;
+    case PI_MODEL_A:  case PI_MODEL_B:
+    case PI_MODEL_AP: case PI_MODEL_BP:
+    case PI_ALPHA:    case PI_MODEL_CM: case PI_MODEL_ZERO:
+      piGpioBase = GPIO_PERI_BASE_OLD ;
+      break ;
+
+    default:
+      piGpioBase = GPIO_PERI_BASE_NEW ;
+      break ;
   }
-// The drive pads
 
-  if ((padsMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
+// Open the master /dev/ memory control device
+// Device strategy: December 2016:
+//     Try /dev/mem. If that fails, then 
+//     try /dev/gpiomem. If that fails then game over.
+
+  if ((fd = open ("/dev/mem", O_RDWR | O_SYNC | O_CLOEXEC) ) < 0)
   {
-    if (wiringPiDebug)
-      fprintf (stderr, "wiringPiSetup: padsMem malloc failed: %s\n", strerror (errno)) ;
-    return -1 ;
+    if ((fd = open ("/dev/gpiomem", O_RDWR | O_SYNC | O_CLOEXEC) ) < 0)
+      return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: Unable to open /dev/mem or /dev/gpiomem: %s.\n  Try running with sudo?\n", strerror (errno)) ;
+    piGpioBase = 0 ;
   }
 
-  if (((uint32_t)padsMem % PAGE_SIZE) != 0)
-    padsMem += PAGE_SIZE - ((uint32_t)padsMem % PAGE_SIZE) ;
+// Set the offsets into the memory interface.
 
-  pads = (uint32_t *)mmap(padsMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_PADS) ;
+  GPIO_PADS      = piGpioBase + 0x00100000 ;
+  GPIO_CLOCK_BASE = piGpioBase + 0x00101000 ;
+  GPIO_BASE      = piGpioBase + 0x00200000 ;
+  GPIO_TIMER     = piGpioBase + 0x0000B000 ;
+  GPIO_PWM       = piGpioBase + 0x0020C000 ;
 
-  if ((int32_t)pads < 0)
-  {
-    if (wiringPiDebug)
-      fprintf (stderr, "wiringPiSetup: mmap failed (pads): %s\n", strerror (errno)) ;
-    return -1 ;
-  }
+// Map the individual hardware components
 
-#ifdef DEBUG_PADS
-  printf ("Checking pads @ 0x%08X\n", (unsigned int)pads) ;
-  printf (" -> %08X %08X %08X\n", *(pads + 11), *(pads + 12), *(pads + 13)) ;
-#endif
+//     GPIO:
 
-// The system timer
+  gpio = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_BASE) ;
+  if (gpio == MAP_FAILED)
+    return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (GPIO) failed: %s\n", strerror (errno)) ;
 
-  if ((timerMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
-  {
-    if (wiringPiDebug)
-      fprintf (stderr, "wiringPiSetup: timerMem malloc failed: %s\n", strerror (errno)) ;
-    return -1 ;
-  }
+//     PWM
 
-  if (((uint32_t)timerMem % PAGE_SIZE) != 0)
-    timerMem += PAGE_SIZE - ((uint32_t)timerMem % PAGE_SIZE) ;
+  pwm = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PWM) ;
+  if (pwm == MAP_FAILED)
+    return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (PWM) failed: %s\n", strerror (errno)) ;
+//     Clock control (needed for PWM)
 
-  timer = (uint32_t *)mmap(timerMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_TIMER) ;
+  clk = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_CLOCK_BASE) ;
+  if (clk == MAP_FAILED)
+    return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (CLOCK) failed: %s\n", strerror (errno)) ;
+//     The drive pads
 
-  if ((int32_t)timer < 0)
-  {
-    if (wiringPiDebug)
-      fprintf (stderr, "wiringPiSetup: mmap failed (timer): %s\n", strerror (errno)) ;
-    return -1 ;
-  }
+  pads = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PADS) ;
+  if (pads == MAP_FAILED)
+    return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (PADS) failed: %s\n", strerror (errno)) ;
+
+#ifdef USE_TIMER
+//     The system timer
+
+  timer = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_TIMER) ;
+  if (timer == MAP_FAILED)
+    return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (TIMER) failed: %s\n", strerror (errno)) ;
 
 // Set the timer to free-running, 1MHz.
 //     0xF9 is 249, the timer divide is base clock / (divide+1)
@@ -1329,13 +2215,9 @@ int wiringPiSetup (void)
   *(timer + TIMER_CONTROL) = 0x0000280 ;
   *(timer + TIMER_PRE_DIV) = 0x00000F9 ;
   timerIrqRaw = timer + TIMER_IRQ_RAW ;
+#endif
 
-// Initialise our epoch for millis()
-
-  gettimeofday (&tv, NULL) ;
-  epoch = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
-
-  wiringPiMode = WPI_MODE_PINS ;
+  initialiseEpoch () ;
 
   return 0 ;
 }
@@ -1352,33 +2234,11 @@ int wiringPiSetup (void)
 
 int wiringPiSetupGpio (void)
 {
-  int x  ;
-
-  if (geteuid () != 0)
-  {
-    fprintf (stderr, "Must be root to call wiringPiSetupGpio(). (Did you forget sudo?)\n") ;
-    exit (EXIT_FAILURE) ;
-  }
-
-  if ((x = wiringPiSetup ()) < 0)
-    return x ;
+  (void)wiringPiSetup () ;
 
   if (wiringPiDebug)
     printf ("wiringPi: wiringPiSetupGpio called\n") ;
 
-            pinMode =           pinModeGpio ;
-    pullUpDnControl =   pullUpDnControlGpio ;
-       digitalWrite =      digitalWriteGpio ;
-   digitalWriteByte =  digitalWriteByteGpio ;
-           pwmWrite =          pwmWriteGpio ;
-        setPadDrive =       setPadDriveGpio ;
-        digitalRead =       digitalReadGpio ;
-   waitForInterrupt =  waitForInterruptGpio ;
-  delayMicroseconds = delayMicrosecondsWPi ;   // Same
-         pwmSetMode =        pwmSetModeWPi ;
-        pwmSetRange =       pwmSetRangeWPi ;
-        pwmSetClock =       pwmSetClockWPi ;
-
   wiringPiMode = WPI_MODE_GPIO ;
 
   return 0 ;
@@ -1386,6 +2246,28 @@ int wiringPiSetupGpio (void)
 
 
 /*
+ * wiringPiSetupPhys:
+ *     Must be called once at the start of your program execution.
+ *
+ * Phys setup: Initialises the system into Physical Pin mode and uses the
+ *     memory mapped hardware directly.
+ *********************************************************************************
+ */
+
+int wiringPiSetupPhys (void)
+{
+  (void)wiringPiSetup () ;
+
+  if (wiringPiDebug)
+    printf ("wiringPi: wiringPiSetupPhys called\n") ;
+
+  wiringPiMode = WPI_MODE_PHYS ;
+
+  return 0 ;
+}
+
+
+/*
  * wiringPiSetupSys:
  *     Must be called once at the start of your program execution.
  *
@@ -1396,36 +2278,39 @@ int wiringPiSetupGpio (void)
 
 int wiringPiSetupSys (void)
 {
-  int boardRev ;
   int pin ;
-  struct timeval tv ;
   char fName [128] ;
 
-  if (getenv ("WIRINGPI_DEBUG") != NULL)
+  static int alreadyDoneThis = FALSE ;
+
+// It's actually a fatal error to call any of the wiringPiSetup routines more than once,
+//     (you run out of file handles!) but I'm fed-up with the useless twats who email
+//     me bleating that there is a bug in my code, so screw-em.
+
+  if (alreadyDoneThis)
+    return 0 ;
+
+  alreadyDoneThis = TRUE ;
+
+  if (getenv (ENV_DEBUG) != NULL)
     wiringPiDebug = TRUE ;
 
+  if (getenv (ENV_CODES) != NULL)
+    wiringPiReturnCodes = TRUE ;
+
   if (wiringPiDebug)
     printf ("wiringPi: wiringPiSetupSys called\n") ;
 
-            pinMode =           pinModeSys ;
-    pullUpDnControl =   pullUpDnControlSys ;
-       digitalWrite =      digitalWriteSys ;
-   digitalWriteByte =  digitalWriteByteSys ;
-           pwmWrite =          pwmWriteSys ;
-        setPadDrive =       setPadDriveSys ;
-        digitalRead =       digitalReadSys ;
-   waitForInterrupt =  waitForInterruptSys ;
-  delayMicroseconds = delayMicrosecondsSys ;
-         pwmSetMode =        pwmSetModeSys ;
-        pwmSetRange =       pwmSetRangeSys ;
-        pwmSetClock =       pwmSetClockSys ;
-
-  boardRev = piBoardRev () ;
-
-  if (boardRev == 1)
-    pinToGpio = pinToGpioR1 ;
+  if (piGpioLayout () == 1)
+  {
+     pinToGpio =  pinToGpioR1 ;
+    physToGpio = physToGpioR1 ;
+  }
   else
-    pinToGpio = pinToGpioR2 ;
+  {
+     pinToGpio =  pinToGpioR2 ;
+    physToGpio = physToGpioR2 ;
+  }
 
 // Open and scan the directory, looking for exported GPIOs, and pre-open
 //     the 'value' interface to speed things up for later
@@ -1436,10 +2321,7 @@ int wiringPiSetupSys (void)
     sysFds [pin] = open (fName, O_RDWR) ;
   }
 
-// Initialise the epoch for mills() ...
-
-  gettimeofday (&tv, NULL) ;
-  epoch = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
+  initialiseEpoch () ;
 
   wiringPiMode = WPI_MODE_GPIO_SYS ;