rpi_gpio 0.5.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c751d8fda46ee296e1df93542416ba668f7f6d9d05142f7647ce63310be42873
-  data.tar.gz: 471e4e0dc50ed6b265c9f9dd3ff01a4cb332ac288c8210b161c4bd69ee9cd4d1
+  metadata.gz: e85a39df6149e36f76739cbb642208a635cc20fa3a7e201ea0207c2070fc4765
+  data.tar.gz: 36b825467b90ebe19c1bcd431847bbc596ea94fdd31e7c5b99fdda31f3efc87c
 SHA512:
-  metadata.gz: 00ef0c4360e5f9c41aec4cf7274249c7dae11fcadc06ad54e27b474a2ea95397fb6727a1a8360e8261fe88f3aa765d904739314da8bc5b1730cc8319c5db2042
-  data.tar.gz: 76a6df3e90bfc0ab0ee47030c1c18cb36098b981b72ac5ff855ca5e5abc424a9c5e7452a8e8f1c47507dc846db6ee694de6a49d06fe7bd10bae4529b7c98a9cf
+  metadata.gz: fa6f1aa7414cdcfc349b2f06c4108fc6819634f8f6a1d3dd5aa70cf8f6e040e0c0a06d32342af3d36c5207673c86640895918e4c6651e74205b6da62d8608056
+  data.tar.gz: bed6f48051ae7eb6c62eb3394cd18c7f1e4f8b5b543a50a38b9ebe091260b0f5a512b46aa89b69f0e3a011c58f51e9a0921b0d2f76acccaf5640a3ed072ff1bc

