WiringPi/wiringPi/wiringPi.c

/*
 * wiringPi:
 *  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
 *  BCM2835 ARM Peripherals manual, however it's missing
 *  the clock section /grr/mutter/
 ***********************************************************************
 * This file is part of wiringPi:
 *    https://github.com/nuncio-bitis/WiringPi
 *
 *    wiringPi is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU Lesser General Public License as
 *    published by the Free Software Foundation, either version 3 of the
 *    License, or (at your option) any later version.
 *
 *    wiringPi is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with wiringPi.
 *    If not, see <http://www.gnu.org/licenses/>.
 ***********************************************************************
 */

// Revisions:
// 08 March 2022:
//  Updates to revisioning from https://www.raspberrypi.com/documentation/computers/raspberry-pi.html#new-style-revision-codes-in-use
//
// 19 Jul 2012:
// 	Moved to the LGPL
// 	Added an abstraction layer to the main routines to save a tiny
// 	bit of run-time and make the clode a little cleaner (if a little
// 	larger)
// 	Added waitForInterrupt code
// 	Added piHiPri code
//
//  9 Jul 2012:
// 	Added in support to use the /sys/class/gpio interface.
//  2 Jul 2012:
// 	Fixed a few more bugs to do with range-checking when in GPIO mode.
// 11 Jun 2012:
// 	Fixed some typos.
// 	Added c++ support for the .h file
// 	Added a new function to allow for using my "pin" numbers, or native
// 		GPIO pin numbers.
// 	Removed my busy-loop delay and replaced it with a call to delayMicroseconds
//
// 02 May 2012:
// 	Added in the 2 UART pins
// 	Change maxPins to numPins to more accurately reflect purpose


#include <stdio.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdlib.h>
#include <ctype.h>
#include <poll.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/time.h>
#include <sys/mman.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"

// Environment Variables
#define ENV_DEBUG    "WIRINGPI_DEBUG"
#define ENV_CODES    "WIRINGPI_CODES"


// Extend wiringPi with other pin-based devices and keep track of
// them in this structure
struct wiringPiNodeStruct *wiringPiNodes = NULL;

// BCM Magic
#define BCM_PASSWORD 0x5A000000

// Full revision string
static uint32_t fullRevision = 0;

// 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_ALT1 0b101
#define FSEL_ALT2 0b110
#define FSEL_ALT3 0b111
#define FSEL_ALT4 0b011
#define FSEL_ALT5 0b010

// Access from ARM Running Linux
// 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
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)

static unsigned int usingGpioMem    = FALSE;
static          int wiringPiSetuped = FALSE;

// PWM
// Word offsets into the PWM control region
#define PWM_CONTROL 0
#define PWM_STATUS  1
#define PWM0_RANGE  4
#define PWM0_DATA   5
#define PWM1_RANGE  8
#define PWM1_DATA   9

// Clock regsiter offsets
#define PWMCLK_CNTL	40
#define PWMCLK_DIV	41

#define PWM0_MS_MODE    0x0080  // Run in MS mode
#define PWM0_USEFIFO    0x0020  // Data from FIFO
#define PWM0_REVPOLAR   0x0010  // Reverse polarity
#define PWM0_OFFSTATE   0x0008  // Ouput Off state
#define PWM0_REPEATFF   0x0004  // Repeat last value if FIFO empty
#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)
#define TIMER_CONTROL  (0x408 >> 2)
#define TIMER_IRQ_CLR  (0x40C >> 2)
#define TIMER_IRQ_RAW  (0x410 >> 2)
#define TIMER_IRQ_MASK (0x414 >> 2)
#define TIMER_RELOAD   (0x418 >> 2)
#define TIMER_PRE_DIV  (0x41C >> 2)
#define TIMER_COUNTER  (0x420 >> 2)

// Locals to hold pointers to the hardware
static volatile unsigned int *gpio;
static volatile unsigned int *pwm;
static volatile unsigned int *clk;
static volatile unsigned int *pads;
static volatile unsigned int *timer;
static volatile unsigned int *timerIrqRaw;

// Export variables for the hardware pointers
volatile unsigned int *_wiringPiGpio;
volatile unsigned int *_wiringPiPwm;
volatile unsigned int *_wiringPiClk;
volatile unsigned int *_wiringPiPads;
volatile unsigned int *_wiringPiTimer;
volatile unsigned int *_wiringPiTimerIrqRaw;


// 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_2835 0x3F000000
#define GPIO_PERI_BASE_2711 0xFE000000

static volatile unsigned int piGpioBase = 0;

const char *piModelNames[21] =
{
  "Model A",    //  0
  "Model B",    //  1
  "Model A+",   //  2
  "Model B+",   //  3
  "Pi 2B",      //  4
  "Alpha",      //  5
  "CM1",        //  6
  "Unknown07",  //  7
  "Pi 3B",      //  8
  "Pi Zero",    //  9
  "CM3",        // 10
  "Unknown11",  // 11
  "Pi Zero-W",  // 12
  "Pi 3B+",     // 13
  "Pi 3A+",     // 14
  "Unknown15",  // 15
  "CM3+",       // 16
  "Pi 4B",      // 17
  "Pi Zero2-W", // 18
  "Pi 400",     // 19
  "CM4",        // 20
};

const char *piRevisionNames[5] =
{
  "1.0",
  "1.1",
  "1.2",
  "1.3",
  "1.4"
};

