Gordons Projects

--> Projects Top-Level GIT

Bumped the version to 2.40 - correctly this time, I hope.
[wiringPi] / wiringPi / wiringPi.c
index 32e5100..e018100 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * wiringPi:
  *     Arduino look-a-like Wiring library for the Raspberry Pi
- *     Copyright (c) 2012-2015 Gordon Henderson
+ *     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
 #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"
-
-#ifndef        TRUE
-#define        TRUE    (1==1)
-#define        FALSE   (1==2)
-#endif
+#include "../version.h"
 
 // Environment Variables
 
 #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)
+// Extend wiringPi with other pin-based devices and keep track of
+//     them in this structure
 
 struct wiringPiNodeStruct *wiringPiNodes = NULL ;
 
@@ -133,9 +128,8 @@ struct wiringPiNodeStruct *wiringPiNodes = NULL ;
 //     that I can find )-:
 //
 // Updates in September 2015 - all now static variables (and apologies for the caps)
-//     due to the Pi v2 and the new /dev/gpiomem interface
+//     due to the Pi v2, v3, etc. and the new /dev/gpiomem interface
 
-static volatile unsigned int RASPBERRY_PI_PERI_BASE ;
 static volatile unsigned int GPIO_PADS ;
 static volatile unsigned int GPIO_CLOCK_BASE ;
 static volatile unsigned int GPIO_BASE ;
@@ -201,43 +195,90 @@ 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!
 
-static int piModel2 = FALSE ;
+// piGpioBase:
+//     The base address of the GPIO memory mapped hardware IO
 