data/LICENSE

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 
-Copyright (c) 2014-2020 Nick Lowery
-Copyright (c) 2012-2014 Ben Croston
+Copyright (c) 2014-2026 Nick Lowery
+Copyright (c) 2012-2021 Ben Croston
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,4 +1,4 @@
-# rpi_gpio v0.5.0
+# rpi_gpio v0.7.1
 
 Ruby conversion of [RPi.GPIO Python module](https://pypi.python.org/pypi/RPi.GPIO)
 
@@ -10,7 +10,7 @@ Manipulate your Raspberry Pi's GPIO pins from Ruby!
 - Software-driven PWM (written in C for speed)
 - Event-driven input (blocking and non-blocking)
 
-Up-to-date with RPi.GPIO Python module version 0.7.0, so it works on all Raspberry Pi models!
+Up-to-date with RPi.GPIO Python module version 0.7.1, so it works on all Raspberry Pi models!
 
 ## Sample Usage
 
@@ -180,7 +180,7 @@ to clean up all pins and to also reset the selected numbering mode.
 
 Original Python code by Ben Croston modified for Ruby by Nick Lowery
 
-Copyright (c) 2014-2020 [Nick Lowery](https://github.com/ClockVapor)
+Copyright (c) 2014-2026 [Nick Lowery](https://github.com/ClockVapor)
 
 View LICENSE for full license.
 

data/ext/rpi_gpio/c_gpio.c

@@ -0,0 +1,345 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2026 Nick Lowery
+
+Copyright (c) 2012-2021 Ben Croston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <string.h>
+#include "c_gpio.h"
+
+#define BCM2708_PERI_BASE_DEFAULT   0x20000000
+#define BCM2709_PERI_BASE_DEFAULT   0x3f000000
+#define BCM2710_PERI_BASE_DEFAULT   0x3f000000
+#define BCM2711_PERI_BASE_DEFAULT   0xfe000000
+#define GPIO_BASE_OFFSET            0x200000
+#define FSEL_OFFSET                 0   // 0x0000
+#define SET_OFFSET                  7   // 0x001c / 4
+#define CLR_OFFSET                  10  // 0x0028 / 4
+#define PINLEVEL_OFFSET             13  // 0x0034 / 4
+#define EVENT_DETECT_OFFSET         16  // 0x0040 / 4
+#define RISING_ED_OFFSET            19  // 0x004c / 4
+#define FALLING_ED_OFFSET           22  // 0x0058 / 4
+#define HIGH_DETECT_OFFSET          25  // 0x0064 / 4
+#define LOW_DETECT_OFFSET           28  // 0x0070 / 4
+#define PULLUPDN_OFFSET             37  // 0x0094 / 4
+#define PULLUPDNCLK_OFFSET          38  // 0x0098 / 4
+
+#define PULLUPDN_OFFSET_2711_0      57
+#define PULLUPDN_OFFSET_2711_1      58
+#define PULLUPDN_OFFSET_2711_2      59
+#define PULLUPDN_OFFSET_2711_3      60
+
+#define PAGE_SIZE  (4*1024)
+#define BLOCK_SIZE (4*1024)
+
+static volatile uint32_t *gpio_map;
+
+void short_wait(void)
+{
+    int i;
+
+    for (i=0; i<150; i++) {    // wait 150 cycles
+        asm volatile("nop");
+    }
+}
+
+int setup(void)
+{
+    int mem_fd;
+    uint8_t *gpio_mem;
+    uint32_t peri_base = 0;
+    uint32_t gpio_base;
+    uint8_t ranges[12] = { 0 };
+    uint8_t rev[4] = { 0 };
+    uint32_t cpu = 0;
+    FILE *fp;
+    char buffer[1024];
+    char hardware[1024];
+    int found = 0;
+
+    // try /dev/gpiomem first - this does not require root privs
+    if ((mem_fd = open("/dev/gpiomem", O_RDWR|O_SYNC)) > 0)
+    {
+        if ((gpio_map = (uint32_t *)mmap(NULL, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, mem_fd, 0)) == MAP_FAILED) {
+            return SETUP_MMAP_FAIL;
+        } else {
+            return SETUP_OK;
+        }
+    }
+
+    // revert to /dev/mem method - requires root privileges
+
+    if ((fp = fopen("/proc/device-tree/soc/ranges", "rb")) != NULL)
+    {
+        // get peri base from device tree
+        if (fread(ranges, 1, sizeof(ranges), fp) >= 8) {
+            peri_base = ranges[4] << 24 | ranges[5] << 16 | ranges[6] << 8 | ranges[7] << 0;
+            if (!peri_base) {
+                peri_base = ranges[8] << 24 | ranges[9] << 16 | ranges[10] << 8 | ranges[11] << 0;
+            }
+        }
+        if ((ranges[0] != 0x7e) ||
+            (ranges[1] != 0x00) ||
+            (ranges[2] != 0x00) ||
+            (ranges[3] != 0x00) ||
+            ((peri_base != BCM2708_PERI_BASE_DEFAULT) &&
+             (peri_base != BCM2709_PERI_BASE_DEFAULT) &&
+             (peri_base != BCM2711_PERI_BASE_DEFAULT))) {
+                 // invalid ranges file
+                 peri_base = 0;
+        }
+        fclose(fp);
+    }
+
+    // guess peri_base based on /proc/device-tree/system/linux,revision
+    if (!peri_base) {
+        if ((fp = fopen("/proc/device-tree/system/linux,revision", "rb")) != NULL) {
+            if (fread(rev, 1, sizeof(rev), fp) == 4) {
+                cpu = (rev[2] >> 4) & 0xf;
+                switch (cpu) {
+                    case 0 : peri_base = BCM2708_PERI_BASE_DEFAULT;
+                             break;
+                    case 1 :
+                    case 2 : peri_base = BCM2709_PERI_BASE_DEFAULT;
+                             break;
+                    case 3 : peri_base = BCM2711_PERI_BASE_DEFAULT;
+                             break;
+                }
+            }
+            fclose(fp);
+        }
+    }
+
+    // guess peri_base based on /proc/cpuinfo hardware field
+    if (!peri_base) {
+        if ((fp = fopen("/proc/cpuinfo", "r")) == NULL)
+            return SETUP_CPUINFO_FAIL;
+
+        while(!feof(fp) && !found && fgets(buffer, sizeof(buffer), fp)) {
+            sscanf(buffer, "Hardware	: %s", hardware);
+            if (strcmp(hardware, "BCM2708") == 0 || strcmp(hardware, "BCM2835") == 0) {
+                // pi 1 hardware
+                peri_base = BCM2708_PERI_BASE_DEFAULT;
+            } else if (strcmp(hardware, "BCM2709") == 0 || strcmp(hardware, "BCM2836") == 0) {
+                // pi 2 hardware
+                peri_base = BCM2709_PERI_BASE_DEFAULT;
+            } else if (strcmp(hardware, "BCM2710") == 0 || strcmp(hardware, "BCM2837") == 0) {
+                // pi 3 hardware
+                peri_base = BCM2710_PERI_BASE_DEFAULT;
+            } else if (strcmp(hardware, "BCM2711") == 0) {
+                // pi 4 hardware
+                peri_base = BCM2711_PERI_BASE_DEFAULT;
+            }
+        }
+        fclose(fp);
+    }
+
+    if (!peri_base)
+        return SETUP_NO_PERI_ADDR;
+
+    gpio_base = peri_base + GPIO_BASE_OFFSET;
+
+    // mmap the GPIO memory registers
+    if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0)
+        return SETUP_DEVMEM_FAIL;
+
+    if ((gpio_mem = malloc(BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
+        return SETUP_MALLOC_FAIL;
+
+    if ((uint32_t)gpio_mem % PAGE_SIZE)
+        gpio_mem += PAGE_SIZE - ((uint32_t)gpio_mem % PAGE_SIZE);
+
+    if ((gpio_map = (uint32_t *)mmap( (void *)gpio_mem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, mem_fd, gpio_base)) == MAP_FAILED)
+        return SETUP_MMAP_FAIL;
+
+    return SETUP_OK;
+}
+
+void clear_event_detect(int gpio)
+{
+    int offset = EVENT_DETECT_OFFSET + (gpio/32);
+    int shift = (gpio%32);
+
+    *(gpio_map+offset) |= (1 << shift);
+    short_wait();
+    *(gpio_map+offset) = 0;
+}
+
+int eventdetected(int gpio)
+{
+    int offset, value, bit;
+
+    offset = EVENT_DETECT_OFFSET + (gpio/32);
+    bit = (1 << (gpio%32));
+    value = *(gpio_map+offset) & bit;
+    if (value)
+        clear_event_detect(gpio);
+    return value;
+}
+
+void set_rising_event(int gpio, int enable)
+{
+    int offset = RISING_ED_OFFSET + (gpio/32);
+    int shift = (gpio%32);
+
+    if (enable)
+        *(gpio_map+offset) |= 1 << shift;
+    else
+        *(gpio_map+offset) &= ~(1 << shift);
+    clear_event_detect(gpio);
+}
+
+void set_falling_event(int gpio, int enable)
+{
+    int offset = FALLING_ED_OFFSET + (gpio/32);
+    int shift = (gpio%32);
+
+    if (enable) {
+        *(gpio_map+offset) |= (1 << shift);
+        *(gpio_map+offset) = (1 << shift);
+    } else {
+        *(gpio_map+offset) &= ~(1 << shift);
+    }
+    clear_event_detect(gpio);
+}
+
+void set_high_event(int gpio, int enable)
+{
+    int offset = HIGH_DETECT_OFFSET + (gpio/32);
+    int shift = (gpio%32);
+
+    if (enable)
+        *(gpio_map+offset) |= (1 << shift);
+    else
+        *(gpio_map+offset) &= ~(1 << shift);
+    clear_event_detect(gpio);
+}
+
+void set_low_event(int gpio, int enable)
+{
+    int offset = LOW_DETECT_OFFSET + (gpio/32);
+    int shift = (gpio%32);
+
+    if (enable)
+        *(gpio_map+offset) |= 1 << shift;
+    else
+        *(gpio_map+offset) &= ~(1 << shift);
+    clear_event_detect(gpio);
+}
+
+void set_pullupdn(int gpio, int pud)
+{
+    // Check GPIO register
+    int is2711 = *(gpio_map+PULLUPDN_OFFSET_2711_3) != 0x6770696f;
+    if (is2711) {
+        // Pi 4 Pull-up/down method
+        int pullreg = PULLUPDN_OFFSET_2711_0 + (gpio >> 4);
+        int pullshift = (gpio & 0xf) << 1;
+        unsigned int pullbits;
+        unsigned int pull = 0;
+        switch (pud) {
+            case PUD_OFF:  pull = 0; break;
+            case PUD_UP:   pull = 1; break;
+            case PUD_DOWN: pull = 2; break;
+            default:       pull = 0; // switch PUD to OFF for other values
+        }
+        pullbits = *(gpio_map + pullreg);
+        pullbits &= ~(3 << pullshift);
+        pullbits |= (pull << pullshift);
+        *(gpio_map + pullreg) = pullbits;
+    } else {
+        // Legacy Pull-up/down method
+        int clk_offset = PULLUPDNCLK_OFFSET + (gpio/32);
+        int shift = (gpio%32);
+
+        if (pud == PUD_DOWN) {
+            *(gpio_map+PULLUPDN_OFFSET) = (*(gpio_map+PULLUPDN_OFFSET) & ~3) | PUD_DOWN;
+        } else if (pud == PUD_UP) {
+            *(gpio_map+PULLUPDN_OFFSET) = (*(gpio_map+PULLUPDN_OFFSET) & ~3) | PUD_UP;
+        } else  { // pud == PUD_OFF
+            *(gpio_map+PULLUPDN_OFFSET) &= ~3;
+        }
+        short_wait();
+        *(gpio_map+clk_offset) = 1 << shift;
+        short_wait();
+        *(gpio_map+PULLUPDN_OFFSET) &= ~3;
+        *(gpio_map+clk_offset) = 0;
+    }
+}
+
+void setup_gpio(int gpio, int direction, int pud)
+{
+    int offset = FSEL_OFFSET + (gpio/10);
+    int shift = (gpio%10)*3;
+
+    set_pullupdn(gpio, pud);
+    if (direction == OUTPUT)
+        *(gpio_map+offset) = (*(gpio_map+offset) & ~(7<<shift)) | (1<<shift);
+    else  // direction == INPUT
+        *(gpio_map+offset) = (*(gpio_map+offset) & ~(7<<shift));
+}
+
+// Contribution by Eric Ptak <trouch@trouch.com>
+int gpio_function(int gpio)
+{
+    int offset = FSEL_OFFSET + (gpio/10);
+    int shift = (gpio%10)*3;
+    int value = *(gpio_map+offset);
+    value >>= shift;
+    value &= 7;
+    return value; // 0=input, 1=output, 4=alt0
+}
+
+void output_gpio(int gpio, int value)
+{
+    int offset, shift;
+
+    if (value) // value == HIGH
+        offset = SET_OFFSET + (gpio/32);
+    else       // value == LOW
+       offset = CLR_OFFSET + (gpio/32);
+
+    shift = (gpio%32);
+
+    *(gpio_map+offset) = 1 << shift;
+}
+
+int input_gpio(int gpio)
+{
+   int offset, value, mask;
+
+   offset = PINLEVEL_OFFSET + (gpio/32);
+   mask = (1 << gpio%32);
+   value = *(gpio_map+offset) & mask;
+   return value;
+}
+
+void cleanup(void)
+{
+    munmap((void *)gpio_map, BLOCK_SIZE);
+}

data/ext/rpi_gpio/c_gpio.h

@@ -0,0 +1,55 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2026 Nick Lowery
+
+Copyright (c) 2012-2021 Ben Croston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+int setup(void);
+void setup_gpio(int gpio, int direction, int pud);
+int gpio_function(int gpio);
+void output_gpio(int gpio, int value);
+int input_gpio(int gpio);
+void set_rising_event(int gpio, int enable);
+void set_falling_event(int gpio, int enable);
+void set_high_event(int gpio, int enable);
+void set_low_event(int gpio, int enable);
+int eventdetected(int gpio);
+void cleanup(void);
+
+#define SETUP_OK           0
+#define SETUP_DEVMEM_FAIL  1
+#define SETUP_MALLOC_FAIL  2
+#define SETUP_MMAP_FAIL    3
+#define SETUP_CPUINFO_FAIL 4
+#define SETUP_NO_PERI_ADDR 5
+
+#define INPUT  1 // is really 0 for control register!
+#define OUTPUT 0 // is really 1 for control register!
+#define ALT0   4
+
+#define HIGH 1
+#define LOW  0
+
+#define PUD_OFF  0
+#define PUD_DOWN 1
+#define PUD_UP   2

data/ext/rpi_gpio/common.c

@@ -0,0 +1,96 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2026 Nick Lowery
+
+Copyright (c) 2013-2021 Ben Croston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "ruby.h"
+#include "c_gpio.h"
+#include "common.h"
+
+int gpio_mode = MODE_UNKNOWN;
+const int pin_to_gpio_rev1[41] = {-1, -1, -1, 0, -1, 1, -1, 4, 14, -1, 15, 17, 18, 21, -1, 22, 23, -1, 24, 10, -1, 9, 25, 11, 8, -1, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
+const int pin_to_gpio_rev2[41] = {-1, -1, -1, 2, -1, 3, -1, 4, 14, -1, 15, 17, 18, 27, -1, 22, 23, -1, 24, 10, -1, 9, 25, 11, 8, -1, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
+const int pin_to_gpio_rev3[41] = {-1, -1, -1, 2, -1, 3, -1, 4, 14, -1, 15, 17, 18, 27, -1, 22, 23, -1, 24, 10, -1, 9, 25, 11, 8, -1, 7, -1, -1, 5, -1, 6, 12, 13, -1, 19, 16, 26, 20, -1, 21 };
+const int (*pin_to_gpio)[41];
+int gpio_direction[54];
+rpi_info rpiinfo;
+int setup_error = 0;
+int module_setup = 0;
+
+int check_gpio_priv(void)
+{
+    // check module has been imported cleanly
+    if (setup_error)
+    {
+        rb_raise(rb_eRuntimeError, "gem not imported correctly!");
+        return 1;
+    }
+
+    // check mmap setup has worked
+    if (!module_setup)
+    {
+        rb_raise(rb_eRuntimeError, "no access to /dev/mem. try running as root!");
+        return 2;
+    }
+    return 0;
+}
+
+int get_gpio_number(int channel, unsigned int *gpio)
+{
+    // check setmode() has been run
+    if (gpio_mode != BOARD && gpio_mode != BCM)
+    {
+        rb_raise(rb_eRuntimeError, "please set pin numbering mode "
+          "using RPi::GPIO.set_numbering :board or "
+          "RPi::GPIO.set_numbering :bcm");
+        return 3;
+    }
+
+    // check channel number is in range
+    if ( (gpio_mode == BCM && (channel < 0 || channel > 53))
+      || (gpio_mode == BOARD && (channel < 1 || channel > 26) && rpiinfo.p1_revision != 3)
+      || (gpio_mode == BOARD && (channel < 1 || channel > 40) && rpiinfo.p1_revision == 3) )
+    {
+        rb_raise(rb_eArgError, "the channel sent is invalid on a Raspberry Pi");
+        return 4;
+    }
+
+    // convert channel to gpio
+    if (gpio_mode == BOARD)
+    {
+        if (*(*pin_to_gpio+channel) == -1)
+        {
+            rb_raise(rb_eArgError, "the channel sent is invalid on a Raspberry Pi");
+            return 5;
+        } else {
+            *gpio = *(*pin_to_gpio+channel);
+        }
+    }
+    else // gpio_mode == BCM
+    {
+        *gpio = channel;
+    }
+
+    return 0;
+}

data/ext/rpi_gpio/common.h

@@ -0,0 +1,48 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2026 Nick Lowery
+
+Copyright (c) 2013-2021 Ben Croston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "cpuinfo.h"
+
+#define MODE_UNKNOWN -1
+#define BOARD        10
+#define BCM          11
+#define SERIAL       40
+#define SPI          41
+#define I2C          42
+#define PWM          43
+
+extern int gpio_mode;
+extern const int pin_to_gpio_rev1[41];
+extern const int pin_to_gpio_rev2[41];
+extern const int pin_to_gpio_rev3[41];
+extern const int (*pin_to_gpio)[41];
+extern int gpio_direction[54];
+extern rpi_info rpiinfo;
+extern int setup_error;
+extern int module_setup;
+
+int check_gpio_priv(void);
+int get_gpio_number(int channel, unsigned int *gpio);