const char *piMakerNames[16] =
{
  "Sony",       //  0
  "Egoman",     //  1
  "Embest",     //  2
  "Sony Japan", //  3
  "Embest",     //  4
  "Stadium",    //  5
  "Unknown06",  //  6
  "Unknown07",  //  7
  "Unknown08",  //  8
  "Unknown09",  //  9
  "Unknown10",  // 10
  "Unknown11",  // 11
  "Unknown12",  // 12
  "Unknown13",  // 13
  "Unknown14",  // 14
  "Unknown15",  // 15
};

const char *piProcessorNames[5] =
{
  "BCM2835",
  "BCM2836",
  "BCM2837",
  "BCM2711",
  "Unknown"
};

// Memory sizes in MB
const char *piMemorySize[8] =
{
   "256MB", //  0
   "512MB", //  1
     "1GB", //  2
     "2GB", //  3
     "4GB", //  4
     "8GB", //  5
    "16GB", //  6
    "32GB", //  7
};

// Time for easy calculations
static uint64_t epochMilli, epochMicro;

// Misc
static int wiringPiMode = WPI_MODE_UNINITIALISED;
static volatile int    pinPass = -1;
static pthread_mutex_t pinMutex;

// Debugging & Return codes
// Intentionally global; also used in gpio.c
int wiringPiDebug       = FALSE;
int wiringPiReturnCodes = TRUE;

// Use /dev/gpiomem ?
int wiringPiTryGpioMem  = FALSE;

// sysFds:
// Map a file descriptor from the /sys/class/gpio/gpioX/value
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
static void (*isrFunctions[64])(int pin);


// Doing it the Arduino way with lookup tables...
// Yes, it's probably more innefficient than all the bit-twidling, but it
// does tend to make it all a bit clearer. At least to me!

// pinToGpio:
// Take a Wiring pin (0 through X) and re-map it to the BCM_GPIO pin
// Cope for 3 different board revisions here.
static int *pinToGpio;

// Index: WiringPi pin #
// Value @ index: BCM GPIO #
// Revision 1, 1.1:
static int pinToGpioR1[64] =
{
  // From the Original Wiki
  17, 18, 21, 22, 23, 24, 25, 4, // 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:
      -1, -1, -1, -1, -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
};

// Index: WiringPi pin #
// Value @ index: BCM GPIO #
// Revisions 2...:
static int pinToGpioR2[64] =
{
  // From the Original Wiki
  17, 18, 27, 22, 23, 24, 25, 4, // GPIO 0 through 7 : wpi  0 -  7
   2,  3,             // I2C  - SDA0, SCL0       : 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
  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, -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;
// Index: Physical pin #
// Value @ index: BCM GPIO #
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
};

// Index: Physical pin #
// Value @ index: BCM GPIO #
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, // 27, 28
   5, -1,
   6, 12,
  13, -1,
  19, 16,
  26, 20,
  -1, 21, // 39, 40

// 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 its Function Selection
// control port. (GPFSEL 0-5)
// Groups of 10 - 3 bits per Function - 30 bits per port
static uint8_t gpioToGPFSEL[] =
{
  0,0,0,0,0,0,0,0,0,0,
  1,1,1,1,1,1,1,1,1,1,
  2,2,2,2,2,2,2,2,2,2,
  3,3,3,3,3,3,3,3,3,3,
  4,4,4,4,4,4,4,4,4,4,
  5,5,5,5,5,5,5,5,5,5,
};


// gpioToShift
// Define the shift up for the 3 bits per pin in each GPFSEL port
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,
  0,3,6,9,12,15,18,21,24,27,
  0,3,6,9,12,15,18,21,24,27,
};


// gpioToGPSET:
// (Word) offset to the GPIO Set registers for each GPIO pin
static uint8_t gpioToGPSET[] =
{
   7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
   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
static uint8_t gpioToGPCLR[] =
{
  10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
  11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
};


// gpioToGPLEV:
// (Word) offset to the GPIO Input level registers for each GPIO pin
// This will handle banks 0 and 1 of GPIOs
static uint8_t gpioToGPLEV[] =
{
  13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13, // bank 0
  14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14, // bank 1
};


// GPPUD:
// GPIO Pin pull up/down register
#define GPPUD	37

/* 2711 has a different mechanism for pin pull-up/down/enable  */
#define GPPUPPDN0                57        /* Pin pull-up/down for pins 15:0  */
#define GPPUPPDN1                58        /* Pin pull-up/down for pins 31:16 */
#define GPPUPPDN2                59        /* Pin pull-up/down for pins 47:32 */
#define GPPUPPDN3                60        /* Pin pull-up/down for pins 57:48 */

static volatile unsigned int piGpioPupOffset = 0;

// 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,
  39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,
};