-const char *piModelNames [7] =
+#define        GPIO_PERI_BASE_OLD      0x20000000
+#define        GPIO_PERI_BASE_NEW      0x3F000000
+
+static volatile unsigned int piGpioBase = 0 ;
+
+const char *piModelNames [16] =
 {
-  "Unknown",
-  "Model A",
-  "Model B",
-  "Model B+",
-  "Compute Module",
-  "Model A+",
-  "Model 2",   // Quad Core
+  "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 [5] =
+const char *piRevisionNames [16] =
 {
-  "Unknown",
-  "1",
-  "1.1",
-  "1.2",
-  "2",
+  "00",
+  "01",
+  "02",
+  "03",
+  "04",
+  "05",
+  "06",
+  "07",
+  "08",
+  "09",
+  "10",
+  "11",
+  "12",
+  "13",
+  "14",
+  "15",
 } ;
 
-const char *piMakerNames [5] =
+const char *piMakerNames [16] =
 {
-  "Unknown",
-  "Egoman",
-  "Sony",
-  "Qusda",
-  "MBest",
+  "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
 
@@ -419,6 +460,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,
 } ;
 
 
@@ -610,91 +652,78 @@ int wiringPiFailure (int fatal, const char *message, ...)
 
 
 /*
- * piBoardRev:
+ * piGpioLayout:
  *     Return a number representing the hardware revision of the board.
+ *     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 ....
  *
- *     Revision 1 really means the early Model B's.
+ *     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+ ...
  *
- *     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 
- *     0002 - Model B,  Rev 1,   256MB, Egoman
- *     0003 - Model B,  Rev 1.1, 256MB, Egoman, Fuses/D14 removed.
- *     0004 - Model B,  Rev 2,   256MB, Sony
- *     0005 - Model B,  Rev 2,   256MB, Qisda
- *     0006 - Model B,  Rev 2,   256MB, Egoman
- *     0007 - Model A,  Rev 2,   256MB, Egoman
- *     0008 - Model A,  Rev 2,   256MB, Sony
- *     0009 - Model A,  Rev 2,   256MB, Qisda
- *     000d - Model B,  Rev 2,   512MB, Egoman
- *     000e - Model B,  Rev 2,   512MB, Sony
- *     000f - Model B,  Rev 2,   512MB, Qisda
- *     0010 - Model B+, Rev 1.2, 512MB, Sony
- *     0011 - Pi CM,    Rev 1.2, 512MB, Sony
- *     0012 - Model A+  Rev 1.2, 256MB, Sony
- *     0014 - Pi CM,    Rev 1.1, 512MB, Sony (Actual Revision might be different)
- *     0015 - Model A+  Rev 1.1, 256MB, Sony
- *
- *     For the Pi 2:
- *     0010 - Model 2, Rev 1.1, Quad Core, 1GB, Sony
- *
- *     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.
  *
- *     The Pi compute module has an revision of 0011 - 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 the next rev of the CN is 0014 ...
+ *     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 (const 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 ;
-  static int  boardRev = -1 ;
+  static int  gpioLayout = -1 ;
 
-  if (boardRev != -1)  // No point checking twice
-    return boardRev ;
+  if (gpioLayout != -1)        // No point checking twice
+    return gpioLayout ;
 
   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
-    piBoardRevOops ("Unable to open /proc/cpuinfo") ;
+    piGpioLayoutOops ("Unable to open /proc/cpuinfo") ;
 
-// Start by looking for the Architecture, then we can look for a B2 revision....
+// 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)
-    piBoardRevOops ("No \"Hardware\" line") ;
+    piGpioLayoutOops ("No \"Hardware\" line") ;
 
   if (wiringPiDebug)
-    printf ("piboardRev: Hardware: %s\n", line) ;
+    printf ("piGpioLayout: Hardware: %s\n", line) ;
+
+// See if it's BCM2708 or BCM2709 or the new BCM2835.
 
-// See if it's BCM2708 or BCM2709
+// 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, "BCM2709") != NULL)
-    piModel2 = TRUE ;
-  else if (strstr (line, "BCM2708") == NULL)
+  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 or BCM2709.\n") ;
+    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") ;
@@ -702,10 +731,15 @@ int piBoardRev (void)
     exit (EXIT_FAILURE) ;
   }
 
-// Now do the rest of it as before
+// 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.
 
-  rewind (cpuFd) ;
+// Isolate the Revision line
 
+  rewind (cpuFd) ;
   while (fgets (line, 120, cpuFd) != NULL)
     if (strncmp (line, "Revision", 8) == 0)
       break ;
@@ -713,7 +747,7 @@ int piBoardRev (void)
   fclose (cpuFd) ;
 
   if (strncmp (line, "Revision", 8) != 0)
-    piBoardRevOops ("No \"Revision\" line") ;
+    piGpioLayoutOops ("No \"Revision\" line") ;
 
 // Chomp trailing CR/NL
 
@@ -721,58 +755,119 @@ int piBoardRev (void)
     *c = 0 ;
   
   if (wiringPiDebug)
-    printf ("piboardRev: Revision string: %s\n", line) ;
+    printf ("piGpioLayout: Revision string: %s\n", line) ;
 
-// Scan to first digit
+// 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)") ;
+
+// Chomp spaces
+
+  ++c ;
+  while (isspace (*c))
+    ++c ;
+
+  if (!isxdigit (*c))
+    piGpioLayoutOops ("Bogus \"Revision\" line (no hex digit at start of revision)") ;
 
 // Make sure its long enough
 
   if (strlen (c) < 4)
-    piBoardRevOops ("Bogus \"Revision\" line (too small)") ;
-  
-// If you have overvolted the Pi, then it appears that the revision
-//     has 100000 added to it!
-// The actual condition for it being set is:
-//      (force_turbo || current_limit_override || temp_limit>85) && over_voltage>0
-
-  if (wiringPiDebug)
-    if (strlen (c) != 4)
-      printf ("piboardRev: This Pi has/is (force_turbo || current_limit_override || temp_limit>85) && over_voltage>0\n") ;
+    piGpioLayoutOops ("Bogus revision line (too small)") ;
 
-// Isolate  last 4 characters:
+// Isolate  last 4 characters: (in-case of overvolting or new encoding scheme)
 
   c = c + strlen (c) - 4 ;
 
   if (wiringPiDebug)
-    printf ("piboardRev: last4Chars are: \"%s\"\n", c) ;
+    printf ("piGpioLayout: last4Chars are: \"%s\"\n", c) ;
 
   if ( (strcmp (c, "0002") == 0) || (strcmp (c, "0003") == 0))
-    boardRev = 1 ;
+    gpioLayout = 1 ;
   else
-    boardRev = 2 ;     // Covers everything else from the B revision 2 to the B+, the Pi v2 and CM's.
+    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 () ;
 }
 
 
+
 /*
  * piBoardId:
- *     Do more digging into the board revision string as above, but return
- *     as much details as we can.
+ *     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!
  *
- * for Pi v2:
+ *     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
@@ -783,19 +878,21 @@ int piBoardRev (void)
  *********************************************************************************
  */
 
-void piBoardId (int *model, int *rev, int *mem, int *maker, int *overVolted)
+void piBoardId (int *model, int *rev, int *mem, int *maker, int *warranty)
 {
   FILE *cpuFd ;
   char line [120] ;
   char *c ;
+  unsigned int revision ;
+  int bRev, bType, bProc, bMfg, bMem, bWarranty ;
 
 //     Will deal with the properly later on - for now, lets just get it going...
 //  unsigned int modelNum ;
 
-  (void)piBoardRev () ;        // Call this first to make sure all's OK. Don't care about the result.
+  (void)piGpioLayout () ;      // Call this first to make sure all's OK. Don't care about the result.
 
   if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
-    piBoardRevOops ("Unable to open /proc/cpuinfo") ;
+    piGpioLayoutOops ("Unable to open /proc/cpuinfo") ;
 
   while (fgets (line, 120, cpuFd) != NULL)
     if (strncmp (line, "Revision", 8) == 0)
@@ -804,7 +901,7 @@ void piBoardId (int *model, int *rev, int *mem, int *maker, int *overVolted)
   fclose (cpuFd) ;
 
   if (strncmp (line, "Revision", 8) != 0)
-    piBoardRevOops ("No \"Revision\" line") ;
+    piGpioLayoutOops ("No \"Revision\" line") ;
 
 // Chomp trailing CR/NL
 
@@ -812,44 +909,70 @@ void piBoardId (int *model, int *rev, int *mem, int *maker, int *overVolted)
     *c = 0 ;
   
   if (wiringPiDebug)
-    printf ("piboardId: Revision string: %s\n", line) ;
+    printf ("piBoardId: Revision string: %s\n", line) ;
 
-  if (piModel2)
-  {
+// Need to work out if it's using the new or old encoding scheme:
 
-// Scan to the colon
+// Scan to the first character of the revision number
+
+  for (c = line ; *c ; ++c)
+    if (*c == ':')
+      break ;
 
-    for (c = line ; *c ; ++c)
-      if (*c == ':')
-       break ;
+  if (*c != ':')
+    piGpioLayoutOops ("Bogus \"Revision\" line (no colon)") ;
 
-    if (*c != ':')
-      piBoardRevOops ("Bogus \"Revision\" line (no colon)") ;
+// Chomp spaces
 
-//    modelNum = (unsigned int)strtol (++c, NULL, 16) ; // Hex number with no leading 0x
+  ++c ;
+  while (isspace (*c))
+    ++c ;
+
+  if (!isxdigit (*c))
+    piGpioLayoutOops ("Bogus \"Revision\" line (no hex digit at start of revision)") ;
+
+  revision = (unsigned int)strtol (c, NULL, 16) ; // Hex number with no leading 0x
+
+// Check for new way:
+
+  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 = PI_MODEL_2  ;
-    *rev   = PI_VERSION_1_1 ;
-    *mem   = 1024 ;
-    *maker = PI_MAKER_SONY   ;
+    *model    = bType ;
+    *rev      = bRev ;
+    *mem      = bMem ;
+    *maker    = bMfg  ;
+    *warranty = bWarranty ;
+
+    if (wiringPiDebug)
+      printf ("piBoardId: rev: %d, type: %d, proc: %d, mfg: %d, mem: %d, warranty: %d\n",
+               bRev, bType, bProc, bMfg, bMem, bWarranty) ;
   }
-  else
+  else                                 // Old way
   {
+    if (wiringPiDebug)
+      printf ("piBoardId: Old Way: revision is: %s\n", c) ;
 
-// Scan to first digit
-
-    for (c = line ; *c ; ++c)
-      if (isdigit (*c))
-       break ;
+    if (!isdigit (*c))
+      piGpioLayoutOops ("Bogus \"Revision\" line (no digit at start of revision)") ;
 
 // Make sure its long enough
 
     if (strlen (c) < 4)
-      piBoardRevOops ("Bogus \"Revision\" line (not long enough)") ;
+      piGpioLayoutOops ("Bogus \"Revision\" line (not long enough)") ;
 
 // If longer than 4, we'll assume it's been overvolted
 
-    *overVolted = strlen (c) > 4 ;
+    *warranty = strlen (c) > 4 ;
   
 // Extract last 4 characters:
 
@@ -857,23 +980,36 @@ void piBoardId (int *model, int *rev, int *mem, int *maker, int *overVolted)
 
 // Fill out the replys as appropriate
 
-    /**/ if (strcmp (c, "0002") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1   ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
-    else if (strcmp (c, "0003") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_1_1 ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
-    else if (strcmp (c, "0004") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_SONY   ; }
-    else if (strcmp (c, "0005") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_QISDA  ; }
-    else if (strcmp (c, "0006") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
-    else if (strcmp (c, "0007") == 0) { *model = PI_MODEL_A  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
-    else if (strcmp (c, "0008") == 0) { *model = PI_MODEL_A  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_SONY ; ; }
-    else if (strcmp (c, "0009") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 256 ; *maker = PI_MAKER_QISDA  ; }
-    else if (strcmp (c, "000d") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 512 ; *maker = PI_MAKER_EGOMAN ; }
-    else if (strcmp (c, "000e") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 512 ; *maker = PI_MAKER_SONY   ; }
-    else if (strcmp (c, "000f") == 0) { *model = PI_MODEL_B  ; *rev = PI_VERSION_2   ; *mem = 512 ; *maker = PI_MAKER_EGOMAN ; }
-    else if (strcmp (c, "0010") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 512 ; *maker = PI_MAKER_SONY   ; }
-    else if (strcmp (c, "0011") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_2 ; *mem = 512 ; *maker = PI_MAKER_SONY   ; }
-    else if (strcmp (c, "0012") == 0) { *model = PI_MODEL_AP ; *rev = PI_VERSION_1_2 ; *mem = 256 ; *maker = PI_MAKER_SONY   ; }
-    else if (strcmp (c, "0013") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 512 ; *maker = PI_MAKER_MBEST  ; }
-    else if (strcmp (c, "0014") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_2 ; *mem = 512 ; *maker = PI_MAKER_SONY   ; }
-    else if (strcmp (c, "0015") == 0) { *model = PI_MODEL_AP ; *rev = PI_VERSION_1_1 ; *mem = 256 ; *maker = PI_MAKER_SONY   ; }
+    /**/ 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 ;               }
   }
 }
@@ -918,9 +1054,6 @@ void setPadDrive (int group, int value)
 
   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
   {
-    if (RASPBERRY_PI_PERI_BASE == 0)   // Ignore for now
-      return ;
-
     if ((group < 0) || (group > 2))
       return ;
 
@@ -994,9 +1127,6 @@ void pwmSetRange (unsigned int range)
 {
   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
   {
-    if (RASPBERRY_PI_PERI_BASE == 0)   // Ignore for now
-      return ;
-
     *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
     *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
   }
@@ -1018,9 +1148,6 @@ void pwmSetClock (int divisor)
 
   if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
   {
-    if (RASPBERRY_PI_PERI_BASE == 0)   // Ignore for now
-      return ;
-
     if (wiringPiDebug)
       printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
 
@@ -1073,9 +1200,6 @@ void gpioClockSet (int pin, int freq)
   else if (wiringPiMode != WPI_MODE_GPIO)
     return ;
   
-  if (RASPBERRY_PI_PERI_BASE == 0)     // Ignore for now
-    return ;
-
   divi = 19200000 / freq ;
   divr = 19200000 % freq ;
   divf = (int)((double)divr * 4096.0 / 19200000.0) ;
@@ -1118,13 +1242,15 @@ struct wiringPiNodeStruct *wiringPiFindNode (int pin)
  *********************************************************************************
  */
 
-static void pinModeDummy             (struct wiringPiNodeStruct *node, int pin, int mode)  { return ; }
-static void pullUpDnControlDummy     (struct wiringPiNodeStruct *node, int pin, int pud)   { return ; }
-static int  digitalReadDummy         (struct wiringPiNodeStruct *node, int pin)            { return LOW ; }
-static void digitalWriteDummy        (struct wiringPiNodeStruct *node, int pin, int value) { return ; }
-static void pwmWriteDummy            (struct wiringPiNodeStruct *node, int pin, int value) { return ; }
-static int  analogReadDummy          (struct wiringPiNodeStruct *node, int pin)            { return 0 ; }
-static void analogWriteDummy         (struct wiringPiNodeStruct *node, int pin, int value) { return ; }
+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 unsigned int digitalRead8Dummy        (UNU struct wiringPiNodeStruct *node, UNU int UNU pin)            { return 0 ; }
+static         void digitalWrite8Dummy       (UNU struct wiringPiNodeStruct *node, UNU int pin, UNU int value) { 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)
 {
@@ -1146,17 +1272,19 @@ struct wiringPiNodeStruct *wiringPiNewNode (int pinBase, int numPins)
   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 ;
+  node->pinBase          = pinBase ;
+  node->pinMax           = pinBase + numPins - 1 ;
+  node->pinMode          = pinModeDummy ;
+  node->pullUpDnControl  = pullUpDnControlDummy ;
+  node->digitalRead      = digitalReadDummy ;
+//node->digitalRead8     = digitalRead8Dummy ;
+  node->digitalWrite     = digitalWriteDummy ;
+//node->digitalWrite8    = digitalWrite8Dummy ;
+  node->pwmWrite         = pwmWriteDummy ;
+  node->analogRead       = analogReadDummy ;
+  node->analogWrite      = analogWriteDummy ;
+  node->next             = wiringPiNodes ;
+  wiringPiNodes          = node ;
 
   return node ;
 }
@@ -1248,17 +1376,11 @@ void pinMode (int pin, int mode)
       softToneCreate (origPin) ;
     else if (mode == PWM_TONE_OUTPUT)
     {
-      if (RASPBERRY_PI_PERI_BASE == 0) // Ignore for now
-       return ;
-
       pinMode (origPin, PWM_OUTPUT) ;  // Call myself to enable PWM mode
       pwmSetMode (PWM_MODE_MS) ;
     }
     else if (mode == PWM_OUTPUT)
     {
-      if (RASPBERRY_PI_PERI_BASE == 0) // Ignore for now
-       return ;
-
       if ((alt = gpioToPwmALT [pin]) == 0)     // Not a hardware capable PWM pin
        return ;
 
@@ -1273,9 +1395,6 @@ void pinMode (int pin, int mode)
     }
     else if (mode == GPIO_CLOCK)
     {
-      if (RASPBERRY_PI_PERI_BASE == 0) // Ignore for now
-       return ;
-
       if ((alt = gpioToGpClkALT0 [pin]) == 0)  // Not a GPIO_CLOCK pin
        return ;
 
@@ -1376,6 +1495,27 @@ int digitalRead (int pin)
 
 
 /*
+ * digitalRead8:
+ *     Read 8-bits (a byte) from given start pin.
+ *********************************************************************************
+
+unsigned int digitalRead8 (int pin)
+{
+  struct wiringPiNodeStruct *node = wiringPiNodes ;
+
+  if ((pin & PI_GPIO_MASK) == 0)               // On-Board Pin
+    return 0 ;
+  else
+  {
+    if ((node = wiringPiFindNode (pin)) == NULL)
+      return LOW ;
+    return node->digitalRead8 (node, pin) ;
+  }
+}
+ */
+
+
+/*
  * digitalWrite:
  *     Set an output bit
  *********************************************************************************
@@ -1419,6 +1559,26 @@ void digitalWrite (int pin, int value)
 
 
 /*
+ * digitalWrite8:
+ *     Set an output 8-bit byte on the device from the given pin number
+ *********************************************************************************
+
+void digitalWrite8 (int pin, int value)
+{
+  struct wiringPiNodeStruct *node = wiringPiNodes ;
+
+  if ((pin & PI_GPIO_MASK) == 0)               // On-Board Pin
+    return ;
+  else
+  {
+    if ((node = wiringPiFindNode (pin)) != NULL)
+      node->digitalWrite8 (node, pin, value) ;
+  }
+}
+ */
+
+
+/*
  * pwmWrite:
  *     Set an output PWM value
  *********************************************************************************
@@ -1430,9 +1590,6 @@ void pwmWrite (int pin, int value)
 
   if ((pin & PI_GPIO_MASK) == 0)               // On-Board Pin
   {
-    if (RASPBERRY_PI_PERI_BASE == 0)   // Ignore for now
-      return ;
-
     /**/ if (wiringPiMode == WPI_MODE_PINS)
       pin = pinToGpio [pin] ;
     else if (wiringPiMode == WPI_MODE_PHYS)
@@ -1499,9 +1656,6 @@ void pwmToneWrite (int pin, int freq)
 {
   int range ;
 
-  if (RASPBERRY_PI_PERI_BASE == 0)     // Ignore for now
-    return ;
-
   if (freq == 0)
     pwmWrite (pin, 0) ;             // Off
   else
@@ -1516,16 +1670,21 @@ void pwmToneWrite (int pin, int freq)
 
 /*
  * 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
  *********************************************************************************
  */
 
-void digitalWriteByte (int value)
+void digitalWriteByte (const int value)
 {
   uint32_t pinSet = 0 ;
   uint32_t pinClr = 0 ;
@@ -1536,7 +1695,7 @@ void digitalWriteByte (int value)
   {
     for (pin = 0 ; pin < 8 ; ++pin)
     {
-      digitalWrite (pin, value & mask) ;
+      digitalWrite (pinToGpio [pin], value & mask) ;
       mask <<= 1 ;
     }
     return ;
@@ -1558,6 +1717,83 @@ void digitalWriteByte (int value)
   }
 }
 
+unsigned int digitalReadByte (void)
+{
+  int pin, x ;
+  uint32_t raw ;
+  uint32_t data = 0 ;
+
+  /**/ 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 ;
+}
+
+
+/*
+ * 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 digitalWriteByte2 (const int value)
+{
+  register int mask = 1 ;
+  register int pin ;
+
+  /**/ 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 ;
+  }
+}
+
+unsigned int digitalReadByte2 (void)
+{
+  int pin, x ;
+  uint32_t data = 0 ;
+
+  /**/ 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:
@@ -1586,18 +1822,20 @@ int waitForInterrupt (int pin, int mS)
 // Setup poll structure
 
   polls.fd     = fd ;
-  polls.events = POLLPRI ;     // Urgent data!
+  polls.events = POLLPRI | POLLERR ;
 
 // Wait for it ...
 
   x = poll (&polls, 1, mS) ;
 
-// Do a dummy read to clear the interrupt
+// If no error, do a dummy read to clear the interrupt
 //     A one character read appars to be enough.
-//     Followed by a seek to reset it.
 
-  (void)read (fd, &c, 1) ;
-  lseek (fd, 0, SEEK_SET) ;
+  if (x > 0)
+  {
+    lseek (fd, 0, SEEK_SET) ;  // Rewind
+    (void)read (fd, &c, 1) ;   // Read & clear
+  }
 
   return x ;
 }
@@ -1611,7 +1849,7 @@ int waitForInterrupt (int pin, int mS)
  *********************************************************************************
  */
 
-static void *interruptHandler (void *arg)
+static void *interruptHandler (UNU void *arg)
 {
   int myPin ;
 
@@ -1736,11 +1974,19 @@ int wiringPiISR (int pin, int mode, void (*function)(void))
 
 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
 }
 
 
@@ -1814,17 +2060,27 @@ void delayMicroseconds (unsigned int howLong)
 /*
  * millis:
  *     Return a number of milliseconds as an unsigned int.
+ *     Wraps at 49 days.
  *********************************************************************************
  */
 
 unsigned int millis (void)
 {
-  struct timeval tv ;
   uint64_t now ;
 
+#ifdef OLD_WAY
+  struct timeval tv ;
+
   gettimeofday (&tv, NULL) ;
   now  = (uint64_t)tv.tv_sec * (uint64_t)1000 + (uint64_t)(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)(now - epochMilli) ;
 }
 
@@ -1832,20 +2088,41 @@ unsigned int millis (void)
 /*
  * micros:
  *     Return a number of microseconds as an unsigned int.
+ *     Wraps after 71 minutes.
  *********************************************************************************
  */
 
 unsigned int micros (void)
 {
-  struct timeval tv ;
   uint64_t now ;
+#ifdef OLD_WAY
+  struct timeval tv ;
 
   gettimeofday (&tv, NULL) ;
   now  = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)tv.tv_usec ;
+#else
+  struct  timespec ts ;
+
+  clock_gettime (CLOCK_MONOTONIC_RAW, &ts) ;
+  now  = (uint64_t)ts.tv_sec * (uint64_t)1000000 + (uint64_t)(ts.tv_nsec / 1000) ;
+#endif
+
 
   return (uint32_t)(now - epochMicro) ;
 }
 
+/*
+ * wiringPiVersion:
+ *     Return our current version number
+ *********************************************************************************
+ */
+
+void wiringPiVersion (int *major, int *minor)
+{
+  *major = VERSION_MAJOR ;
+  *minor = VERSION_MINOR ;
+}
+
 
 /*
  * wiringPiSetup:
@@ -1861,8 +2138,17 @@ unsigned int micros (void)
 int wiringPiSetup (void)
 {
   int   fd ;
-  int   boardRev ;
   int   model, rev, mem, maker, overVolted ;
+  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 ;
@@ -1870,99 +2156,99 @@ int wiringPiSetup (void)
   if (getenv (ENV_CODES) != NULL)
     wiringPiReturnCodes = TRUE ;
 
-  if (getenv (ENV_GPIOMEM) != NULL)
-    wiringPiTryGpioMem = TRUE ;
-
   if (wiringPiDebug)
-  {
     printf ("wiringPi: wiringPiSetup called\n") ;
-    if (wiringPiTryGpioMem)
-      printf ("wiringPi: Using /dev/gpiomem\n") ;
-  }
 
-  boardRev = piBoardRev () ;
+// 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 (boardRev == 1)      // A, B, Rev 1, 1.1
+  piBoardId (&model, &rev, &mem, &maker, &overVolted) ;
+
+  if ((model == PI_MODEL_CM) || (model == PI_MODEL_CM3))
+    wiringPiMode = WPI_MODE_GPIO ;
+  else
+    wiringPiMode = WPI_MODE_PINS ;
+
+  /**/ if (piGpioLayout () == 1)       // A, B, Rev 1, 1.1
   {
      pinToGpio =  pinToGpioR1 ;
     physToGpio = physToGpioR1 ;
   }
-  else                                 // A, B, Rev 2, B+, CM, Pi2
+  else                                         // A2, B2, A+, B+, CM, Pi2, Pi3, Zero
   {
      pinToGpio =  pinToGpioR2 ;
     physToGpio = physToGpioR2 ;
   }
 
-  if (piModel2)
-    RASPBERRY_PI_PERI_BASE = 0x3F000000 ;
-  else
-    RASPBERRY_PI_PERI_BASE = 0x20000000 ;
-
-// Open the master /dev/ memory control device
-
-//     See if /dev/gpiomem exists and we can open it...
+// ...
 
-  if (wiringPiTryGpioMem)
+  switch (model)
   {
-    if ((fd = open ("/dev/gpiomem", O_RDWR | O_SYNC | O_CLOEXEC) ) < 0)
-      return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: Unable to open /dev/gpiomem: %s\n", strerror (errno)) ;
-    RASPBERRY_PI_PERI_BASE = 0 ;
+    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 ;
   }
 
-//     ... otherwise fall back to the original /dev/mem which requires root level access
+// 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.
 
-  else
+  if ((fd = open ("/dev/mem", O_RDWR | O_SYNC | O_CLOEXEC) ) < 0)
   {
-
-//     This check is here because people are too stupid to check for themselves or read
-//             error messages.
-
-    if (geteuid () != 0)
-      (void)wiringPiFailure (WPI_FATAL, "wiringPiSetup: Must be root. (Did you forget sudo?)\n") ;
-
-    if ((fd = open ("/dev/mem", O_RDWR | O_SYNC | O_CLOEXEC) ) < 0)
-      return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: Unable to open /dev/mem: %s\n", strerror (errno)) ;
+    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 ;
   }
 
 // Set the offsets into the memory interface.
 
-  GPIO_PADS      = RASPBERRY_PI_PERI_BASE + 0x00100000 ;
-  GPIO_CLOCK_BASE = RASPBERRY_PI_PERI_BASE + 0x00101000 ;
-  GPIO_BASE      = RASPBERRY_PI_PERI_BASE + 0x00200000 ;
-  GPIO_TIMER     = RASPBERRY_PI_PERI_BASE + 0x0000B000 ;
-  GPIO_PWM       = RASPBERRY_PI_PERI_BASE + 0x0020C000 ;
+  GPIO_PADS      = piGpioBase + 0x00100000 ;
+  GPIO_CLOCK_BASE = piGpioBase + 0x00101000 ;
+  GPIO_BASE      = piGpioBase + 0x00200000 ;
+  GPIO_TIMER     = piGpioBase + 0x0000B000 ;
+  GPIO_PWM       = piGpioBase + 0x0020C000 ;
 
 // Map the individual hardware components
 
 //     GPIO:
 
   gpio = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_BASE) ;
-  if ((int32_t)gpio == -1)
+  if (gpio == MAP_FAILED)
     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (GPIO) failed: %s\n", strerror (errno)) ;
 
 //     PWM
 
   pwm = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PWM) ;
-  if ((int32_t)pwm == -1)
+  if (pwm == MAP_FAILED)
     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (PWM) failed: %s\n", strerror (errno)) ;
  
 //     Clock control (needed for PWM)
 
   clk = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_CLOCK_BASE) ;
-  if ((int32_t)clk == -1)
+  if (clk == MAP_FAILED)
     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (CLOCK) failed: %s\n", strerror (errno)) ;
  
 //     The drive pads
 
   pads = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PADS) ;
-  if ((int32_t)pads == -1)
+  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 ((int32_t)timer == -1)
+  if (timer == MAP_FAILED)
     return wiringPiFailure (WPI_ALMOST, "wiringPiSetup: mmap (TIMER) failed: %s\n", strerror (errno)) ;
 
 // Set the timer to free-running, 1MHz.
@@ -1976,14 +2262,6 @@ int wiringPiSetup (void)
 
   initialiseEpoch () ;
 
-// If we're running on a compute module, then wiringPi pin numbers don't really many anything...
-
-  piBoardId (&model, &rev, &mem, &maker, &overVolted) ;
-  if (model == PI_MODEL_CM)
-    wiringPiMode = WPI_MODE_GPIO ;
-  else
-    wiringPiMode = WPI_MODE_PINS ;
-
   return 0 ;
 }
 
@@ -2043,10 +2321,20 @@ int wiringPiSetupPhys (void)
 
 int wiringPiSetupSys (void)
 {
-  int boardRev ;
   int pin ;
   char fName [128] ;
 
+  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 ;
 
@@ -2056,9 +2344,7 @@ int wiringPiSetupSys (void)
   if (wiringPiDebug)
     printf ("wiringPi: wiringPiSetupSys called\n") ;
 
-  boardRev = piBoardRev () ;
-
-  if (boardRev == 1)
+  if (piGpioLayout () == 1)
   {
      pinToGpio =  pinToGpioR1 ;
     physToGpio = physToGpioR1 ;