// gpioToPwmALT
// the ALT value to put a GPIO pin into PWM mode
static uint8_t gpioToPwmALT[] =
{
          0,         0,         0,         0,         0,         0,         0,         0, //  0 ->  7
          0,         0,         0,         0, FSEL_ALT0, FSEL_ALT0,         0,         0, //  8 -> 15
          0,         0, FSEL_ALT5, FSEL_ALT5,         0,         0,         0,         0, // 16 -> 23
          0,         0,         0,         0,         0,         0,         0,         0, // 24 -> 31
          0,         0,         0,         0,         0,         0,         0,         0, // 32 -> 39
  FSEL_ALT0, FSEL_ALT0,         0,         0,         0, FSEL_ALT0,         0,         0, // 40 -> 47
          0,         0,         0,         0,         0,         0,         0,         0, // 48 -> 55
          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
          0,         0,         0,         0, PWM0_DATA, PWM1_DATA,         0,         0, //  8 -> 15
          0,         0, PWM0_DATA, PWM1_DATA,         0,         0,         0,         0, // 16 -> 23
          0,         0,         0,         0,         0,         0,         0,         0, // 24 -> 31
          0,         0,         0,         0,         0,         0,         0,         0, // 32 -> 39
  PWM0_DATA, PWM1_DATA,         0,         0,         0, PWM1_DATA,         0,         0, // 40 -> 47
          0,         0,         0,         0,         0,         0,         0,         0, // 48 -> 55
          0,         0,         0,         0,         0,         0,         0,         0, // 56 -> 63

};

// 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 int 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 int 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
 *********************************************************************************
 */


/*
 * wiringPiFailure:
 *  Fail. Or not.
 *********************************************************************************
 */

int wiringPiFailure (int fatal, const char *message, ...)
{
  va_list argp;
  char buffer[1024];

  va_start (argp, message);
    vsnprintf (buffer, 1023, message, argp);
  va_end (argp);

  fprintf (stderr, "%s", buffer);

  if (!fatal && wiringPiReturnCodes)
    return -1;

  exit (EXIT_FAILURE);

  return 0;
}


/*
 * setupCheck
 *  Another sanity check because some users forget to call the setup
 *  function. Mosty because they need feeding C drip by drip )-:
 *********************************************************************************
 */

static void setupCheck (const char *fName)
{
  if (!wiringPiSetuped)
  {
    fprintf (stderr, "[FATAL] %s: You have not called one of the wiringPiSetup functions. Aborting.\n", fName);
    exit (EXIT_FAILURE);
  }
}

/*
 * gpioMemCheck:
 *  See if we're using the /dev/gpiomem interface, if-so then some operations
 *  can't be done and will crash the Pi.
 *********************************************************************************
 */

static void usingGpioMemCheck (const char *what)
{
  if (usingGpioMem)
  {
    fprintf (stderr, "[FATAL] %s: Unable to do this when using /dev/gpiomem. You need to use sudo\n", what);
    exit (EXIT_FAILURE);
  }
}



/*
 * 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 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+ ...
 *
 *  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 piGpioLayoutOops (const char *why)
{
  fprintf (stderr, "[FATAL] Unable to determine board revision from /proc/cpuinfo\n");
  fprintf (stderr, " -> %s\n", why);
  exit (EXIT_FAILURE);
}

int piGpioLayout (void)
{
  FILE *cpuFd;
  char line[120];
  char *c;
  static int gpioLayout = -1; // Set the first time this is called

  // If already set, just return the previously-found value.
  if (gpioLayout != -1)
    return gpioLayout;

  if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
    piGpioLayoutOops ("Unable to open /proc/cpuinfo");

  // --------------------------------------------
  // Get the model description
  while (fgets (line, 120, cpuFd) != NULL)
    if (strncmp (line, "Model", 5) == 0)
      break;

  if (strncmp (line, "Model", 5) != 0)
    piGpioLayoutOops ("No \"Model\" line");
  else
  {
    for (c = line; *c; ++c)
    {
      if (*c == ':') break;
    }
    ++c; // Skip colon
    // Skip space
    while ((*c == ' ') || (*c == '\t'))
    {
      ++c;
    }
    if (wiringPiDebug)
    {
      printf ("piGpioLayout: Model: %s", c);
    }
  }

  // --------------------------------------------
  // Get hardware architecture.
  rewind (cpuFd);
  while (fgets (line, 120, cpuFd) != NULL)
    if (strncmp (line, "Hardware", 8) == 0)
      break;

  if (strncmp (line, "Hardware", 8) != 0)
    piGpioLayoutOops ("No \"Hardware\" line");
  else
  {
    for (c = line; *c; ++c)
    {
      if (*c == ':') break;
    }
    ++c; // Skip colon
    // Skip space
    while ((*c == ' ') || (*c == '\t'))
    {
      ++c;
    }
    if (wiringPiDebug)
    {
      printf ("piGpioLayout: Hardware: %s", c);
    }
  }

  // --------------------------------------------
  // Get the Revision line
  rewind (cpuFd);
  while (fgets (line, 120, cpuFd) != NULL)
    if (strncmp (line, "Revision", 8) == 0)
      break;

  fclose (cpuFd);

  if (strncmp (line, "Revision", 8) != 0)
    piGpioLayoutOops ("No \"Revision\" line");

  // Chomp CR and/or LF
  for (c = line; *c; ++c)
  {
    if ((*c == '\n') || (*c == '\r'))
    {
      *c = 0;
    }
  }

  // Scan to the first character of the revision number
  for (c = line; *c; ++c)
  {
    if (*c == ':') break;
  }
  ++c; // Skip colon
  // Skip space
  while ((*c == ' ') || (*c == '\t'))
  {
    ++c;
  }
  if (wiringPiDebug)
  {
    printf ("piGpioLayout: Revision string: %s\n", c);
  }

  if (!isxdigit (*c))
    piGpioLayoutOops ("Bogus \"Revision\" line (no hex digit at start of revision)");

  // Make sure its long enough
  if (strlen (c) < 4)
    piGpioLayoutOops ("Bogus revision line (too small)");

  // Use last character for revision number
  char *rev = c + strlen (c) - 1;
  int revnum = atoi(rev);
  if (wiringPiDebug)
  {
    printf ("piGpioLayout: Revision number: 1.%d\n", revnum);
  }

  // Isolate  last 4 characters: (in-case of overvolting or new encoding scheme)
  c = c + strlen (c) - 4;
  if ( (strcmp (c, "0002") == 0) || (strcmp (c, "0003") == 0))
    gpioLayout = 1 ;
  else
    gpioLayout = 2 ;	// Covers everything else from the B revision 2 to the B+, the Pi v2, v3, zero and CM's.

  if (wiringPiDebug)
    printf ("piGpioLayout: Returning revision: %d\n", gpioLayout);

  // --------------------------------------------

  return gpioLayout;
}


/*
 * piBoardId:
 *  Return the real details of the board we have.
 *  See:
 *  https://www.raspberrypi.com/documentation/computers/raspberry-pi.html#new-style-revision-codes-in-use
 *
 *  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
 *
 *  Old-style revision codes
 *    Original Pi boards:
 *    0002 - Model B,  Rev 1.0, 256MB, Egoman
 *    0003 - Model B,  Rev 1.0, 256MB, Egoman, Fuses/D14 removed.
 *    Newer Pi's with remapped GPIO:
 *    0004 - Model B,  Rev 2.0, 256MB, Sony
 *    0005 - Model B,  Rev 2.0, 256MB, Qisda
 *    0006 - Model B,  Rev 2.0, 256MB, Egoman
 *    0007 - Model A,  Rev 2.0, 256MB, Egoman
 *    0008 - Model A,  Rev 2.0, 256MB, Sony
 *    0009 - Model A,  Rev 2.0, 256MB, Qisda
 *    000d - Model B,  Rev 2.0, 512MB, Egoman
 *    000e - Model B,  Rev 2.0, 512MB, Sony
 *    000f - Model B,  Rev 2.0, 512MB, Egoman
 *    0010 - Model B+, Rev 1.2, 512MB, Sony
 *    0011 - Pi CM,    Rev 1.0, 512MB, Sony
 *    0012 - Model A+  Rev 1.1, 256MB, Sony
 *    0013 - Model B+  Rev 1.2, 512MB, Embest
 *    0014 - Pi CM1,   Rev 1.0, 512MB, Embest
 *    0015 - Model A+  Rev 1.1, 256MB/512MB, Embest
 *
 *  A small thorn is the olde style overvolting - that will add in
 *    1000000
 *
 *  The Pi compute module one has a 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
 *********************************************************************************
 */

uint32_t piBoardId (int *model, int *proc, 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;

  (void)piGpioLayout();	// Call this first to make sure all's OK. Don't care about the result.

  if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
    piGpioLayoutOops ("Unable to open /proc/cpuinfo");

  while (fgets (line, 120, cpuFd) != NULL)
    if (strncmp (line, "Revision", 8) == 0)
      break;

  fclose (cpuFd);

  if (strncmp (line, "Revision", 8) != 0)
    piGpioLayoutOops ("No \"Revision\" line");

  // Chomp trailing CR/NL
  for (c = &line[strlen (line) - 1]; (*c == '\n') || (*c == '\r'); --c)
  {
    *c = 0;
  }

  if (wiringPiDebug)
    printf ("piBoardId: Revision string: %s\n", line);

  // Need to work out if it's using the new or old encoding scheme:
  // Scan to the first character of the revision number
  for (c = line; *c; ++c)
    if (*c == ':')
      break;

  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)");

  revision = (unsigned int)strtol (c, NULL, 16); // Hex number with no leading 0x
  // Save full revision number
  fullRevision = revision;

  // Check for new way: Bit 23 of the revision number
  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;
    bMfg      = (revision & (0x0F << 16)) >> 16;
    bMem      = (revision & (0x07 << 20)) >> 20;
    bWarranty = (revision & (0x03 << 24)) != 0;

    *model    = bType;
    *proc     = bProc;
    *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 // 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)");

    // Make sure its long enough
    if (strlen (c) < 4)
      piGpioLayoutOops ("Bogus \"Revision\" line (not long enough)");

    // If longer than 4, we'll assume it's been overvolted
    *warranty = strlen (c) > 4;

    // Extract last 4 characters:
    c = c + strlen (c) - 4;

    // Using the old way - the processor was always reported as BCM2835
    *proc = 0;

    // 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_CM1; *rev = PI_VERSION_1_1; *mem = 1; *maker = PI_MAKER_SONY   ; }
    else if (strcmp (c, "0014") == 0) { *model = PI_MODEL_CM1; *rev = PI_VERSION_1_1; *mem = 1; *maker = PI_MAKER_EMBEST ; }
    else if (strcmp (c, "0017") == 0) { *model = PI_MODEL_CM1; *rev = PI_VERSION_1_1; *mem = 1; *maker = PI_MAKER_SONY   ; }
    else if (strcmp (c, "001a") == 0) { *model = PI_MODEL_CM1; *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;               }
  }

  return fullRevision;
}



/*
 * wpiPinToGpio:
 *  Translate a wiringPi Pin number to native GPIO pin number.
 *  Provided for external support.
 *********************************************************************************
 */
int wpiPinToGpio (int wpiPin)
{
  return pinToGpio[wpiPin & 63];
}


/*
 * physPinToGpio:
 *  Translate a physical Pin number to native GPIO pin number.
 *  Provided for external support.
 *********************************************************************************
 */
int physPinToGpio (int physPin)
{
  return physToGpio[physPin & 63];
}


/*
 * setPadDrive:
 *  Set the PAD driver value
 *********************************************************************************
 */
void setPadDrive (int group, int value)
{
  uint32_t wrVal;

  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.
 *********************************************************************************
 */
void pwmSetClock (int divisor)
{
  uint32_t pwm_control;

  if (piGpioBase == GPIO_PERI_BASE_2711)
  {
    divisor = 540*divisor/192;
  }
  // Keep divisor in range.
  if (divisor > 4095)
  {
    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

    // We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY stays high.
    *(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
    // flag is not working properly in balanced mode. Without the delay when DIV is
    // 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

    while ((*(clk + PWMCLK_CNTL) & 0x80) != 0)	// Wait for clock to be !BUSY
      delayMicroseconds (1);

    *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12);

    *(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));
  }
}


/*
 * gpioClockSet:
 *  Set the frequency on a GPIO clock pin
 *********************************************************************************
 */
void gpioClockSet (int pin, int freq)
{
  int divi, divr, divf;
  int save = pin;

  // Only works on on-board pins
  if (pin > 63)
  {
      if (wiringPiDebug)
      {
        printf ("%s(%d)%s ERROR: Specified pin (%d) is not an on-board pin!\n",
            __FILE__, __LINE__, __FUNCTION__, pin);
      }
      return;
  }

  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;

  // Fail if the pin isn't a GPIO clock pin
  if ((gpioToClkCon[pin] == -1) || (gpioToClkDiv[pin] == -1))
  {
      if (wiringPiDebug)
      {
        printf ("%s(%d)%s ERROR: Specified pin (%d) is not a clock pin!\n",
            __FILE__, __LINE__, __FUNCTION__, save);
      }
      return;
  }

  *(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);

  // Allocate memory. NOTE: calloc clears the memory before giving it to you. Bonus!
  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;

  // Use dummy routines so as not to have NULL pointers.
  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;
}


/*
 *********************************************************************************
 * Core Functions
 *********************************************************************************
 */

/*
 * pinModeAlt:
 *  This is an un-documented special to let you set any pin to any mode
 *********************************************************************************
 */
void pinModeAlt (int pin, int mode)
{
  int fSel, shift;

  setupCheck ("pinModeAlt");

  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);
  }
}


/*
 * pinMode:
 *  Sets the mode of a pin to be input, output or PWM output
 *********************************************************************************
 */
void pinMode (int pin, int mode)
{
  int    fSel, shift, alt;
  struct wiringPiNodeStruct *node = wiringPiNodes;
  int origPin = pin;

  setupCheck ("pinMode");

  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;

      usingGpioMemCheck ("pinMode PWM");

      // 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;

      usingGpioMemCheck ("pinMode CLOCK");

      // 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
  {
    if ((node = wiringPiFindNode (pin)) != NULL)
      node->pinMode (node, pin, mode);
    return;
  }
}


/*
 * pullUpDownCtrl:
 *  Control the internal pull-up/down resistors on a GPIO pin.
 *********************************************************************************
 */
void pullUpDnControl (int pin, int pud)
{
  struct wiringPiNodeStruct *node = wiringPiNodes;

  setupCheck ("pullUpDnControl");

  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;

    if (piGpioPupOffset == GPPUPPDN0)
    {
      // Pi 4B pull up/down method
      int pullreg = GPPUPPDN0 + (pin>>4);
      int pullshift = (pin & 0xf) << 1;
      unsigned int pullbits;
      unsigned int pull;

      switch (pud)
      {
        case PUD_OFF:  pull = 0; break;
        case PUD_UP:   pull = 1; break;
        case PUD_DOWN: pull = 2; break;
        default: return; /* An illegal value */
      }

      pullbits = *(gpio + pullreg);
      pullbits &= ~(3 << pullshift);
      pullbits |= (pull << pullshift);
      *(gpio + pullreg) = pullbits;
    }
    else
    {
      // legacy pull up/down method
      *(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;
  }
}


/*
 * digitalRead:
 *  Read the value of a given Pin, returning HIGH or LOW
 *********************************************************************************
 */
int digitalRead (int pin)
{
  char c;
  struct wiringPiNodeStruct *node = wiringPiNodes;
  if ((pin & PI_GPIO_MASK) == 0)		// On-Board Pin
  {
    if (wiringPiMode == WPI_MODE_GPIO_SYS)	// Sys mode
    {
      if (sysFds[pin] == -1)
        return LOW;

      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 & 0x1F))) != 0)
      return HIGH;
    else
      return LOW;
  }
  else
  {
    if ((node = wiringPiFindNode (pin)) == NULL)
      return LOW;
    return node->digitalRead (node, pin);
  }
}

/*
 * digitalReadBank:
 *  Read all 32 bits in a bank, returning a 32-bit unsigned int.
 *  This only works in BCM GPIO pin numbering mode.
 *********************************************************************************
 */
uint32_t digitalReadBank(int bank)
{
    if (bank > 1)
    {
        return 0;
    }
    return (uint32_t)*(gpio + gpioToGPLEV[bank * 32]);
}


/*
 * digitalWrite:
 *  Set an output bit
 *********************************************************************************
 */
void digitalWrite (int pin, int value)
{
  struct wiringPiNodeStruct *node = wiringPiNodes;

  if ((pin & PI_GPIO_MASK) == 0)		// On-Board Pin
  {
    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);
  }
}


/*
 * pwmWrite:
 *  Set an output PWM value
 *********************************************************************************
 */
void pwmWrite (int pin, int value)
{
  struct wiringPiNodeStruct *node = wiringPiNodes;

  setupCheck ("pwmWrite");

  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;

    usingGpioMemCheck ("pwmWrite");
    *(pwm + gpioToPwmPort[pin]) = value;
  }
  else
  {
    if ((node = wiringPiFindNode (pin)) != NULL)
      node->pwmWrite (node, pin, 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)
{
  struct wiringPiNodeStruct *node = wiringPiNodes;

  if ((node = wiringPiFindNode (pin)) == NULL)
    return 0;
  else
    return node->analogRead (node, pin);
}


/*
 * 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 analogWrite (int pin, int value)
{
  struct wiringPiNodeStruct *node = wiringPiNodes;

  if ((node = wiringPiFindNode (pin)) == NULL)
    return;

  node->analogWrite (node, pin, value);
}


/*
 * pwmToneWrite:
 *  Pi Specific.
 *      Output the given frequency on the Pi's PWM pin
 *********************************************************************************
 */
void pwmToneWrite (int pin, int freq)
{
  int range;

  setupCheck ("pwmToneWrite");

  if (freq == 0)
    pwmWrite (pin, 0);             // Off
  else
  {
    range = 600000 / freq;
    pwmSetRange (range);
    pwmWrite    (pin, freq / 2);
  }
}


/*
 * 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, 27, 22, 23, 24, 25, 4 on a Pi v1 rev 3 onwards or B+, 2, 3, zero
 *********************************************************************************
 */

void digitalWriteByte (const int value)
{
  uint32_t pinSet = 0;
  uint32_t pinClr = 0;
  int mask = 1;
  int pin;

  if (wiringPiMode == WPI_MODE_GPIO_SYS)
  {
    for (pin = 0; pin < 8; ++pin)
    {
      digitalWrite (pinToGpio[pin], value & mask);
      mask <<= 1;
    }
    return;
  }
  else
  {
    for (pin = 0; pin < 8; ++pin)
    {
      if ((value & mask) == 0)
        pinClr |= (1 << pinToGpio[pin]);
      else
        pinSet |= (1 << pinToGpio[pin]);

      mask <<= 1;
    }

    *(gpio + gpioToGPCLR[0]) = pinClr;
    *(gpio + gpioToGPSET[0]) = pinSet;
  }
}

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:
 *  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
 *  way for a bit more efficiency.
 *  Returns output of poll(): 1 on success, 0 on timeout, -1 on error.
 *********************************************************************************
 */
int waitForInterrupt (int pin, int mS)
{
  int fd, x;
  uint8_t c;
  struct pollfd polls;

  if      (wiringPiMode == WPI_MODE_PINS)
    pin = pinToGpio[pin];
  else if (wiringPiMode == WPI_MODE_PHYS)
    pin = physToGpio[pin];

  if ((fd = sysFds[pin]) == -1)
    return -2;

  // Setup poll structure
  polls.fd     = fd;
  polls.events = POLLPRI | POLLERR;

  // Wait for it ...
  x = poll (&polls, 1, mS);

  // If no error, do a dummy read to clear the interrupt
  // A one character read appars to be enough.
  if (x > 0)
  {
    lseek (fd, 0, SEEK_SET); // Rewind
    (void)read (fd, &c, 1);  // Read & clear
  }

  return x;
}


/*
 * interruptHandler:
 *  This is a thread that gets started to wait for the interrupt we're
 *  hoping to catch. It will call the user-function when the interrupt
 *  fires.
 *********************************************************************************
 */
static void *interruptHandler (UNU void *arg)
{
  int myPin;

  (void)piHiPri (55);	// Only effective if we run as root

  myPin   = pinPass;
  pinPass = -1;

  for (;;)
  {
    if (waitForInterrupt (myPin, -1) > 0)
    {
      isrFunctions[myPin](myPin);
    }
  }

  return NULL;
}


/*
 * wiringPiISR:
 *  Pi Specific.
 *  Take the details and create an interrupt handler that will do a call-
 *  back to the user supplied function.
 *  Returns 0 on success, -1 on failure (or program exits if !wiringPiReturnCodes)
 *********************************************************************************
 */
int wiringPiISR (int pin, int mode, void (*function)(int))
{
  pthread_t threadId;
  const char *modeS;
  char  fName[64];
  char  pinS[8];
  pid_t pid;
  int   count, i;
  char  c;
  int   bcmGpioPin;

  if ((pin < 0) || (pin > 63))
    return wiringPiFailure (WPI_FATAL, "wiringPiISR: pin must be 0-63 (%d)\n", pin);

  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)
    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
  // a full installation of wiringPi. It's a bit 'clunky', but it
  // is a way that will work when we're running in "Sys" mode, as
  // a non-root user. (without sudo)
  if (mode != INT_EDGE_SETUP)
  {
    if      (mode == INT_EDGE_FALLING)
      modeS = "falling";
    else if (mode == INT_EDGE_RISING)
      modeS = "rising";
    else
      modeS = "both";

    sprintf (pinS, "%d", bcmGpioPin);

    if ((pid = fork ()) < 0)	// Fail
      return wiringPiFailure (WPI_FATAL, "wiringPiISR: fork failed: %s\n", strerror (errno));

    if (pid == 0)	// Child, execl (doesn't return if successful)
    {
      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 for child's execl call to finish
      waitpid (pid, NULL, 0);
  }
  // Parent continues...

  // Now pre-open the /sys/class node - but it may already be open if
  // we are in Sys mode...
  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));
  }

  // Clear any initial pending interrupt
  ioctl (sysFds[bcmGpioPin], FIONREAD, &count);
  for (i = 0; i < count; ++i)
    read (sysFds[bcmGpioPin], &c, 1);

  // Save caller's callback function
  isrFunctions[pin] = function;

  pthread_mutex_lock (&pinMutex);
  pinPass = pin;
  pthread_create (&threadId, NULL, interruptHandler, NULL);
  while (pinPass != -1)
  {
    delayMs(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)
{
  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);
}


/*
 * delay:
 *  Wait for some number of milliseconds
 *********************************************************************************
 */
void delay (unsigned int milliseconds)
{
#if 0
  struct timespec sleeper, dummy;

  sleeper.tv_sec  = (time_t)(howLong / 1000);
  sleeper.tv_nsec = (long)(howLong % 1000) * 1000000;

  nanosleep (&sleeper, &dummy);
#else
  usleep(milliseconds * 1000);
#endif
}


/*
 * delayMicroseconds:
 *  It seems that a single call to nanosleep takes 80 to 130
 *  microseconds anyway, so while obeying the standards (may take longer),
 *  it's not optimal.
 *
 *  So what I'll do now is if the delay is less than 100uS we'll do it
 *  in a hard loop, watching a built-in counter on the ARM chip. This is
 *  somewhat sub-optimal in that it uses 100% CPU, something not an issue
 *  in a microcontroller, but under a multi-tasking, multi-user OS, it's
 *  wastefull, however we've no real choice )-:
 *
 *      Plan B: It seems all might not be well with that plan, so changing it
 *      to use gettimeofday () and poll on that instead...
 *********************************************************************************
 */
void delayMicrosecondsHard (unsigned int microseconds)
{
  struct timeval tNow, tLong, tEnd;

  gettimeofday (&tNow, NULL);
  tLong.tv_sec  = microseconds / 1000000;
  tLong.tv_usec = microseconds % 1000000;
  timeradd (&tNow, &tLong, &tEnd);

  while (timercmp (&tNow, &tEnd, <))
    gettimeofday (&tNow, NULL);
}

void delayMicroseconds (unsigned int microseconds)
{
#if 0
  struct timespec sleeper;
  unsigned int uSecs = microseconds % 1000000;
  unsigned int wSecs = microseconds / 1000000;

  if (microseconds ==   0)
    return;
  else if (microseconds  < 100)
    delayMicrosecondsHard (microseconds);
  else
  {
    sleeper.tv_sec  = wSecs;
    sleeper.tv_nsec = (long)(uSecs * 1000L);
    nanosleep (&sleeper, NULL);
  }
#else
  if (microseconds ==   0)
    return;
  else if (microseconds  < 100)
    delayMicrosecondsHard (microseconds);
  else
  {
    usleep(microseconds);
  }
#endif
}


/*
 * millis:
 *  Return a number of milliseconds as an unsigned int.
 *  Wraps at 49 days.
 *********************************************************************************
 */
unsigned int millis (void)
{
  uint64_t now;
  struct  timespec ts;

  clock_gettime (CLOCK_MONOTONIC_RAW, &ts);
  now  = (uint64_t)ts.tv_sec * (uint64_t)1000 + (uint64_t)(ts.tv_nsec / 1000000L);

  return (uint32_t)(now - epochMilli);
}


/*
 * micros:
 *  Return a number of microseconds as an unsigned int.
 *  Wraps after 71 minutes.
 *********************************************************************************
 */
unsigned int micros (void)
{
  uint64_t now;
  struct  timespec ts;

  clock_gettime (CLOCK_MONOTONIC_RAW, &ts);
  now  = (uint64_t)ts.tv_sec * (uint64_t)1000000 + (uint64_t)(ts.tv_nsec / 1000);

  return (uint32_t)(now - epochMicro);
}

/*
 * wiringPiVersion:
 *  Return our current version number
 *********************************************************************************
 */
void wiringPiVersion (int *major, int *minor)
{
  *major = VERSION_MAJOR;
  *minor = VERSION_MINOR;
}


/*
 * 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.
 *********************************************************************************
 */
int wiringPiSetup (void)
{
  int   fd;
  int   model, proc, rev, mem, maker, overVolted;

  // Exit with OK status if this has already been called.
  if (wiringPiSetuped)
  {
    return 0;
  }

  wiringPiSetuped = TRUE;

  if (getenv (ENV_DEBUG) != NULL)
  {
    wiringPiDebug = TRUE;
  }

  if (getenv (ENV_CODES) != NULL)
  {
    wiringPiReturnCodes = TRUE;
  }

  if (wiringPiDebug)
  {
    printf ("wiringPi: wiringPiSetup called\n");
  }

  // 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.
  piBoardId (&model, &proc, &rev, &mem, &maker, &overVolted);

  // Set default GPIO/pin mode.
  if ((model == PI_MODEL_CM1) ||
      (model == PI_MODEL_CM3) ||
      (model == PI_MODEL_CM3P))
    wiringPiMode = WPI_MODE_GPIO; // Virtual pin numbers 0 through 16
  else
    wiringPiMode = WPI_MODE_PINS; // Broadcom GPIO pin numbers

  if (piGpioLayout() == 1) // A, B, Rev 1, 1.1 (Oldest boards)
  {
    pinToGpio =  pinToGpioR1;
    physToGpio = physToGpioR1;
  }
  else // A2, B2, A+, B+, CM, Pi2, Pi3, Zero, Zero W, Zero 2 W
  {
    pinToGpio =  pinToGpioR2;
    physToGpio = physToGpioR2;
  }

  // ...

  switch (model)
  {
    case PI_MODEL_A:    case PI_MODEL_B:
    case PI_MODEL_AP:   case PI_MODEL_BP:
    case PI_ALPHA:      case PI_MODEL_CM1:
    case PI_MODEL_ZERO: case PI_MODEL_ZERO_W:
      piGpioBase = GPIO_PERI_BASE_OLD;
      piGpioPupOffset = GPPUD;
      break;

    case PI_MODEL_4B:
    case PI_MODEL_400:
    case PI_MODEL_CM4:
      piGpioBase = GPIO_PERI_BASE_2711;
      piGpioPupOffset = GPPUPPDN0;
      break;

    default:
      piGpioBase = GPIO_PERI_BASE_2835;
      piGpioPupOffset = GPPUD;
      break;
  }

  // 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 ((fd = open ("/dev/gpiomem", O_RDWR | O_SYNC | O_CLOEXEC) ) >= 0)	// We're using gpiomem
    {
      piGpioBase   = 0;
      usingGpioMem = TRUE;
    }
    else
      return wiringPiFailure (WPI_NON_FATAL,
        "wiringPiSetup: Unable to open /dev/mem or /dev/gpiomem: %s.\n"
        "  Aborting your program because it must be able to access the GPIO hardware.\n"
        "  NOTE: You may need to run with sudo.\n",
        strerror (errno));
  }

  // Set the offsets into the memory interface.
  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 (gpio == MAP_FAILED)
    return wiringPiFailure (WPI_NON_FATAL, "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 (pwm == MAP_FAILED)
    return wiringPiFailure (WPI_NON_FATAL, "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 (clk == MAP_FAILED)
    return wiringPiFailure (WPI_NON_FATAL, "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 (pads == MAP_FAILED)
    return wiringPiFailure (WPI_NON_FATAL, "wiringPiSetup: mmap (PADS) failed: %s\n", strerror (errno));

  // 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_NON_FATAL, "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)
  // so base clock is 250MHz / 250 = 1MHz.
  *(timer + TIMER_CONTROL) = 0x0000280;
  *(timer + TIMER_PRE_DIV) = 0x00000F9;
  timerIrqRaw = timer + TIMER_IRQ_RAW;

  // Export the base addresses for any external software that might need them
  _wiringPiGpio  = gpio;
  _wiringPiPwm   = pwm;
  _wiringPiClk   = clk;
  _wiringPiPads  = pads;
  _wiringPiTimer = timer;

  initialiseEpoch ();

  return 0;
}


/*
 * wiringPiSetupGpio:
 *  Must be called once at the start of your program execution.
 *
 * GPIO setup: Initialises the system into GPIO Pin mode and uses the
 *  memory mapped hardware directly.
 *********************************************************************************
 */

int wiringPiSetupGpio (void)
{
  (void)wiringPiSetup ();

  if (wiringPiDebug)
    printf ("wiringPi: wiringPiSetupGpio called\n");

  wiringPiMode = WPI_MODE_GPIO;

  return 0;
}


/*
 * 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.
 *
 * Initialisation (again), however this time we are using the /sys/class/gpio
 *  interface to the GPIO systems - slightly slower, but always usable as
 *  a non-root user, assuming the devices are already exported and setup correctly.
 */
int wiringPiSetupSys (void)
{
  int pin;
  char fName[128];

  if (wiringPiSetuped)
    return 0;

  wiringPiSetuped = TRUE;

  if (getenv (ENV_DEBUG) != NULL)
    wiringPiDebug = TRUE;

  if (getenv (ENV_CODES) != NULL)
    wiringPiReturnCodes = TRUE;

  if (wiringPiDebug)
    printf ("wiringPi: wiringPiSetupSys called\n");

  if (piGpioLayout () == 1)
  {
     pinToGpio =  pinToGpioR1;
    physToGpio = physToGpioR1;
  }
  else
  {
     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
  for (pin = 0; pin < 64; ++pin)
  {
    sprintf (fName, "/sys/class/gpio/gpio%d/value", pin);
    sysFds[pin] = open (fName, O_RDWR);
  }

  initialiseEpoch ();

  wiringPiMode = WPI_MODE_GPIO_SYS;

  return 0;
}