python: doc: add python doc to python3

Make sure that right python is used for the right bindings docs

Signed-off-by: Thomas Ingleby <thomas.ingleby@intel.com>

.travis.yml

@@ -1,34 +1,55 @@
 language: cpp
+sudo: required
+dist: trusty
 env:
   - NODE010=true
   - NODE012=true
   - NODE4=true
   - NODE5=true
+  - JSONPLAT=true NODE010=true
+  - JSONPLAT=true NODE012=true
+  - JSONPLAT=true NODE4=true
+  - JSONPLAT=true NODE5=true
+  # node010 npm builds don't work in clang and anyone using npm should want to
+  # use something newer
+  - NPM=true NODE4=true
+  - NPM=true NODE5=true
 compiler:
   - clang
   - gcc
+before_install:
+  # Via https://github.com/travis-ci/travis-ci/issues/5326
+  - export PATH="$(echo $PATH | tr ':' "\n" | sed '/\/opt\/python/d' | tr "\n" ":" | sed "s|::|:|g")"
 install:
   - if [ "${NODE4}" ]; then export CC=gcc-4.8 CXX=g++-4.8; fi
-  - sudo add-apt-repository --yes ppa:kalakris/cmake
-  - sudo add-apt-repository --yes ppa:fenics-packages/fenics-exp/swig
-  - sudo apt-get update -qq
-  - sudo apt-get install -y -qq swig3.0 python git cmake
-  - sudo ln -s /usr/bin/swig3.0 /usr/bin/swig
-  - sudo update-java-alternatives -s java-8-oracle
 before_script:
   # Turn off JAVA SWIG for clang++, use 4.8 for all g++ builds
   - if [ "$CC" == "gcc" ]; then export BUILDJAVA=ON; export CC=gcc-4.8; export CXX=g++-4.8; else export BUILDJAVA=OFF; fi
+  - if [ "${JSONPLAT}" ]; then export JSONPLAT=ON; else export JSONPLAT=OFF; fi
+  - if [ "${NODE010}" ]; then nvm install 0.10; fi
   - if [ "${NODE012}" ]; then nvm install 0.12; fi
   - if [ "${NODE4}" ]; then nvm install 4.1; fi
   - if [ "${NODE5}" ]; then nvm install 5; fi
+  - npm install node-gyp && export NODE_GYP="/home/travis/build/intel-iot-devkit/mraa/node_modules/node-gyp/bin/node-gyp.js"
   # Handle 0.10 NODE_ROOT_DIR differently than other versions
-  - if [ -z ${NODE010} ]; then export NODE_ROOT_DIR="/home/travis/.nvm/versions/node/`nvm version`"; else export NODE_ROOT_DIR=/home/travis/.nvm/v0.10.36; fi
+  - wget http://prdownloads.sourceforge.net/swig/swig-3.0.10.tar.gz && tar xf swig-3.0.10.tar.gz && cd swig-3.0.10 && ./configure --prefix=/home/travis/ && make && make install && cd ..
 script:
-  - echo "CC=$CC BUILDJAVA=$BUILDJAVA NODE010=$NODE010 NODE012=$NODE012 NODE4=$NODE4 NODE5=$NODE5 NODE_ROOT_DIR=$NODE_ROOT_DIR"
-  - mkdir build && cd build && cmake -DBUILDSWIGJAVA=$BUILDJAVA -DNODE_ROOT_DIR:PATH="${NODE_ROOT_DIR}" -DCMAKE_INSTALL_PREFIX:PATH=../install .. && make install && make test
+  - echo "CC=$CC BUILDJAVA=$BUILDJAVA JSONPLAT=$JSONPLAT NODE010=$NODE010 NODE012=$NODE012 NODE4=$NODE4 NODE5=$NODE5 NODE_ROOT_DIR=$NODE_ROOT_DIR"
+  - if [ -z ${NPM} ]; then mkdir build && cd build && cmake -DBUILDSWIGJAVA="$BUILDJAVA" -DJSONPLAT=$JSONPLAT -DNODE_ROOT_DIR:PATH="${NVM_BIN}/.." -DCMAKE_INSTALL_PREFIX:PATH=../install -DSWIG_EXECUTABLE=/home/travis/bin/swig -DSWIG_DIR:PATH=/home/travis/share/swig/3.0.10/ .. && make install && make test; else mkdir build && cd build && cmake -DBUILDSWIGJAVA="$BUILDJAVA" -DJSONPLAT=$JSONPLAT -DNODE_ROOT_DIR:PATH="${NVM_BIN}/.." -DCMAKE_INSTALL_PREFIX:PATH=../install -DSWIG_EXECUTABLE=/home/travis/bin/swig -DSWIG_DIR:PATH=/home/travis/share/swig/3.0.10/ .. && make npmpkg && cd .. && ${NODE_GYP} configure && ${NODE_GYP} build; fi
+  # simple test to see if we can load our node module
+  - if [ ${NPM} ]; then cd build/Release/obj.target/ && node -e  "var m = require('./mraa.node'); m.getVersion()";fi
 addons:
   apt:
     sources:
       - ubuntu-toolchain-r-test
+      - kalakris-cmake
     packages:
       - g++-4.8
+      - cmake
+      - python
+      - python-dev
+      - python3
+      - python3-dev
+      - git
+      - libjson0
+      - libjson0-dev

Android.mk

@@ -37,7 +37,8 @@ LOCAL_SRC_FILES := \
     src/x86/intel_sofia_3gr.c \
     src/x86/intel_minnow_byt_compatible.c \
     src/x86/intel_cherryhills.c \
-    src/x86/up.c
+    src/x86/up.c \
+    src/x86/intel_gt_tuchuck.c
 
 # glob.c pulled in from NetBSD project (BSD 3-clause License)
 LOCAL_SRC_FILES += \

CMakeLists.txt

@@ -31,7 +31,7 @@ include (GetGitRevisionDescription)
 git_describe (VERSION "--tags")
 if ("x_${VERSION}" STREQUAL "x_GIT-NOTFOUND" OR "x_${VERSION}" STREQUAL "x_HEAD-HASH-NOTFOUND" OR "x_${VERSION}" STREQUAL "x_-128-NOTFOUND")
   message (WARNING " - Install git to compile a production libmraa!")
-  set (VERSION "v1.0.0-dirty")
+  set (VERSION "v1.2.3-dirty")
 endif ()
 
 message (STATUS "INFO - libmraa Version ${VERSION}")
@@ -71,18 +71,19 @@ option (BUILDSWIGJAVA "Build Java API." OFF)
 option (USBPLAT "Detection USB platform." OFF)
 option (FIRMATA "Add Firmata support to mraa." OFF)
 option (ONEWIRE "Add Onewire support to mraa." ON)
+option (JSONPLAT "Add Platform loading via a json file." ON)
 option (IMRAA "Add Imraa support to mraa." OFF)
 option (FTDI4222 "Build with FTDI FT4222 subplatform support." OFF)
 option (IPK "Generate IPK using CPack" OFF)
 option (RPM "Generate RPM using CPack" OFF)
-option (BUILDPYTHON3 "Use python3 for building/installing/testing" OFF)
 option (ENABLEEXAMPLES "Disable building of examples" ON)
 option (INSTALLGPIOTOOL "Install gpio tool" OFF)
 option (INSTALLTOOLS "Install all tools" OFF)
-option (BUILDARCH "Override architecture to build for - override" OFF)
 option (BUILDTESTS "Override the addition of tests" ON)
 
-set (MRAAPLATFORMFORCE "" CACHE STRING "ALL")
+set (BUILDARCH "" CACHE STRING "Override architecture to build for")
+
+set (MRAAPLATFORMFORCE "ALL" CACHE STRING "Override platform to build for")
 
 if (NOT BUILDSWIG)
   set (BUILDSWIGPYTHON OFF)
@@ -104,17 +105,14 @@ if (DETECTED_ARCH STREQUAL "i586" OR DETECTED_ARCH STREQUAL "x86_64"
   set (X86PLAT ON)
 elseif (DETECTED_ARCH MATCHES "arm.*")
   set (ARMPLAT ON)
+elseif (DETECTED_ARCH STREQUAL "MOCK")
+  set (MOCKPLAT ON)
 else ()
-  message (FATAL_ERROR "Only x86 and arm platforms currently supported")
+  message (FATAL_ERROR "Only x86, arm and mock platforms currently supported")
 endif()
 
 if (BUILDSWIGPYTHON OR BUILDTESTS)
-  if (BUILDPYTHON3)
-    set (PYTHONBUILD_VERSION 3)
-  else ()
-    set (PYTHONBUILD_VERSION 2.7)
-  endif ()
-  find_package (PythonInterp ${PYTHONBUILD_VERSION} REQUIRED)
+  include (cmake/modules/OpenCVDetectPython.cmake)
 endif ()
 
 if (BUILDDOC)
@@ -202,9 +200,7 @@ if (IMRAA)
   add_subdirectory (imraa)
 endif ()
 
-if (BUILDTESTS)
-  if (${PYTHONINTERP_FOUND})
-    enable_testing ()
-    add_subdirectory (tests)
-  endif ()
+if (BUILDTESTS AND PYTHON_DEFAULT_EXECUTABLE)
+  enable_testing ()
+  add_subdirectory (tests)
 endif ()

README.md

@@ -15,6 +15,8 @@ The intent is to make it easier for developers and sensor manufacturers to map
 their sensors & actuators on top of supported hardware and to allow control of
 low level communication protocol by high level languages & constructs.
 
+[![Build Status](https://travis-ci.org/intel-iot-devkit/mraa.svg?branch=master)](https://travis-ci.org/intel-iot-devkit/mraa)
+
 Supported Boards
 ================
 
@@ -27,6 +29,7 @@ X86
 * [Minnowboard Max](../master/docs/minnow_max.md)
 * [NUC 5th generation](../master/docs/intel_nuc5.md)
 * [UP](../master/docs/up.md)
+* [Intel Grosse Tete](../master/docs/grossetete.md)
 
 ARM
 ---
@@ -38,6 +41,10 @@ USB
 ---
 * [FT4222](../master/docs/ftdi_ft4222.md)
 
+Mock
+----
+* [Generic simulated board](../master/docs/mock.md)
+
 Installing on your board
 ========
 

api/mraa/aio.hpp

@@ -47,13 +47,26 @@ class Aio
      *
      * @param pin channel number to read ADC inputs
      */
-    Aio(unsigned int pin)
+    Aio(int pin)
     {
         m_aio = mraa_aio_init(pin);
         if (m_aio == NULL) {
             throw std::invalid_argument("Invalid AIO pin specified - do you have an ADC?");
         }
     }
+    /**
+     * Aio Constructor, takes a pointer to the AIO context and initialises
+     * the AIO class
+     *
+     * @param void * to an AIO context
+     */
+    Aio(void* aio_context)
+    {
+        m_aio = (mraa_aio_context) aio_context;
+        if (m_aio == NULL) {
+            throw std::invalid_argument("Invalid AIO context");
+        }
+    }
     /**
      * Aio destructor
      */

api/mraa/common.h

@@ -44,6 +44,7 @@
                                       if (res != MRAA_SUCCESS) \
                                       return res;} while(0)
 
+
 /** @file
  *
  * This file defines the basic shared values for libmraa
@@ -293,6 +294,29 @@ mraa_result_t mraa_add_subplatform(mraa_platform_t subplatformtype, const char*
  */
 mraa_result_t mraa_remove_subplatform(mraa_platform_t subplatformtype);
 
+/**
+ * Create IO using a description in the format:
+ * [io]-[pin]
+ * [io]-[raw]-[pin]
+ * [io]-[raw]-[id]-[pin]
+ * [io]-[raw]-[path]
+ *
+ * @param IO description
+ *
+ * @return void* to IO context or NULL
+ */
+void* mraa_init_io(const char* desc);
+
+/**
+ * Instantiate an unknown board using a json file
+ *
+ * @param Path to the json file, relative to the folder the program
+ * was initially run in or a direct path
+ *
+ * @return mraa_result indicating success
+ */
+mraa_result_t mraa_init_json_platform(const char* path);
+
 #ifdef __cplusplus
 }
 #endif

api/mraa/common.hpp

@@ -309,4 +309,36 @@ removeSubplatform(Platform subplatformtype)
     return (Result) mraa_remove_subplatform((mraa_platform_t) subplatformtype);
 }
 
+/**
+ * Create IO using a description in the format:
+ * [io]-[pin]
+ * [io]-[raw]-[pin]
+ * [io]-[raw]-[id]-[pin]
+ * [io]-[raw]-[path]
+ *
+ * @param IO description
+ *
+ * @return class T initialised using pointer to IO or NULL
+ */
+template <class T>
+inline T*
+initIo(std::string desc)
+{
+    return new T(mraa_init_io(desc.c_str()));
+}
+
+/**
+ * Instantiate an unknown board using a json file
+ *
+ * @param Path to the json file, relative to the folder the program
+ * was initially run in or a direct path
+ *
+ * @return Result indicating success
+ */
+inline Result
+initJsonPlatform(std::string path)
+{
+    return (Result) mraa_init_json_platform(path.c_str());
+}
+
 }

api/mraa/gpio.hpp

@@ -107,6 +107,19 @@ class Gpio
             mraa_gpio_owner(m_gpio, 0);
         }
     }
+    /**
+     * Gpio Constructor, takes a pointer to the GPIO context and initialises
+     * the GPIO class
+     *
+     * @param void * to GPIO context
+     */
+    Gpio(void* gpio_context)
+    {
+        m_gpio = (mraa_gpio_context) gpio_context;
+        if (m_gpio == NULL) {
+            throw std::invalid_argument("Invalid GPIO context");
+        }
+    }
     /**
      * Gpio object destructor, this will only unexport the gpio if we where
      * the owner

api/mraa/i2c.hpp

@@ -62,6 +62,18 @@ class I2c
             throw std::invalid_argument("Invalid i2c bus");
         }
     }
+    /**
+     * I2C constructor, takes a pointer to a I2C context and initialises the I2C class
+     *
+     * @param void * to an I2C context
+     */
+    I2c(void* i2c_context)
+    {
+        m_i2c = (mraa_i2c_context) i2c_context;
+        if (m_i2c == NULL) {
+            throw std::invalid_argument("Invalid I2C context");
+        }
+    }
 
     /**
      * Closes the I2c Bus used. This does not guarrantee the bus will not

api/mraa/iio.h

@@ -121,7 +121,7 @@ mraa_result_t mraa_iio_event_extract_event(struct iio_event_data* event,
                                            int* channel2,
                                            int* different);
 
-mraa_result_t mraa_iio_get_mounting_matrix(mraa_iio_context dev, float mm[9]);
+mraa_result_t mraa_iio_get_mount_matrix(mraa_iio_context dev, const char *sysfs_name, float mm[9]);
 
 mraa_result_t mraa_iio_create_trigger(mraa_iio_context dev, const char* trigger);
 

api/mraa/iio_kernel_headers.h

@@ -106,7 +106,12 @@ enum iio_event_direction {
 };
 
 //linux/iio/events.h
+#if defined(MSYS)
+#define __USE_LINUX_IOCTL_DEFS
+#include <sys/ioctl.h>
+#else
 #include <linux/ioctl.h>
+#endif
 
 /**
  * struct iio_event_data - The actual event being pushed to userspace

api/mraa/pwm.hpp

@@ -66,6 +66,20 @@ class Pwm
             mraa_pwm_owner(m_pwm, 0);
         }
     }
+
+    /**
+     * Pwm constructor, takes a pointer to the PWM context and
+     * initialises the class
+     *
+     * @param void * to a PWM context
+     */
+    Pwm(void* pwm_context)
+    {
+        m_pwm = (mraa_pwm_context) pwm_context;
+        if (m_pwm == NULL) {
+            throw std::invalid_argument("Invalid PWM context");
+        }
+    }
     /**
      * Pwm destructor
      */

api/mraa/spi.hpp

@@ -79,6 +79,20 @@ class Spi
         }
     }
 
+    /**
+     * Spi Constructor, takes a pointer to a SPI context and initialises
+     * the SPI class
+     *
+     * @param void * to SPI context
+     */
+    Spi(void* spi_context)
+    {
+        m_spi = (mraa_spi_context) spi_context;
+        if (m_spi == NULL) {
+            throw std::invalid_argument("Invalid SPI context");
+        }
+    }
+
     /**
      * Closes spi bus
      */

api/mraa/types.h

@@ -50,6 +50,7 @@ typedef enum {
     MRAA_INTEL_SOFIA_3GR = 10,      /**< The Intel SoFIA 3GR */
     MRAA_INTEL_CHERRYHILLS = 11,     /**< The Intel Braswell Cherryhills */
     MRAA_UP = 12,                    /**< The UP Board */
+    MRAA_INTEL_GT_TUCHUCK = 13,      /**< The Intel GT Tuchuck Board */
 
     // USB platform extenders start at 256
     MRAA_FTDI_FT4222 = 256,         /**< FTDI FT4222 USB to i2c bridge */
@@ -57,6 +58,8 @@ typedef enum {
     // contains bit 9 so is subplatform
     MRAA_GENERIC_FIRMATA = 1280,    /**< Firmata uart platform/bridge */
 
+    MRAA_MOCK_PLATFORM = 96,        /**< Mock platform, which requires no real hardware */
+    MRAA_JSON_PLATFORM = 97,        /**< User initialised platform from json*/
     MRAA_NULL_PLATFORM = 98,        /**< Platform with no capabilities that hosts a sub platform  */
     MRAA_UNKNOWN_PLATFORM =
     99 /**< An unknown platform type, typically will load INTEL_GALILEO_GEN1 */

api/mraa/types.hpp

@@ -50,6 +50,8 @@ typedef enum {
     A96BOARDS = 9,             /**< Linaro 96boards, A prefix for 'ARM' since not allowed numerical */
     INTEL_SOFIA_3GR = 10,      /**< The Intel SoFIA 3GR */
     INTEL_CHERRYHILLS = 11,    /**< The Intel Braswell Cherryhills */
+    INTEL_UP = 12,             /**< The UP Board */
+    INTEL_GT_TUCHUCK = 13,     /**< The Intel GT Board */
 
     FTDI_FT4222 = 256,         /**< FTDI FT4222 USB to i2c bridge */
 

api/mraa/uart.hpp

@@ -75,6 +75,20 @@ class Uart
         }
     }
 
+    /**
+     * Uart Constructor, takes a pointer to the UART context and initialises
+     * the UART class
+     *
+     * @param void * to a UART context
+     */
+    Uart(void* uart_context)
+    {
+        m_uart = (mraa_uart_context) uart_context;
+
+        if (m_uart == NULL) {
+            throw std::invalid_argument("Invalid UART context");
+        }
+    }
     /**
      * Uart destructor
      */

cmake/modules/FindJSON-C.cmake

@@ -3,7 +3,7 @@
 # JSON-C_LIBRARIES - library directories
 
 find_package (PkgConfig)
-pkg_check_modules (PC_JSON-C QUIET json-c)
+pkg_search_module (PC_JSON-C QUIET json-c json)
 
 find_path (JSON-C_INCLUDE_DIR json.h HINTS ${PC_JSON-C_INCLUDEDIR}
 ${PC_JSON-C_INCLUDE_DIRS} PATH_SUFFIXES json-c json)

cmake/modules/OpenCVDetectPython.cmake

@@ -0,0 +1,160 @@
+# Find specified Python version
+# Arguments:
+#   preferred_version (value): Version to check for first
+#   min_version (value): Minimum supported version
+#   library_env (value): Name of Python library ENV variable to check
+#   include_dir_env (value): Name of Python include directory ENV variable to check
+#   found (variable): Set if interpreter found
+#   executable (variable): Output of executable found
+#   version_string (variable): Output of found version
+#   version_major (variable): Output of found major version
+#   version_minor (variable): Output of found minor version
+#   libs_found (variable): Set if libs found
+#   libs_version_string (variable): Output of found libs version
+#   libraries (variable): Output of found Python libraries
+#   library (variable): Output of found Python library
+#   debug_libraries (variable): Output of found Python debug libraries
+#   debug_library (variable): Output of found Python debug library
+#   include_path (variable): Output of found Python include path
+#   include_dir (variable): Output of found Python include dir
+#   include_dir2 (variable): Output of found Python include dir2
+#   packages_path (variable): Output of found Python packages path
+function(find_python preferred_version min_version library_env include_dir_env
+         found executable version_string version_major version_minor
+         libs_found libs_version_string libraries library debug_libraries
+         debug_library include_path include_dir include_dir2 packages_path)
+if(NOT ${found})
+  if(${executable})
+    set(PYTHON_EXECUTABLE "${${executable}}")
+  endif()
+
+  find_package(PythonInterp "${preferred_version}")
+  if(NOT PYTHONINTERP_FOUND)
+    find_package(PythonInterp "${min_version}")
+  endif()
+
+  if(PYTHONINTERP_FOUND)
+    # Copy outputs
+    set(_found ${PYTHONINTERP_FOUND})
+    set(_executable ${PYTHON_EXECUTABLE})
+    set(_version_string ${PYTHON_VERSION_STRING})
+    set(_version_major ${PYTHON_VERSION_MAJOR})
+    set(_version_minor ${PYTHON_VERSION_MINOR})
+    set(_version_patch ${PYTHON_VERSION_PATCH})
+
+    # Clear find_host_package side effects
+    unset(PYTHONINTERP_FOUND)
+    unset(PYTHON_EXECUTABLE CACHE)
+    unset(PYTHON_VERSION_STRING)
+    unset(PYTHON_VERSION_MAJOR)
+    unset(PYTHON_VERSION_MINOR)
+    unset(PYTHON_VERSION_PATCH)
+  endif()
+
+  if(_found)
+    set(_version_major_minor "${_version_major}.${_version_minor}")
+
+    if(NOT ANDROID AND NOT APPLE_FRAMEWORK)
+      # not using _version_string here, because it might not conform to the CMake version format
+      if(CMAKE_CROSSCOMPILING)
+        # builder version can differ from target, matching base version (e.g. 2.7)
+        find_package(PythonLibs "${_version_major_minor}")
+      else()
+        find_package(PythonLibs "${_version_major_minor}.${_version_patch}" EXACT)
+      endif()
+
+      if(PYTHONLIBS_FOUND)
+        # Copy outputs
+        set(_libs_found ${PYTHONLIBS_FOUND})
+        set(_libraries ${PYTHON_LIBRARIES})
+        set(_include_path ${PYTHON_INCLUDE_PATH})
+        set(_include_dirs ${PYTHON_INCLUDE_DIRS})
+        set(_debug_libraries ${PYTHON_DEBUG_LIBRARIES})
+        set(_libs_version_string ${PYTHONLIBS_VERSION_STRING})
+        set(_debug_library ${PYTHON_DEBUG_LIBRARY})
+        set(_library ${PYTHON_LIBRARY})
+        set(_library_debug ${PYTHON_LIBRARY_DEBUG})
+        set(_library_release ${PYTHON_LIBRARY_RELEASE})
+        set(_include_dir ${PYTHON_INCLUDE_DIR})
+        set(_include_dir2 ${PYTHON_INCLUDE_DIR2})
+
+        # Clear find_package side effects
+        unset(PYTHONLIBS_FOUND)
+        unset(PYTHON_LIBRARIES)
+        unset(PYTHON_INCLUDE_PATH)
+        unset(PYTHON_INCLUDE_DIRS)
+        unset(PYTHON_DEBUG_LIBRARIES)
+        unset(PYTHONLIBS_VERSION_STRING)
+        unset(PYTHON_DEBUG_LIBRARY CACHE)
+        unset(PYTHON_LIBRARY)
+        unset(PYTHON_LIBRARY_DEBUG)
+        unset(PYTHON_LIBRARY_RELEASE)
+        unset(PYTHON_LIBRARY CACHE)
+        unset(PYTHON_LIBRARY_DEBUG CACHE)
+        unset(PYTHON_LIBRARY_RELEASE CACHE)
+        unset(PYTHON_INCLUDE_DIR CACHE)
+        unset(PYTHON_INCLUDE_DIR2 CACHE)
+      endif()
+    endif()
+
+    execute_process(COMMAND ${_executable} -c "from distutils.sysconfig import *; print(get_python_lib())"
+                    RESULT_VARIABLE _cvpy_process
+                    OUTPUT_VARIABLE _std_packages_path
+                    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if("${_std_packages_path}" MATCHES "site-packages")
+      set(_packages_path "python${_version_major_minor}/site-packages")
+    else() #debian based assumed, install to the dist-packages.
+      set(_packages_path "python${_version_major_minor}/dist-packages")
+    endif()
+      if(EXISTS "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/${${packages_path}}")
+        set(_packages_path "lib${LIB_SUFFIX}/${_packages_path}")
+      else()
+        set(_packages_path "lib/${_packages_path}")
+    endif()
+  endif()
+
+  # Export return values
+  set(${found} "${_found}" CACHE INTERNAL "")
+  set(${executable} "${_executable}" CACHE FILEPATH "Path to Python interpretor")
+  set(${version_string} "${_version_string}" CACHE INTERNAL "")
+  set(${version_major} "${_version_major}" CACHE INTERNAL "")
+  set(${version_minor} "${_version_minor}" CACHE INTERNAL "")
+  set(${libs_found} "${_libs_found}" CACHE INTERNAL "")
+  set(${libs_version_string} "${_libs_version_string}" CACHE INTERNAL "")
+  set(${libraries} "${_libraries}" CACHE INTERNAL "Python libraries")
+  set(${library} "${_library}" CACHE FILEPATH "Path to Python library")
+  set(${debug_libraries} "${_debug_libraries}" CACHE INTERNAL "")
+  set(${debug_library} "${_debug_library}" CACHE FILEPATH "Path to Python debug")
+  set(${include_path} "${_include_path}" CACHE INTERNAL "")
+  set(${include_dir} "${_include_dir}" CACHE PATH "Python include dir")
+  set(${include_dir2} "${_include_dir2}" CACHE PATH "Python include dir 2")
+  set(${packages_path} "${_packages_path}" CACHE PATH "Where to install the python packages.")
+endif()
+endfunction(find_python)
+
+set(MIN_VER_PYTHON2 2.7)
+set(MIN_VER_PYTHON3 3.2)
+
+find_python(2.7 "${MIN_VER_PYTHON2}" PYTHON2_LIBRARY PYTHON2_INCLUDE_DIR
+    PYTHON2INTERP_FOUND PYTHON2_EXECUTABLE PYTHON2_VERSION_STRING
+    PYTHON2_VERSION_MAJOR PYTHON2_VERSION_MINOR PYTHON2LIBS_FOUND
+    PYTHON2LIBS_VERSION_STRING PYTHON2_LIBRARIES PYTHON2_LIBRARY
+    PYTHON2_DEBUG_LIBRARIES PYTHON2_LIBRARY_DEBUG PYTHON2_INCLUDE_PATH
+    PYTHON2_INCLUDE_DIR PYTHON2_INCLUDE_DIR2 PYTHON2_PACKAGES_PATH)
+
+find_python(3 "${MIN_VER_PYTHON3}" PYTHON3_LIBRARY PYTHON3_INCLUDE_DIR
+    PYTHON3INTERP_FOUND PYTHON3_EXECUTABLE PYTHON3_VERSION_STRING
+    PYTHON3_VERSION_MAJOR PYTHON3_VERSION_MINOR PYTHON3LIBS_FOUND
+    PYTHON3LIBS_VERSION_STRING PYTHON3_LIBRARIES PYTHON3_LIBRARY
+    PYTHON3_DEBUG_LIBRARIES PYTHON3_LIBRARY_DEBUG PYTHON3_INCLUDE_PATH
+    PYTHON3_INCLUDE_DIR PYTHON3_INCLUDE_DIR2 PYTHON3_PACKAGES_PATH)
+
+if(PYTHON_DEFAULT_EXECUTABLE)
+    set(PYTHON_DEFAULT_AVAILABLE "TRUE")
+elseif(PYTHON2INTERP_FOUND) # Use Python 2 as default Python interpreter
+    set(PYTHON_DEFAULT_AVAILABLE "TRUE")
+    set(PYTHON_DEFAULT_EXECUTABLE "${PYTHON2_EXECUTABLE}")
+elseif(PYTHON3INTERP_FOUND) # Use Python 2 as fallback Python interpreter (if there is no Python 2)
+    set(PYTHON_DEFAULT_AVAILABLE "TRUE")
+    set(PYTHON_DEFAULT_EXECUTABLE "${PYTHON3_EXECUTABLE}")
+endif()

docs/building.md

@@ -92,10 +92,6 @@ Building doc, this will require [SPHINX](http://sphinx-doc.org) &
 [Doxygen](http://doxygen.org):
  `-DBUILDDOC=ON`
 
-Building with Python 3 (careful you need to clear CMake cache between Python
-version switches!)
- `-DBUILDPYTHON3=ON`
-
 Override build architecture (this is useful because on x86 ARM code is not
 compiled so use this flag to force the target arch)
  `-DBUILDARCH=arm`

docs/changelog.md

@@ -5,6 +5,44 @@ This changelog is meant as a quick & rough guide to what has changed between
 versions. The API is now fairly stable but when new calls/features are added
 they are listed here. Anything pre 0.2.x is ignored.
 
+**1.2.3**
+  * Revert 1.2.1 binding.gyp changed that had side effect of enabling JSONPLAT in mraa.c
+  * improve travis.ci to load mraa.node as compiled from make npmpkg target
+
+**1.2.2**
+  * remove jsonplat from prehashed npm builds (see docs/npm.md for details)
+  * internal spelling fix
+
+**1.2.1**
+  * Fix npm pkg build - no other fix
+
+**1.2.0**
+  * JSON platform support
+  * mock I2c functionality
+  * Intel Grosse Tete PWM fix
+  * AIO firmata bug fix
+
+**1.1.2**
+  * Mock platform support
+  * mraa-i2c treats i2c buses by default as linux
+  * grosse tete i2c fixes
+  * travis now uses 14.04 instead of 12.04
+
+**1.1.1**
+  * IIO 4.6 kernel matrix support
+  * Intel Grosse Tete radio led support
+  * mraa_init_io() examples
+  * MRAAPLATFORMFORCE fixes
+  * fix python documentation
+
+**1.1.0**
+  * build python2 & python3 bindings
+  * Intel Grosse Tete support
+  * mraa_init_io() generic funtion
+  * mraa-gpio fixes
+  * edison PWM 0% improvements
+  * iio location maping fix
+
 **1.0.0**
   * Change API to enhance error checking in C. Changes include:
     - mraa_aio_read

docs/grossetete.md

@@ -0,0 +1,112 @@
+Grosse Tete {#grossetete}
+===========
+
+The Grosse Tete with the Tuchuck board is supported by Mraa
+
+Revision Support
+----------------
+Tuchuck
+
+Interface notes
+---------------
+
+**SPI** Currently not working
+
+**UART** Some pins are labelled as UARTs but are not configured in BIOS as UART
+so only available UART is on the FTDI header
+
+Pin Mapping
+-----------
+
+Tuchuck has two breakouts, breakout #1 is 1-40 whilst breakout2 is 41-80. The
+LEDs are numbered from 100-103.
+
+| MRAA Number | Physical Pin | Function |
+|-------------|--------------|----------|
+| 1           | GPIO         | GPIO     |
+| 2           | SPP1RX       | GPIO     |
+| 3           | PMICRST      | NONE     |
+| 4           | SPP1TX       | GPIO     |
+| 5           | 19.2mhz      | GPIO     |
+| 6           | SPP1FS0      | GPIO     |
+| 7           | UART0TX      | GPIO     |
+| 8           | SPP1FS2      | GPIO     |
+| 9           | PWRGD        | NONE     |
+| 10          | SPP1CLK      | GPIO     |
+| 11          | I2C0SDA      | I2C      |
+| 12          | I2S1SDI      | GPIO     |
+| 13          | I2C0SCL      | I2C      |
+| 14          | I2S1SDO      | GPIO     |
+| 15          | I2C1SDA      | I2C      |
+| 16          | I2S1WS       | GPIO     |
+| 17          | I2C1SCL      | I2C      |
+| 18          | I2S1CLK      | GPIO     |
+| 19          | I2C2SDA      | I2C      |
+| 20          | I2S1MCL      | GPIO     |
+| 21          | I2C2SCL	     | I2CO     |
+| 22          | UART1TX	     | UART     |
+| 23          | I2S4SDO      | NONE     |
+| 24          | UART1RX      | UART     |
+| 25          | I2S4SDI	     | NONE     |
+| 26          | PWM0         | GPIO PWM |
+| 27          | I2S4BLK      | GPIO     |
+| 28          | PWM1         | GPIO PWM |
+| 29          | I2S4WS       | NONE     |
+| 30          | PWM2         | GPIO PWM |
+| 31          | I2S3SDO      | NONE     |
+| 32          | PWM3         | GPIO PWM |
+| 33          | I2S3SDI      | NONE     |
+| 34          | 1.8V         | NONE     |
+| 35          | I2S4BLK      | GPIO     |
+| 36          | GND          | NONE     |
+| 37          | GND          | NONE     |
+| 38          | GND          | NONE     |
+| 39          | GND          | NONE     |
+| 40          | 3.3V         | NONE     |
+| 41          | GND          | NONE     |
+| 42          | 5V           | NONE     |
+| 43          | GND          | NONE     |
+| 44          | 5V           | NONE     |
+| 45          | GND          | NONE     |
+| 46          | 3.3V         | NONE     |
+| 47          | GND          | NONE     |
+| 48          | 3.3V         | NONE     |
+| 49          | GND          | NONE     |
+| 50          | 1.8V         | NONE     |
+| 51          | GPIO         | GPIO     |
+| 52          | 1.8V         | NONE     |
+| 53          | PANEL        | GPIO     |
+| 54          | GND          | NONE     |
+| 55          | PANEL        | GPIO     |
+| 56          | CAMERA       | NONE     |
+| 57          | PANEL        | GPIO     |
+| 58          | CAMERA       | NONE     |
+| 59          | SPP0FS0      | GPIO     |
+| 60          | CAMERA       | NONE     |
+| 61          | SPP0FS1      | GPIO     |
+| 62          | SPI_DAT      | SPI      |
+| 63          | SPP0FS2      | GPIO     |
+| 64          | SPICLKB      | GPIO SPI |
+| 65          | SPP0FS3      | GPIO     |
+| 66          | SPICLKA      | GPIO SPI |
+| 67          | SPP0TX       | GPIO     |
+| 68          | UART0RX      | GPIO UART|
+| 69          | SPP0RX       | GPIO     |
+| 70          | UART0RT      | GPIO UART|
+| 71          | I2C1SDA      | GPIO I2C |
+| 72          | UART0CT      | GPIO UART|
+| 73          | I2C1SCL      | GPIO I2C |
+| 74          | UART1TX      | GPIO UART|
+| 75          | I2C2SDA      | GPIO I2C |
+| 76          | UART1RX      | GPIO UART|
+| 77          | I2C1SCL      | GPIO I2C |
+| 78          | UART1RT      | GPIO UART|
+| 79          | RTC_CLK      | GPIO     |
+| 80          | UART1CT      | GPIO UART|
+| 100         | LED100       | GPIO     |
+| 101         | LED101       | GPIO 	|
+| 102         | LED102       | GPIO 	|
+| 103         | LED103       | GPIO 	|
+
+To see a live pin mapping use the command:
+$ mraa-gpio list

docs/index.java.md

@@ -46,6 +46,8 @@ Specific platform information for supported platforms is documented here:
 - @ref bananapi
 - @ref beaglebone
 - @ref nuc5
+- @ref up
+- @ref grossetete
 - @ref ft4222
 
 ## DEBUGGING

docs/index.md

@@ -47,6 +47,7 @@ Specific platform information for supported platforms is documented here:
 - @ref beaglebone
 - @ref nuc5
 - @ref up
+- @ref grossetete
 - @ref ft4222
 
 ## DEBUGGING

docs/mock.md

@@ -0,0 +1,92 @@
+Mock platform   {#mock}
+=============
+
+Mocking capability allows libmraa user to work with the library without any real
+hardware available. Enabling this requires library recompilation with architecture
+override (see Building section below). When mock is enabled, library simulates
+actual HW operations at the backend so that for the application it looks
+like a usual board. Being implemented at the backend, the functionality is available
+in all language bindings libmraa supports.
+
+Board configuration
+-------------------
+
+This feature is yet in the experimental mode and not all functionality is available.
+Right now we simulate a single generic board with:
+* GPIO (without ISR)
+* ADC with 10 (std)/12 (max) bit resolution, which returns random values on read
+* Single I2C bus with one device at address 0x33 and 10 bytes of register space,
+which can be read or written in bytes or words (big-endian). Technically those
+registers are just an array of `uint8_t`, so you can treat them as 10 single-byte
+registers or 5 single-word ones or a mix thereof.
+
+We plan to develop it further and all [contributions](../CONTRIBUTING.md) are more than welcome.
+
+See the table below for pin layout and features
+
+| MRAA Number | Pin Name |            Notes                      |
+|-------------|----------|---------------------------------------|
+| 0           | GPIO0    | GPIO pin, no muxing, no ISR           |
+| 1           | ADC0     | AIO pin, returns random value on read |
+| 2           | I2C0SDA  | SDA pin for I2C0 bus                  |
+| 3           | I2C0SCL  | SCL pin for I2C0 bus                  |
+
+Building
+--------
+
+Generally all the building steps are the same as listed
+in the [main building guide](./building.md), you just need to set some specific
+CMake options.
+
+### Linux
+
+To build under Linux, follow standard instructions, just make sure to set
+the `-DBUILDARCH="MOCK"` CMake option.
+
+### Windows
+
+Mocking capability allows us to build and use libmraa under Windows. That helps
+if you e.g. don't want to leave your customary Windows-based Python IDE, but
+want to develop libmraa-based programs.
+
+Building Node.js bindings was not yet tested under Windows as MSYS2
+does not have a ready-made package. Java was not tested either.
+
+#### Prerequisites
+
+You'll need the following to build libmraa under Windows:
+
+* [MSYS2](http://mingw-w64.org/doku.php/download/msys2) basic installation
+* Several additional packages, install them by running
+
+  ```bash
+  pacman -S cmake base-devel gcc git
+  ```
+
+#### Compiling
+
+The procedure is conceptually the same as under Linux - you first need to run
+CMake with specific options to generate makefiles and then run make to build everything.
+
+* Run MSYS2 shell (not a MinGW one)
+* Clone the libmraa git repo (let's assume into `/home/test/mraa/mraa-src` dir)
+* Create a build directory outside of the clone one (let's say `/home/test/mraa/mraa-build`)
+* Run CMake, switching off unsupported options and enabling mock platform:
+
+  ```bash
+  cmake ../mraa-src/ -DBUILDARCH="MOCK" -DBUILDSWIGNODE=OFF -DENABLEEXAMPLES=OFF
+  ```
+
+* Make, install and test:
+
+  ```bash
+  make clean && make install && make test
+  ```
+
+  All tests should pass.
+
+**Note:** To have autocompletion in Python IDE, just point it to MSYS2's Python
+and make sure to specify any additional paths pointing to site-packages dir
+with mraa module if IDE requires that ("Interpreter Paths" in PyCharm).
+With the above settings the module will be installed into `/usr/local/lib/python2.7/site-packages`
+and the libmraa itself - into `/usr/local/bin`.

examples/c++/initio.cpp

@@ -0,0 +1,68 @@
+/*
+ * Author: Houman Brinjcargorabi <houman.brinjcargorabi@intel.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+
+#include "mraa.hpp"
+
+int main()
+{
+    // GPIO-PIN
+    mraa::Gpio* gpio = mraa::initIo<mraa::Gpio>("gpio-1");
+    // GPIO-RAW-RAWPIN
+    mmraa::Gpio* gpioraw = mraa::initIo<mraa::Gpio>initIo("gpio-raw-131");
+    // AIO-PIN
+    mraa::Aio aio = mraa::initIo<mraa::Aio>("aio-0");
+    // PWM-PIN
+    mraa::Pwm pwm = mraa::initIo<mraa::Pwm>("pwm-6");
+    // PWM-RAW-CHIPID-PIN
+    mraa::Pwm pwmraw = mraa::initIo<mraa::Pwm>("pwm-raw-0,1");
+    // UART-INDEX: the index is the one represented internally in the uart_dev array
+    mraa::Uart uart = mraa::initIo<mraa::Uart>("uart-1");
+    // UART-RAW-PATH
+    mraa::Uart uartraw = mraa::initIo<mraa::Uart>("uart-raw-/dev/ttyS0");
+    // SPI-INDEX: same as UART
+    mraa::Spi spi = mraa::initIo<mraa::Spi>("spi-0");
+    // SPI-RAW-BUS-CS: USED to open and use /dev/spidev<BUS>.<CS>
+    mraa::Spi spiraw = mraa::initIo<mraa::Spi>("spi-raw-0-1");
+    // I2C-INDEX: same as UART
+    mraa::I2c i2c = mraa::initIo<mraa::I2c>("i2c-0");
+    // I2C-RAW-BUS
+    mraa::I2c i2craw = mraa::initIo<mraa::I2c>("i2c-raw-0");
+
+    // FREE STUFF
+    delete gpio;
+    delete gpioraw;
+    delete aio;
+    delete pwm;
+    delete pwmraw;
+    delete uart;
+    delete uartraw;
+    delete spi;
+    delete spiraw;
+    delete i2c;
+    delete i2craw;
+}

examples/initio.c

@@ -0,0 +1,69 @@
+/*
+ * Author: Houman Brinjcargorabi <houman.brinjcargorabi@intel.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+
+#include "mraa.h"
+
+int main()
+{
+    // GPIO-PIN
+    mraa_gpio_context gpio = (mraa_gpio_context) init_io("gpio-1");
+    // GPIO-RAW-RAWPIN
+    mraa_gpio_context gpioraw = (mraa_gpio_context) init_io("gpio-raw-131");
+    // AIO-PIN
+    mraa_aio_context aio = (mraa_aio_context) init_io("aio-0");
+    // PWM-PIN
+    mraa_pwm_context pwm = (mraa_pwm_context) init_io("pwm-6");
+    // PWM-RAW-CHIPID-PIN
+    mraa_pwm_context pwmraw= (mraa_pwm_context) init_io("pwm-raw-0,1");
+    // UART-INDEX: the index is the one represented internally in the uart_dev array
+    mraa_uart_context uart = (mraa_uart_context) init_io("uart-1");
+    // UART-RAW-PATH
+    mraa_uart_context uartraw = (mraa_uart_context) init_io("uart-raw-/dev/ttyS0");
+    // SPI-INDEX: same as UART
+    mraa_spi_context spi = (mraa_spi_context) init_io("spi-0");
+    // SPI-RAW-BUS-CS: USED to open and use /dev/spidev<BUS>.<CS>
+    mraa_spi_context spiraw = (mraa_spi_context) init_io("spi-raw-0-1");
+    // I2C-INDEX: same as UART
+    mraa_i2c_context i2c = (mraa_i2c_context) init_io("i2c-0");
+    // I2C-RAW-BUS
+    mraa_i2c_context i2craw = (mraa_i2c_context) init_io("i2c-raw-0");
+
+
+    // FREE STUFF
+    mraa_gpio_close(gpio);
+    mraa_gpio_close(gpioraw);
+    mraa_aio_close(aio);
+    mraa_pwm_close(pwm);
+    mraa_pwm_close(pwmraw);
+    mraa_uart_close(uart);
+    mraa_uart_close(uartraw);
+    mraa_spi_close(spi);
+    mraa_spi_close(spiraw);
+    mraa_i2c_close(i2c);
+    mraa_i2c_close(i2craw);
+}

examples/javascript/initio.js

@@ -0,0 +1,48 @@
+/*
+ * Author: Houman Brinjcargorabi <houman.brinjcargorabi@intel.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * 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.
+ */
+
+var m = require('mraa');
+
+// GPIO-PIN
+m.gpioFromDesc("gpio-1");
+// GPIO-RAW-RAWPIN
+m.gpioFromDesc("gpio-raw-131");
+// AIO-PIN
+m.aioFromDesc("aio-1");
+//PWM-PIN
+m.pwmFromDesc("pwm-6");
+// PWM-RAW-CHIPID-PIN
+m.pwmFromDesc("pwm-raw-0-1")
+// UART-INDEX: the index is the one represented internally in the uart_dev array
+m.uartFromDesc("uart-0");
+// UART-RAW-PATH
+m.uartFromDesc("uart-raw-/dev/ttyS0");
+// SPI-INDEX: same as UART
+m.spiFromDesc("spi-0");
+// SPI-RAW-BUS-CS: USED to open and use /dev/spidev<BUS>.<CS>
+m.spiFromDesc("spi-raw-0-1");
+// I2C-INDEX: same as UART
+m.i2cFromDesc("i2c-0");
+// I2C-RAW-BUS
+m.i2cFromDesc("i2c-raw-0");

examples/mraa-gpio.c

@@ -67,7 +67,7 @@ list_platform_pins(uint8_t platform_offset)
     for (i = 0; i < pin_count; ++i) {
         int pin_id = platform_offset > 0 ? mraa_get_sub_platform_id(i) : i;
         char* pin_name = mraa_get_pin_name(pin_id);
-        if (strcmp(pin_name, "INVALID") != 0) {
+        if (strcmp(pin_name, "INVALID")  != 0 && mraa_pin_mode_test(pin_id, MRAA_PIN_VALID)) {
             fprintf(stdout, "%02d ", pin_id);
             fprintf(stdout, "%*s: ", (MRAA_PIN_NAME_SIZE - 1), pin_name);
             if (mraa_pin_mode_test(pin_id, MRAA_PIN_GPIO))
@@ -103,7 +103,13 @@ list_pins()
 mraa_result_t
 gpio_set(int pin, int level, mraa_boolean_t raw)
 {
-    mraa_gpio_context gpio = mraa_gpio_init(pin);
+    mraa_gpio_context gpio;
+    if (raw) {
+        gpio = mraa_gpio_init_raw(pin);
+    }
+    else {
+        gpio = mraa_gpio_init(pin);
+    }
     if (gpio != NULL) {
         mraa_gpio_dir(gpio, MRAA_GPIO_OUT);
         if (raw != 0) {

examples/mraa-i2c.c

@@ -65,24 +65,13 @@ print_bus(mraa_board_t* board)
     for (i = 0; i < board->i2c_bus_count; ++i) {
         char* busType;
         switch (board->platform_type) {
-            case MRAA_INTEL_GALILEO_GEN1:
-            case MRAA_INTEL_GALILEO_GEN2:
-            case MRAA_INTEL_EDISON_FAB_C:
-            case MRAA_INTEL_DE3815:
-            case MRAA_INTEL_MINNOWBOARD_MAX:
-            case MRAA_RASPBERRY_PI:
-            case MRAA_BEAGLEBONE:
-            case MRAA_BANANA:
-            case MRAA_UP:
-                bus = i;
-                busType = "linux";
-                break;
             case MRAA_FTDI_FT4222:
                 busType = "ft4222";
                 bus = mraa_get_sub_platform_id(i);
                 break;
             default:
-                busType = "unknown";
+                busType = "linux";
+                bus = i;
                 break;
         }
         int id = board->i2c_bus[i].bus_id;

examples/platform/turbotjson.json

@@ -0,0 +1,73 @@
+{
+  "version": "1.0.0",
+  "platform":[
+    {	"id":300,
+	"name":"Turbot",
+	"pin_count": 28,
+	"gpio_count": 28,
+	"i2c_count": 1,
+	"aio_count": 0,
+	"spi_count": 1,
+	"uart_count": 1,
+	"pwmDefPeriod":500,
+	"pwmMaxPeriod":1000000000,
+	"pwmMinPeriod":1
+    }
+  ],
+  "layout":[
+	{"label": "INVALID", "invalid": true},
+	{"label": "GND"},
+	{"label": "GND"},
+	{"label": "5v"},
+	{"label": "3.3v"},
+	{"label": "SPI_CS"},
+	{"label": "UART1TX"},
+	{"label": "SPIMISO"},
+	{"label": "UART1RX"},
+	{"label": "SPIMOSI"},
+	{"label": "UART1CT"},
+	{"label": "SPI_CLK"},
+	{"label": "UART1RT"},
+	{"label": "I2C_SCL"},
+	{"label": "I2S_CLK"},
+	{"label": "I2C_SDA"},
+	{"label": "I2S_FRM"},
+	{"label": "UART2TX"},
+	{"label": "I2S_DO"},
+	{"label": "UART2RX"},
+	{"label": "I2S_DI"},
+	{"label": "S5_0"},
+	{"label": "PWM0"},
+	{"label": "S5_1"},
+	{"label": "PWM1"},
+	{"label": "S5_4"},
+	{"label": "I2S_MCLK"},
+	{"label": "S5_22"}
+    ],
+    "GPIO":[
+	{ "index": 10, "rawpin": 483 },
+	{ "index": 12, "rawpin": 482 },
+	{ "index": 14, "rawpin": 472 },
+	{ "index": 16, "rawpin": 473 },
+	{ "index": 18, "rawpin": 475 },
+	{ "index": 20, "rawpin": 474 },
+	{ "index": 21, "rawpin": 338 },
+	{ "index": 23, "rawpin": 339 },
+	{ "index": 25, "rawpin": 340 },
+	{ "index": 26, "rawpin": 509 },
+	{ "index": 27, "rawpin": 360 }
+    ],
+    "I2C": [
+	{ "sclpin":13, "sdapin":15, "rawpin": 0, "index": 0, "default":true }
+    ],
+    "PWM": [
+	{ "index":22, "rawpin":0, "chipID":0},
+	{ "index":24, "rawpin":0, "chipID":1 }
+    ],
+    "SPI": [
+	{ "index":0, "chipID": 0, "clock": 11, "miso": 7, "mosi": 9, "chipselect": 5, "default": true}
+    ],
+    "UART":[
+	{ "index":0, "chipID":0, "rawpin":0, "path":"/dev/ttyS0", "default":true}
+    ]
+}

examples/python/initio.py

@@ -0,0 +1,48 @@
+#!/bin/usr/env python
+
+# Author: Houman Brinjcargorabi <houman.brinjcargorabi@intel.com>
+# Copyright (c) 2016 Intel Corporation.
+#
+# 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
+
+import mraa as m
+
+# GPIO-PIN
+m.gpioFromDesc("gpio-1");
+# GPIO-RAW-RAWPIN
+m.gpioFromDesc("gpio-raw-131");
+# AIO-PIN
+m.aioFromDesc("aio-1");
+# PWM-PIN
+m.pwmFromDesc("pwm-6");
+# PWM-RAW-CHIPID-PIN
+m.pwmFromDesc("pwm-raw-0-1")
+# UART-INDEX: the index is the one represented internally in the uart_dev array
+m.uartFromDesc("uart-0");
+# UART-RAW-PATH
+m.uartFromDesc("uart-raw-/dev/ttyS0");
+# SPI-INDEX: same as UART
+m.spiFromDesc("spi-0");
+# SPI-RAW-BUS-CS: USED to open and use /dev/spidev<BUS>.<CS>
+m.spiFromDesc("spi-raw-0-1");
+# I2C-INDEX: same as UART
+m.i2cFromDesc("i2c-0");
+# I2C-RAW-BUS
+m.i2cFromDesc("i2c-raw-0");

imraa/imraa.c

@@ -26,7 +26,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <unistd.h>

include/linux/posix_types.h

@@ -28,6 +28,8 @@ typedef struct {
 typedef void (*__kernel_sighandler_t)(int);
 typedef int __kernel_key_t;
 typedef int __kernel_mqd_t;
+#if !defined(MSYS)
 #include <asm/posix_types.h>
+#endif
 /* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
 #endif

include/linux/spi_kernel_headers.h

@@ -0,0 +1,58 @@
+/*
+ * This header was manually generated from a Linux kernel header
+ * linux/spi/spidev.h, to make information necessary for compilation
+ * to be available under MSYS. It contains only constants,
+ * structures, and macros generated from the original header, and thus,
+ * contains no copyrightable information.
+ */
+#ifndef _SPI_KERNEL_HEADERS_H
+#define _SPI_KERNEL_HEADERS_H
+
+#include <linux/types.h>
+
+#define SPI_CPHA   0x01
+#define SPI_CPOL   0x02
+
+#define SPI_MODE_0 (0|0)
+#define SPI_MODE_1 (0|SPI_CPHA)
+#define SPI_MODE_2 (SPI_CPOL|0)
+#define SPI_MODE_3 (SPI_CPOL|SPI_CPHA)
+
+#define SPI_IOC_MAGIC 'k'
+
+struct spi_ioc_transfer {
+        __u64           tx_buf;
+        __u64           rx_buf;
+
+        __u32           len;
+        __u32           speed_hz;
+
+        __u16           delay_usecs;
+        __u8            bits_per_word;
+        __u8            cs_change;
+        __u8            tx_nbits;
+        __u8            rx_nbits;
+        __u16           pad;
+};
+
+#define SPI_MSGSIZE(N) \
+        ((((N)*(sizeof (struct spi_ioc_transfer))) < (1 << _IOC_SIZEBITS)) \
+                ? ((N)*(sizeof (struct spi_ioc_transfer))) : 0)
+#define SPI_IOC_MESSAGE(N) _IOW(SPI_IOC_MAGIC, 0, char[SPI_MSGSIZE(N)])
+
+#define SPI_IOC_RD_MODE                 _IOR(SPI_IOC_MAGIC, 1, __u8)
+#define SPI_IOC_WR_MODE                 _IOW(SPI_IOC_MAGIC, 1, __u8)
+
+#define SPI_IOC_RD_LSB_FIRST            _IOR(SPI_IOC_MAGIC, 2, __u8)
+#define SPI_IOC_WR_LSB_FIRST            _IOW(SPI_IOC_MAGIC, 2, __u8)
+
+#define SPI_IOC_RD_BITS_PER_WORD        _IOR(SPI_IOC_MAGIC, 3, __u8)
+#define SPI_IOC_WR_BITS_PER_WORD        _IOW(SPI_IOC_MAGIC, 3, __u8)
+
+#define SPI_IOC_RD_MAX_SPEED_HZ         _IOR(SPI_IOC_MAGIC, 4, __u32)
+#define SPI_IOC_WR_MAX_SPEED_HZ         _IOW(SPI_IOC_MAGIC, 4, __u32)
+
+#define SPI_IOC_RD_MODE32               _IOR(SPI_IOC_MAGIC, 5, __u32)
+#define SPI_IOC_WR_MODE32               _IOW(SPI_IOC_MAGIC, 5, __u32)
+
+#endif

include/mock/mock_board.h

@@ -0,0 +1,40 @@
+/*
+ * Author: Alex Tereschenko <alext.mkrs@gmail.com>
+ * Copyright (c) 2016 Alex Tereschenko.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "mraa_internal.h"
+
+#define MRAA_MOCK_PINCOUNT 4
+
+mraa_board_t*
+mraa_mock_board();
+
+#ifdef __cplusplus
+}
+#endif

include/mock/mock_board_aio.h

@@ -0,0 +1,44 @@
+/*
+ * Author: Alex Tereschenko <alext.mkrs@gmail.com>
+ * Copyright (c) 2016 Alex Tereschenko.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "mraa_internal.h"
+
+mraa_result_t
+mraa_mock_aio_init_internal_replace(mraa_aio_context dev, int pin);
+
+mraa_result_t
+mraa_mock_aio_close_replace(mraa_aio_context dev);
+
+int
+mraa_mock_aio_read_replace(mraa_aio_context dev);
+
+#ifdef __cplusplus
+}
+#endif

include/mock/mock_board_gpio.h

@@ -0,0 +1,65 @@
+/*
+ * Author: Alex Tereschenko <alext.mkrs@gmail.com>
+ * Copyright (c) 2016 Alex Tereschenko.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "mraa_internal.h"
+
+mraa_result_t
+mraa_mock_gpio_init_internal_replace(mraa_gpio_context dev, int pin);
+
+mraa_result_t
+mraa_mock_gpio_close_replace(mraa_gpio_context dev);
+
+mraa_result_t
+mraa_mock_gpio_dir_replace(mraa_gpio_context dev, mraa_gpio_dir_t dir);
+
+mraa_result_t
+mraa_mock_gpio_read_dir_replace(mraa_gpio_context dev, mraa_gpio_dir_t* dir);
+
+int
+mraa_mock_gpio_read_replace(mraa_gpio_context dev);
+
+mraa_result_t
+mraa_mock_gpio_write_replace(mraa_gpio_context dev, int value);
+
+mraa_result_t
+mraa_mock_gpio_edge_mode_replace(mraa_gpio_context dev, mraa_gpio_edge_t mode);
+
+mraa_result_t
+mraa_mock_gpio_isr_replace(mraa_gpio_context dev, mraa_gpio_edge_t mode, void (*fptr)(void*), void* args);
+
+mraa_result_t
+mraa_mock_gpio_isr_exit_replace(mraa_gpio_context dev);
+
+mraa_result_t
+mraa_mock_gpio_mode_replace(mraa_gpio_context dev, mraa_gpio_mode_t mode);
+
+#ifdef __cplusplus
+}
+#endif

include/mock/mock_board_i2c.h

@@ -0,0 +1,81 @@
+/*
+ * Author: Alex Tereschenko <alext.mkrs@gmail.com>
+ * Copyright (c) 2016 Alex Tereschenko.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "mraa_internal.h"
+
+// Mock I2C device address
+#define MOCK_I2C_DEV_ADDR 0x33
+// Mock I2C device data registers block length in bytes. Our code assumes it's >= 1.
+#define MOCK_I2C_DEV_DATA_LEN 10
+// Initial value for each byte in the mock I2C device data registers
+#define MOCK_I2C_DEV_DATA_INIT_BYTE 0xAB
+
+mraa_result_t
+mraa_mock_i2c_init_bus_replace(mraa_i2c_context dev);
+
+mraa_result_t
+mraa_mock_i2c_stop_replace(mraa_i2c_context dev);
+
+mraa_result_t
+mraa_mock_i2c_set_frequency_replace(mraa_i2c_context dev, mraa_i2c_mode_t mode);
+
+mraa_result_t
+mraa_mock_i2c_address_replace(mraa_i2c_context dev, uint8_t addr);
+
+int
+mraa_mock_i2c_read_replace(mraa_i2c_context dev, uint8_t* data, int length);
+
+int
+mraa_mock_i2c_read_byte_replace(mraa_i2c_context dev);
+
+int
+mraa_mock_i2c_read_byte_data_replace(mraa_i2c_context dev, uint8_t command);
+
+int
+mraa_mock_i2c_read_bytes_data_replace(mraa_i2c_context dev, uint8_t command, uint8_t* data, int length);
+
+int
+mraa_mock_i2c_read_word_data_replace(mraa_i2c_context dev, uint8_t command);
+
+mraa_result_t
+mraa_mock_i2c_write_replace(mraa_i2c_context dev, const uint8_t* data, int length);
+
+mraa_result_t
+mraa_mock_i2c_write_byte_replace(mraa_i2c_context dev, const uint8_t data);
+
+mraa_result_t
+mraa_mock_i2c_write_byte_data_replace(mraa_i2c_context dev, const uint8_t data, const uint8_t command);
+
+mraa_result_t
+mraa_mock_i2c_write_word_data_replace(mraa_i2c_context dev, const uint16_t data, const uint8_t command);
+
+#ifdef __cplusplus
+}
+#endif

include/mraa_adv_func.h

@@ -48,6 +48,7 @@ typedef struct {
     mraa_result_t (*gpio_dir_replace) (mraa_gpio_context dev, mraa_gpio_dir_t dir);
     mraa_result_t (*gpio_dir_pre) (mraa_gpio_context dev, mraa_gpio_dir_t dir);
     mraa_result_t (*gpio_dir_post) (mraa_gpio_context dev, mraa_gpio_dir_t dir);
+    mraa_result_t (*gpio_read_dir_replace) (mraa_gpio_context dev, mraa_gpio_dir_t *dir);
 
     int (*gpio_read_replace) (mraa_gpio_context dev);
     mraa_result_t (*gpio_write_replace) (mraa_gpio_context dev, int value);
@@ -56,6 +57,8 @@ typedef struct {
     mraa_result_t (*gpio_mmap_setup) (mraa_gpio_context dev, mraa_boolean_t en);
     mraa_result_t (*gpio_interrupt_handler_init_replace) (mraa_gpio_context dev);
     mraa_result_t (*gpio_wait_interrupt_replace) (mraa_gpio_context dev);
+    mraa_result_t (*gpio_isr_replace) (mraa_gpio_context dev, mraa_gpio_edge_t mode, void (*fptr)(void*), void* args);
+    mraa_result_t (*gpio_isr_exit_replace) (mraa_gpio_context dev);
 
     mraa_result_t (*i2c_init_pre) (unsigned int bus);
     mraa_result_t (*i2c_init_bus_replace) (mraa_i2c_context dev);
@@ -75,6 +78,7 @@ typedef struct {
     mraa_result_t (*i2c_stop_replace) (mraa_i2c_context dev);
 
     mraa_result_t (*aio_init_internal_replace) (mraa_aio_context dev, int pin);
+    mraa_result_t (*aio_close_replace) (mraa_aio_context dev);
     int (*aio_read_replace) (mraa_aio_context dev);
     mraa_result_t (*aio_get_valid_fp) (mraa_aio_context dev);
     mraa_result_t (*aio_init_pre) (unsigned int aio);
@@ -87,7 +91,9 @@ typedef struct {
     mraa_result_t (*pwm_period_replace) (mraa_pwm_context dev, int period);
     float (*pwm_read_replace) (mraa_pwm_context dev);
     mraa_result_t (*pwm_write_replace) (mraa_pwm_context dev, float duty);
+    mraa_result_t (*pwm_write_pre) (mraa_pwm_context dev, float percentage);
     mraa_result_t (*pwm_enable_replace) (mraa_pwm_context dev, int enable);
+    mraa_result_t (*pwm_enable_pre) (mraa_pwm_context dev, int enable);
 
     mraa_result_t (*spi_init_pre) (int bus);
     mraa_result_t (*spi_init_post) (mraa_spi_context spi);

include/mraa_internal.h

@@ -37,6 +37,7 @@ extern "C" {
 #include "mraa_lang_func.h"
 
 extern mraa_board_t* plat;
+extern char* platform_name;
 extern mraa_iio_info_t* plat_iio;
 extern mraa_lang_func_t* lang_func;
 
@@ -62,6 +63,13 @@ mraa_platform_t mraa_x86_platform();
  */
 mraa_platform_t mraa_arm_platform();
 
+/**
+ * setup a mock platform
+ *
+ * @return mraa_platform_t of the init'ed platform
+ */
+mraa_platform_t mraa_mock_platform();
+
 /**
  * runtime detect running usb platform extender
  *

include/mraa_internal_types.h

@@ -40,6 +40,46 @@
 #define MRAA_IO_SETUP_FAILURE -2
 #define MRAA_NO_SUCH_IO -1
 
+// Json platform keys
+#define INDEX_KEY "index"
+#define NAME_KEY "name"
+#define PIN_COUNT_KEY "pin_count"
+#define GPIO_COUNT_KEY "gpio_count"
+#define AIO_COUNT_KEY "aio_count"
+#define SPI_COUNT_KEY "spi_count"
+#define I2C_COUNT_KEY "i2c_count"
+#define UART_COUNT_KEY "uart_count"
+#define PWMDEFAULT_KEY "pwmDefPeriod"
+#define PWMMAX_KEY "pwmMaxPeriod"
+#define PWMMIN_KEY "pwmMinPeriod"
+#define LABEL_KEY "label"
+#define DEFAULT_KEY "default"
+#define INVALID_KEY "invalid"
+#define SCLPIN_KEY "sclpin"
+#define SDAPIN_KEY "sdapin"
+#define CHIP_ID_KEY "chipID"
+#define RAW_PIN_KEY "rawpin"
+#define RXPIN_KEY "rx"
+#define TXPIN_KEY "tx"
+#define UART_PATH_KEY "path"
+#define CLOCK_KEY "clock"
+#define MISO_KEY "miso"
+#define MOSI_KEY "mosi"
+#define CS_KEY "chipselect"
+#define PIN_KEY "pin"
+#define IO_KEY "layout"
+#define PLATFORM_KEY "platform"
+
+// IO keys
+#define GPIO_KEY "GPIO"
+#define SPI_KEY "SPI"
+#define UART_KEY "UART"
+#define I2C_KEY "I2C"
+#define PWM_KEY "PWM"
+#define AIO_KEY "AIO"
+
+#define MRAA_JSONPLAT_ENV_VAR "MRAA_JSON_PLATFORM"
+
 #ifdef FIRMATA
 struct _firmata {
     /*@*/
@@ -71,6 +111,10 @@ struct _gpio {
     mraa_result_t (*mmap_write) (mraa_gpio_context dev, int value);
     int (*mmap_read) (mraa_gpio_context dev);
     mraa_adv_func_t* advance_func; /**< override function table */
+#if defined(MOCKPLAT)
+    mraa_gpio_dir_t mock_dir; /**< mock direction of the pin */
+    int mock_state; /**< mock state of the pin */
+#endif
     /*@}*/
 };
 
@@ -85,6 +129,11 @@ struct _i2c {
     unsigned long funcs; /**< /dev/i2c-* device capabilities as per https://www.kernel.org/doc/Documentation/i2c/functionality */
     void *handle; /**< generic handle for non-standard drivers that don't use file descriptors  */
     mraa_adv_func_t* advance_func; /**< override function table */
+#if defined(MOCKPLAT)
+    uint8_t mock_dev_addr; /**< address of the mock I2C device */
+    uint8_t mock_dev_data_len; /**< mock device data register block length in bytes */
+    uint8_t* mock_dev_data; /**< mock device data register block contents */
+#endif
     /*@}*/
 };
 
@@ -213,7 +262,7 @@ typedef struct {
 
 typedef struct {
     /*@{*/
-    unsigned int pinmap; /**< sysfs pin */
+    int pinmap; /**< sysfs pin */
     unsigned int parent_id; /** parent chip id */
     unsigned int mux_total; /** Numfer of muxes needed for operation of pin */
     mraa_mux_t mux[6]; /** Array holding information about mux */
@@ -237,7 +286,7 @@ typedef struct {
 typedef struct {
     /*@{*/
     char name[MRAA_PIN_NAME_SIZE]; /**< Pin's real world name */
-    mraa_pincapabilities_t capabilites; /**< Pin Capabiliites */
+    mraa_pincapabilities_t capabilities; /**< Pin Capabiliites */
     mraa_pin_t gpio; /**< GPIO structure */
     mraa_pin_t pwm;  /**< PWM structure */
     mraa_pin_t aio;  /**< Anaglog Pin */
@@ -283,7 +332,7 @@ typedef struct {
     unsigned int index; /**< ID as exposed in the system */
     int rx; /**< uart rx */
     int tx; /**< uart tx */
-    const char* device_path; /**< To store "/dev/ttyS1" for example */
+    char* device_path; /**< To store "/dev/ttyS1" for example */
     /*@}*/
 } mraa_uart_dev_t;
 
@@ -294,8 +343,8 @@ typedef struct {
 typedef struct _board_t {
     /*@{*/
     int phy_pin_count; /**< The Total IO pins on board */
-    unsigned int gpio_count; /**< GPIO Count */
-    unsigned int aio_count;  /**< Analog side Count */
+    int gpio_count; /**< GPIO Count */
+    int aio_count;  /**< Analog side Count */
     int i2c_bus_count; /**< Usable i2c Count */
     mraa_i2c_bus_t  i2c_bus[12]; /**< Array of i2c */
     unsigned int def_i2c_bus; /**< Position in array of default i2c bus */
@@ -312,7 +361,7 @@ typedef struct _board_t {
     int pwm_max_period; /**< Maximum period in us */
     int pwm_min_period; /**< Minimum period in us */
     mraa_platform_t platform_type; /**< Platform type */
-    const char* platform_name; /**< Platform Name pointer */
+    char* platform_name; /**< Platform Name pointer */
     const char* platform_version; /**< Platform versioning info */
     mraa_pininfo_t* pins;     /**< Pointer to pin array */
     mraa_adv_func_t* adv_func;    /**< Pointer to advanced function disptach table */

include/x86/intel_gt_tuchuck.h

@@ -0,0 +1,42 @@
+/*
+ * Author: Brendan Le Foll <brendan.le.foll@intel.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "mraa_internal.h"
+
+// +1 as pins are "1 indexed"
+// we have 20 useless pins then the 4 LEDS and the 2 LEDs on the module.
+#define MRAA_INTEL_GT_TUCHUCK_PINCOUNT (40*2 + 23 +1 +2)
+
+mraa_board_t*
+mraa_gt_tuchuck_board();
+
+#ifdef __cplusplus
+}
+#endif

jsstub/Gruntfile.js

@@ -0,0 +1,17 @@
+module.exports = function(grunt) {
+  grunt.loadNpmTasks('grunt-mocha-test');
+  // Project configuration.
+  grunt.initConfig({
+    pkg: grunt.file.readJSON('package.json'),
+    mochaTest: {
+      test: {
+        options: {
+          reporter: 'spec'
+        },
+        src: ['test/*.js']
+      }
+    }
+  });
+
+  grunt.registerTask('test', ['mochaTest:test']);
+};

jsstub/README.md

@@ -0,0 +1,51 @@
+mraaStub - JavaScript simulation and stubs for mraa
+====================
+
+This project enables simulation of a device which might be accessed via mraa.
+Currently this library supports I2c, SPI, and GPIO.  This project provides
+several benefits:
+
+1. Prevent crashes in nodejs applications using mraa on unsuported or
+   misconfigured hardware.
+2. Enable basic simulation of mraa-accessible devices for unit testing.
+
+## Examples
+
+The following example is based on an imaginary 'light bulb' device abstraction,
+which exposes a value of brightness over a mraa-provided interface.  Please see
+the `test/index.js` file for an example.
+
+## Installation
+
+You may install `mraaStub` from npm like this:
+
+```
+npm install mraaStub
+```
+
+Since we often switch between a mraaStub and the real mraa library, we
+suggest creating an `index.js` file inside a `lib/mraaSwitcher` folder.
+
+```js
+/* index.js - file for switching between mraa and mraaStub
+ */
+
+// Define the conditions under which the mraaStub should be loaded
+var platform = require('os').platform();
+var m;
+
+if (platform === 'win32') {
+    m = require('mraaStub');
+} else {
+    m = require('mraa');
+}
+
+module.exports = m;
+```
+
+You can add this to your project in its own `lib/mraaSwitcher/index.js` file
+and use `require('../mraaSwitcher')` everywhere!
+
+## License
+
+See [COPYING file](../COPYING) in the root of this repository.

jsstub/index.js

@@ -0,0 +1,223 @@
+/**
+ * @fileoverview This file implements a fake mraa stub which enables testing
+ * as well as the ability to run on Windows.
+ */
+
+var m;
+var winston = require('winston');
+var logger = new winston.Logger({
+        transports: [
+            new winston.transports.Console({
+                level: 'error',
+                handleExceptions: false,
+                json: false,
+                colorize: true})
+            ],
+        exitOnError: false
+    });
+
+/**
+ * @class mraaStub
+ * @classdesc This class is designed to stub out libmraa so we can run
+ * test code on unsupported platforms (specifically Windows).
+ */
+var mraaStub = function() {
+    var verison = '0.0.1';
+    var self = this;
+    self.EDGE_BOTH = 1;
+    self.EDGE_NONE = 2;
+    self.EDGE_RISING = 3;
+    self.EDGE_FALLING = 4;
+    self.DIR_IN = 1;
+    self.DIR_OUT = 2;
+
+    self.getVersion = function() {
+        return "mraaStub " + version;
+    };
+
+    // Stub out GPIO
+    function Gpio(num) {
+        this.num = num;
+        this._callback = null;
+        this._dir = null;
+        this._isr_mode = self.EDGE_NONE;
+    }
+
+    var logGpio = false;
+    Gpio.prototype._callIsr = function() {
+        if(this.isr_mode === self.EDGE_NONE) {
+            logger.log('info',"Could not call ISR.  Not set up for triggering");
+        }
+        this._callback();
+    };
+
+    Gpio.prototype.isr = function(mode, handler){
+        if(logGpio) {
+            logger.log('info',"GPIO " + this.num + " isr stub invoked.");
+        }
+        this._isr_mode = self.EDGE_NONE;
+        this._callback = handler;
+    };
+
+    Gpio.prototype.dir = function(d) {
+        if(logGpio) {
+            logger.log('info',"GPIO " + this.num + " dir stub invoked.");
+        }
+        this._dir = d;
+    };
+    Gpio.prototype.write = function(z) {
+        if(logGpio) {
+            logger.log('logger',"GPIO " + this.num + " write stub invoked.");
+        }
+        if(this._dir !== self.DIR_OUT) {
+            logger.log('info',"GPIO " + this.num + " write called without DIR_OUT set.");
+        }
+    };
+    Gpio.prototype.read = function() {
+        if(logGpio) {
+            logger.log('info',"GPIO " + this.num + " read stub invoked.");
+        }
+        return 0;
+    };
+
+    // Stub out SPI
+    function Spi(num) {
+        var self = this;
+        this.num = num;
+        this._buffer = new Buffer(29);
+        this._buffer.fill(0);
+        this._loopback = false;
+    }
+
+    Spi.prototype._setOutput = function(buf) {
+        this._buffer = buf;
+    };
+
+    Spi.prototype._enableLoopback = function(x) {
+        if(x === true) {
+            this._loopback = true;
+        } else {
+            this._loopback = false;
+        }
+    };
+
+    Spi.prototype.write = function(b) {
+        logger.log('info',"SPI write stub invoked.");
+        if(this._loopback === true) {
+            return b;
+        }
+        return new Buffer(this._buffer);
+    };
+
+    Spi.prototype.frequency = function(f) {
+        logger.log('info',"SPI frequency stub invoked.");
+        return f;
+    };
+
+    Spi.prototype.lsbmode = function(t) {
+        logger.log('info',"SPI lsbmode stub invoked.");
+    };
+
+    Spi.prototype.mode = function(x) {
+        logger.log('info',"SPI mode stub invoked.");
+    };
+
+    function I2c(num) {
+        this._num = num;
+        this._regMapInitialized = false;
+    }
+
+    /* This function sets an internal register map for the I2c device.
+     */
+    I2c.prototype._setRegisterMapInternal = function(buffer) {
+        this._regMapInitialized = true;
+        this._buffer = buffer;
+    };
+
+    I2c.prototype.frequency = function(freq) {
+        // Do nothing.  We don't care.
+    };
+
+    I2c.prototype.address = function(address) {
+        var self = this;
+        self.address = address;
+    };
+
+    I2c.prototype.readReg = function(regAddr) {
+        if(!this._regMapInitialized) {
+            logger.log('error', "Need to set reg map");
+        }
+        if(!this.address) {
+            logger.log('error', "Need to set address");
+        }
+
+        return this._buffer.readUInt8(regAddr);
+    };
+
+    I2c.prototype.readWordReg = function(regAddr) {
+        if(!this._regMapInitialized) {
+            logger.log('error', "Need to set reg map");
+        }
+        if(!this.address) {
+            logger.log('error', "Need to set address");
+        }
+
+        return this._buffer.readUInt16LE(regAddr);
+    };
+
+    I2c.prototype.readBytesReg = function(regAddr, len) {
+        if(!this._regMapInitialized) {
+            logger.log('error', "Need to set reg map");
+        }
+        if(!this.address) {
+            logger.log('error', "Need to set address");
+        }
+
+        return this._buffer.slice(regAddr,regAddr+len);
+    };
+
+    I2c.prototype.write = function(buf) {
+        if(!this._regMapInitialized) {
+            logger.log('error', "Need to set reg map");
+        }
+        if(!this.address) {
+            logger.log('error', "Need to set address");
+        }
+
+        var regAddr = buf[0];
+        var newBuf = buf.slice(1);
+        newBuf.copy(this._buffer, regAddr);
+    };
+
+    I2c.prototype.writeReg = function(regAddr, data) {
+        if(!this._regMapInitialized) {
+            logger.log('error', "Need to set reg map");
+        }
+        if(!this.address) {
+            logger.log('error', "Need to set address");
+        }
+
+        this._buffer.writeUInt8(regAddr,data);
+    };
+
+    I2c.prototype.writeWordReg = function(regAddr, dataWord) {
+        if(!this._regMapInitialized) {
+            logger.log('error', "Need to set reg map");
+        }
+        if(!this.address) {
+            logger.log('error', "Need to set address");
+        }
+
+        this._buffer.writeUInt16LE(regAddr,data);
+    };
+
+    // Export our stubs
+    self.Gpio = Gpio;
+    self.Spi = Spi;
+    self.I2c = I2c;
+
+};
+
+m = new mraaStub();
+
+module.exports = m;

jsstub/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "mraaStub",
+  "version": "0.0.1",
+  "description": "Enables simulation of mraa interfaces for testing purposes",
+  "main": "index.js",
+  "scripts": {
+    "test": "grunt test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intel-iot-devkit/mraa.git"
+  },
+  "keywords": [
+    "mraa",
+    "iot",
+    "intel",
+    "libmraa",
+    "test",
+    "galileo",
+    "edison"
+  ],
+  "author": "David A Antler <david.a.antler@intel.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/intel-iot-devkit/mraa/issues"
+  },
+  "homepage": "https://github.com/intel-iot-devkit/mraa#readme",
+  "devDependencies": {
+    "expect.js": "^0.3.1",
+    "grunt": "^1.0.1",
+    "grunt-mocha-test": "^0.12.7",
+    "mocha": "^2.4.5"
+  }
+}

jsstub/test/index.js

@@ -0,0 +1,32 @@
+var expect = require('expect.js');
+var m = require('../index');
+var LightBulb = require('./lightbulb');
+
+describe('LightBulb', function() {
+
+    /** Model the internal data of LightBulb as a buffer */
+    var bufferFullBrightness = new Buffer(
+       [ 'N',   // Four bytes allocated for name
+         'a',
+         'm',
+         'e',
+          95    // One byte allocated for brightness. Stuff in '95' value!
+       ]);
+
+    it('getBrightness() function should return 95', function() {
+
+        // Create a fake I2c bus based on the 'full brightness' data model
+        var testI2cBus = new m.I2c(0);
+        testI2cBus._setRegisterMapInternal(bufferFullBrightness);
+
+        // Create a new LightBulb that opens the testI2cBus, instead of a real
+        // mraa I2c bus.
+        var lightBulbI2c = new LightBulb(testI2cBus);
+
+        // presumably getBrightness will gather data from I2C and get '95'
+        var brightness = lightBulbI2c.getBrightness();
+
+        expect(brightness).to.be(95);
+    })
+});
+

jsstub/test/lightbulb.js

@@ -0,0 +1,32 @@
+/**
+* @fileoverview Implementation of a LightBulb class abstraction
+*
+*/
+
+module.exports = (function() {
+    "use strict";
+    var m = require('../index');
+
+    /**
+     * Constructor for a new LightBulb
+     * @class LightBulb
+     *
+     * @classdesc This class abstracts access to the control and data registers
+     * on an imaginary lightbulb.
+     * @param {Object} A libmraa I2c object, initialized
+     */
+    function LightBulb (i2cInterface) {
+        var self = this;
+        self._i2cInterface = i2cInterface;
+
+        self.getBrightness = function() {
+            // Presume our brightness data is one byte at offset 4
+            return self._i2cInterface.readReg(4);
+        }
+
+        return self;
+    }
+
+    return LightBulb;
+})();
+

src/CMakeLists.txt

@@ -41,6 +41,7 @@ set (mraa_LIB_X86_SRCS_NOAUTO
   ${PROJECT_SOURCE_DIR}/src/x86/intel_sofia_3gr.c
   ${PROJECT_SOURCE_DIR}/src/x86/intel_cherryhills.c
   ${PROJECT_SOURCE_DIR}/src/x86/up.c
+  ${PROJECT_SOURCE_DIR}/src/x86/intel_gt_tuchuck.c
 )
 
 message (STATUS "INFO - Adding support for platform ${MRAAPLATFORMFORCE}")
@@ -66,6 +67,8 @@ if (NOT ${MRAAPLATFORMFORCE} STREQUAL "ALL")
     set (mraa_LIB_X86_SRCS_NOAUTO ${PROJECT_SOURCE_DIR}/src/x86/x86.c ${PROJECT_SOURCE_DIR}/src/x86/intel_cherryhills.c)
   elseif (${MRAAPLATFORMFORCE} STREQUAL "MRAA_UP")
     set (mraa_LIB_X86_SRCS_NOAUTO ${PROJECT_SOURCE_DIR}/src/x86/x86.c ${PROJECT_SOURCE_DIR}/src/x86/up.c)
+  elseif( ${MRAAPLATFORMFORCE} STREQUAL "MRAA_INTEL_GT_TUCHUCK")
+    set (mraa_LIB_X86_SRCS_NOAUTO ${PROJECT_SOURCE_DIR}/src/x86/x86.c ${PROJECT_SOURCE_DIR}/src/x86/intel_gt_tuchuck.c)
   else ()
     message (FATAL_ERROR "Unknown x86 platform enabled!")
   endif ()
@@ -81,8 +84,27 @@ set (mraa_LIB_ARM_SRCS_NOAUTO
   ${PROJECT_SOURCE_DIR}/src/arm/banana.c
 )
 
+set (mraa_LIB_MOCK_SRCS_NOAUTO
+  ${PROJECT_SOURCE_DIR}/src/mock/mock.c
+  ${PROJECT_SOURCE_DIR}/src/mock/mock_board.c
+  ${PROJECT_SOURCE_DIR}/src/mock/mock_board_gpio.c
+  ${PROJECT_SOURCE_DIR}/src/mock/mock_board_aio.c
+  ${PROJECT_SOURCE_DIR}/src/mock/mock_board_i2c.c
+)
+
+if (JSONPLAT)
+  find_package (JSON-C QUIET)
+  if (${JSON-C_FOUND})
+    set (mraa_LIB_SRCS_NOAUTO
+      ${mraa_LIB_SRCS_NOAUTO}
+      ${PROJECT_SOURCE_DIR}/src/json/jsonplatform.c
+    )
+  endif ()
+endif ()
+
 set (mraa_LIBS ${CMAKE_THREAD_LIBS_INIT})
 
+
 if (X86PLAT)
   add_subdirectory(x86)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DX86PLAT=1")
@@ -93,6 +115,14 @@ if (ARMPLAT)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DARMPLAT=1")
 endif()
 
+if (MOCKPLAT)
+  add_subdirectory(mock)
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DMOCKPLAT=1")
+  if (MSYS)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DMSYS=1")
+  endif ()
+endif()
+
 if (USBPLAT)
   message (STATUS "INFO - Adding USB platforms")
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSBPLAT=1")
@@ -117,11 +147,24 @@ if (USBPLAT)
   add_subdirectory(usb)
 endif ()
 
-if (IMRAA)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DIMRAA=1")
-  find_package (JSON-C REQUIRED)
-  include_directories (${JSON-C_INCLUDE_DIR})
-  set (mraa_LIBS ${mraa_LIBS} ${JSON-C_LIBRARIES})
+if (JSONPLAT OR IMRAA)
+  find_package (JSON-C QUIET)
+  if (NOT ${JSON-C_FOUND})
+    if (IMRAA)
+      message (FATAL_ERROR "Enabled IMRAA but JSON-C library not found")
+    elseif (JSONPLAT)
+      message (WARNING "Enabled JSONPLAT but JSON-C library not found: Ignoring JSONPLAT")
+    endif ()
+  else ()
+    if (JSONPLAT)
+      set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DJSONPLAT=1")
+    endif ()
+    if (IMRAA)
+      set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DIMRAA=1")
+    endif ()
+    include_directories (${JSON-C_INCLUDE_DIR})
+    set (mraa_LIBS ${mraa_LIBS} ${JSON-C_LIBRARIES})
+  endif ()
 endif ()
 
 set (mraa_LIB_SRCS
@@ -193,6 +236,8 @@ if (BUILDSWIG)
       add_subdirectory (python)
     endif ()
     if (BUILDSWIGJAVA)
+      configure_file (${CMAKE_CURRENT_SOURCE_DIR}/java/manifest.txt.in
+          ${CMAKE_CURRENT_BINARY_DIR}/java/manifest.txt)
       add_subdirectory (java)
     endif ()
     if (BUILDSWIGNODE)
@@ -213,4 +258,9 @@ set_target_properties(
    SOVERSION ${mraa_VERSION_MAJOR}
    VERSION ${mraa_VERSION_STRING}
 )
-install(TARGETS mraa DESTINATION ${LIB_INSTALL_DIR})
+if (MSYS)
+  # Under MSYS we have to put our generated DLL into bin, otherwise it's not picked up
+  install(TARGETS mraa DESTINATION ${CMAKE_INSTALL_BINDIR})
+else ()
+  install(TARGETS mraa DESTINATION ${LIB_INSTALL_DIR})
+endif ()

src/aio/aio.c

@@ -113,7 +113,7 @@ mraa_aio_init(unsigned int aio)
         syslog(LOG_ERR, "aio: requested channel out of range");
         return NULL;
     }
-    if (board->pins[pin].capabilites.aio != 1) {
+    if (board->pins[pin].capabilities.aio != 1) {
         syslog(LOG_ERR, "aio: pin %i not capable of aio", pin);
         return NULL;
     }
@@ -156,6 +156,11 @@ mraa_aio_init(unsigned int aio)
 int
 mraa_aio_read(mraa_aio_context dev)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "aio: read: context is invalid");
+        return -1;
+    }
+
     if (IS_FUNC_DEFINED(dev, aio_read_replace)) {
         return dev->advance_func->aio_read_replace(dev);
     }
@@ -220,13 +225,22 @@ mraa_aio_read_float(mraa_aio_context dev)
 mraa_result_t
 mraa_aio_close(mraa_aio_context dev)
 {
-    if (NULL != dev) {
-        if (dev->adc_in_fp != -1)
-            close(dev->adc_in_fp);
-        free(dev);
+    if (dev == NULL) {
+        syslog(LOG_ERR, "aio: close: context is invalid");
+        return MRAA_ERROR_INVALID_HANDLE;
     }
 
-    return (MRAA_SUCCESS);
+    if (IS_FUNC_DEFINED(dev, aio_close_replace)) {
+        return dev->advance_func->aio_close_replace(dev);
+    }
+
+    if (dev->adc_in_fp != -1) {
+        close(dev->adc_in_fp);
+    }
+
+    free(dev);
+
+    return MRAA_SUCCESS;
 }
 
 mraa_result_t

src/arm/96boards.c

@@ -63,9 +63,9 @@ void mraa_96boards_pininfo(mraa_board_t* board, int index, int sysfs_pin,
    vsnprintf(pininfo->name, MRAA_PIN_NAME_SIZE, fmt, arg_ptr);
    va_end(arg_ptr);
    if (sysfs_pin >= 0)
-      pininfo->capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+      pininfo->capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
    else
-      pininfo->capabilites = (mraa_pincapabilities_t){ 0, 0, 0, 0, 0, 0, 0, 0 };
+      pininfo->capabilities = (mraa_pincapabilities_t){ 0, 0, 0, 0, 0, 0, 0, 0 };
    pininfo->gpio.pinmap = sysfs_pin;
    pininfo->gpio.mux_total = 0;
 }

src/arm/banana.c

@@ -305,37 +305,37 @@ mraa_banana()
     b->adv_func->gpio_mmap_setup = &mraa_banana_mmap_setup;
 
     strncpy(b->pins[0].name, "INVALID", MRAA_PIN_NAME_SIZE);
-    b->pins[0].capabilites = (mraa_pincapabilities_t){ 0, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[0].capabilities = (mraa_pincapabilities_t){ 0, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[1].name, "3V3", MRAA_PIN_NAME_SIZE);
-    b->pins[1].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[1].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[2].name, "5V", MRAA_PIN_NAME_SIZE);
-    b->pins[2].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[2].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     if (i2c2 == 1) {
         strncpy(b->pins[3].name, "TWI2-SDA", MRAA_PIN_NAME_SIZE); // PB21 Pin53 TWI2-SDA
-        b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+        b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
     } else {
         strncpy(b->pins[3].name, "PB21", MRAA_PIN_NAME_SIZE); // PB21 Pin53 TWI2-SDA
-        b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[3].gpio.pinmap = 53;
 
     strncpy(b->pins[4].name, "5V", MRAA_PIN_NAME_SIZE);
-    b->pins[4].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     if (i2c2 == 1) {
         strncpy(b->pins[5].name, "TWI2-SCK", MRAA_PIN_NAME_SIZE); // PB20 Pin52 TWI2-SCK
-        b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+        b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
     } else {
         strncpy(b->pins[5].name, "PB20", MRAA_PIN_NAME_SIZE); // PB20 Pin52 TWI2-SCK
-        b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[5].gpio.pinmap = 52;
 
     strncpy(b->pins[6].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[6].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     if (platform_detected == PLATFORM_BANANA_PRO) {
         strncpy(b->pins[7].name, "PH02", MRAA_PIN_NAME_SIZE); // PH2 Pin226
@@ -344,7 +344,7 @@ mraa_banana()
         strncpy(b->pins[7].name, "PI03", MRAA_PIN_NAME_SIZE); // PI3 Pin259 PWM
         b->pins[7].gpio.pinmap = 259;
     }
-    b->pins[7].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[7].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
 
     if (platform_detected == PLATFORM_BANANA_PRO) {
         strncpy(b->pins[8].name, "UART4_TX", MRAA_PIN_NAME_SIZE); // PH4 Pin228 UART4_TX
@@ -353,10 +353,10 @@ mraa_banana()
         strncpy(b->pins[8].name, "UART3_TX", MRAA_PIN_NAME_SIZE); // PH0 Pin224 UART3_TX
         b->pins[8].gpio.pinmap = 224;
     }
-    b->pins[8].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[8].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
 
     strncpy(b->pins[9].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[9].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[9].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     if (platform_detected == PLATFORM_BANANA_PRO) {
         strncpy(b->pins[10].name, "UART4_RX", MRAA_PIN_NAME_SIZE); // PH5 Pin229 UART4_RX
@@ -365,10 +365,10 @@ mraa_banana()
         strncpy(b->pins[10].name, "UART3_RX", MRAA_PIN_NAME_SIZE); // PH1 Pin225 UART3_RX
         b->pins[10].gpio.pinmap = 225;
     }
-    b->pins[10].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[10].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
 
     strncpy(b->pins[11].name, "PI19", MRAA_PIN_NAME_SIZE); // PI19 Pin275 IO+UART2_RX
-    b->pins[11].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[11].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[11].gpio.pinmap = 275;
 
     if (platform_detected == PLATFORM_BANANA_PRO) {
@@ -378,143 +378,143 @@ mraa_banana()
         strncpy(b->pins[12].name, "PH02", MRAA_PIN_NAME_SIZE); // PH2 Pin226
         b->pins[12].gpio.pinmap = 226;
     }
-    b->pins[12].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[12].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[13].name, "PI18", MRAA_PIN_NAME_SIZE); // PI18 Pin274 UART2_TX
-    b->pins[13].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[13].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[13].gpio.pinmap = 274;
 
     strncpy(b->pins[14].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[14].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[14].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[15].name, "PI17", MRAA_PIN_NAME_SIZE); // PI17 Pin273 UART2_CTS
-    b->pins[15].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[15].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[15].gpio.pinmap = 273;
 
     strncpy(b->pins[16].name, "PH20", MRAA_PIN_NAME_SIZE); // PH20 Pin 244 CAN_TX
-    b->pins[16].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[16].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[16].gpio.pinmap = 244;
 
     strncpy(b->pins[17].name, "3V3", MRAA_PIN_NAME_SIZE);
-    b->pins[17].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[17].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[18].name, "PH21", MRAA_PIN_NAME_SIZE); // PH21 Pin245 CAN_RX
-    b->pins[18].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[18].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[18].gpio.pinmap = 245;
 
     strncpy(b->pins[19].name, "SPI0MOSI", MRAA_PIN_NAME_SIZE); // PI12 SPI0
-    b->pins[19].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[19].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[19].gpio.pinmap = 268;
 
     strncpy(b->pins[20].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[20].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[20].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[21].name, "SPI0MISO", MRAA_PIN_NAME_SIZE); // PI13 SPI0
-    b->pins[21].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[21].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[21].gpio.pinmap = 269;
 
     strncpy(b->pins[22].name, "PI16", MRAA_PIN_NAME_SIZE); // PI16 UART2_RTS
-    b->pins[22].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[22].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[22].gpio.pinmap = 272;
 
     strncpy(b->pins[23].name, "SPI0CLK", MRAA_PIN_NAME_SIZE); // PI11 SPI0
-    b->pins[23].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[23].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[23].gpio.pinmap = 267;
 
     strncpy(b->pins[24].name, "SPI0CS0", MRAA_PIN_NAME_SIZE); // PI10 SPI0
-    b->pins[24].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[24].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[24].gpio.pinmap = 266;
 
     strncpy(b->pins[25].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[25].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[25].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[26].name, "SPI0CS1", MRAA_PIN_NAME_SIZE); // PI14 SPI0
-    b->pins[26].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[26].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[26].gpio.pinmap = 270;
 
     if (platform_detected == PLATFORM_BANANA_PI) {
         strncpy(b->pins[27].name, "5V", MRAA_PIN_NAME_SIZE);
-        b->pins[27].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[27].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[28].name, "3V3", MRAA_PIN_NAME_SIZE);
-        b->pins[28].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[28].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[29].name, "PH05", MRAA_PIN_NAME_SIZE); // PH5
-        b->pins[29].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[29].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[29].gpio.pinmap = 229;
 
         strncpy(b->pins[30].name, "PI21", MRAA_PIN_NAME_SIZE); // PI21 UART7_RX
-        b->pins[30].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[30].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
         b->pins[30].gpio.pinmap = 277;
 
         strncpy(b->pins[31].name, "PH03", MRAA_PIN_NAME_SIZE); // PH3
-        b->pins[31].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[31].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[31].gpio.pinmap = 227;
 
         strncpy(b->pins[32].name, "PI20", MRAA_PIN_NAME_SIZE); // PI20 UART7_TX
-        b->pins[32].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[32].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
         b->pins[32].gpio.pinmap = 276;
 
         strncpy(b->pins[33].name, "GND", MRAA_PIN_NAME_SIZE);
-        b->pins[33].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[33].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[34].name, "GND", MRAA_PIN_NAME_SIZE);
-        b->pins[34].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[34].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     }
 
     if (platform_detected == PLATFORM_BANANA_PRO) {
 
         strncpy(b->pins[27].name, "HAT_SDA", MRAA_PIN_NAME_SIZE); // PI1 TWI3-SDA i2c3
-        b->pins[27].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[27].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
         b->pins[27].gpio.pinmap = 257;
 
         strncpy(b->pins[28].name, "HAT_SCK", MRAA_PIN_NAME_SIZE); // PI0 TWI3-SCK i2c3
-        b->pins[28].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[28].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
         b->pins[28].gpio.pinmap = 256;
 
         strncpy(b->pins[29].name, "PB03", MRAA_PIN_NAME_SIZE); // PB3 IR0_TX/SPDIF_MCLK
-        b->pins[29].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[29].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[29].gpio.pinmap = 35;
 
         strncpy(b->pins[30].name, "GND", MRAA_PIN_NAME_SIZE);
-        b->pins[30].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[30].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[31].name, "PI21", MRAA_PIN_NAME_SIZE); // PI21 UART7_RX
-        b->pins[31].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[31].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
         b->pins[31].gpio.pinmap = 277;
 
         strncpy(b->pins[32].name, "PI20", MRAA_PIN_NAME_SIZE); // PI20 UART7_TX
-        b->pins[32].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[32].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
         b->pins[32].gpio.pinmap = 276;
 
         strncpy(b->pins[33].name, "PB13", MRAA_PIN_NAME_SIZE); // PB13 SPDIF_D0
-        b->pins[33].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[33].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[33].gpio.pinmap = 45;
 
         strncpy(b->pins[34].name, "GND", MRAA_PIN_NAME_SIZE);
-        b->pins[34].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[34].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[35].name, "PB07", MRAA_PIN_NAME_SIZE); // PB07 I2S0_LRCK
-        b->pins[35].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[35].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[35].gpio.pinmap = 39;
 
         strncpy(b->pins[36].name, "PB06", MRAA_PIN_NAME_SIZE); // PB06 I2S0BCLK
-        b->pins[36].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[36].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[36].gpio.pinmap = 38;
 
         strncpy(b->pins[37].name, "PB05", MRAA_PIN_NAME_SIZE); // PB05 I2S0MCK
-        b->pins[37].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[37].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[37].gpio.pinmap = 37;
 
         strncpy(b->pins[38].name, "PB12", MRAA_PIN_NAME_SIZE); // PB12 I2S0_DI
-        b->pins[38].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[38].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[38].gpio.pinmap = 44;
 
         strncpy(b->pins[39].name, "GND", MRAA_PIN_NAME_SIZE);
-        b->pins[39].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[39].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[40].name, "PB08", MRAA_PIN_NAME_SIZE); // PB08 I2S0_DO0
-        b->pins[40].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[40].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[40].gpio.pinmap = 40;
     }
 
@@ -528,7 +528,7 @@ mraa_banana()
     b->gpio_count = 0;
     int i;
     for (i = 0; i < b->phy_pin_count; i++) {
-        if (b->pins[i].capabilites.gpio) {
+        if (b->pins[i].capabilities.gpio) {
             b->gpio_count++;
         }
     }

src/arm/beaglebone.c

@@ -312,7 +312,7 @@ mraa_beaglebone_pwm_init_replace(int pin)
         syslog(LOG_ERR, "pwm: Platform Not Initialised");
         return NULL;
     }
-    if (plat->pins[pin].capabilites.pwm != 1) {
+    if (plat->pins[pin].capabilities.pwm != 1) {
         syslog(LOG_ERR, "pwm: pin not capable of pwm");
         return NULL;
     }
@@ -525,20 +525,20 @@ mraa_beaglebone()
     b->adv_func->pwm_init_replace = &mraa_beaglebone_pwm_init_replace;
 
     strncpy(b->pins[0].name, "INVALID", MRAA_PIN_NAME_SIZE);
-    b->pins[0].capabilites = (mraa_pincapabilities_t){ 0, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[0].capabilities = (mraa_pincapabilities_t){ 0, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[1].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[1].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[1].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[2].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[2].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[2].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     if (emmc_enabled == 1) {
         strncpy(b->pins[3].name, "MMC1_D6", MRAA_PIN_NAME_SIZE);
-        b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[3].name, "GPIO38", MRAA_PIN_NAME_SIZE);
-        b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[3].gpio.pinmap = 38;
     b->pins[3].gpio.parent_id = 0;
@@ -546,10 +546,10 @@ mraa_beaglebone()
 
     if (emmc_enabled == 1) {
         strncpy(b->pins[4].name, "MMC1_D7", MRAA_PIN_NAME_SIZE);
-        b->pins[4].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[4].name, "GPIO39", MRAA_PIN_NAME_SIZE);
-        b->pins[4].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[4].gpio.pinmap = 39;
     b->pins[4].gpio.parent_id = 0;
@@ -557,10 +557,10 @@ mraa_beaglebone()
 
     if (emmc_enabled == 1) {
         strncpy(b->pins[5].name, "MMC1_D2", MRAA_PIN_NAME_SIZE);
-        b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[5].name, "GPIO34", MRAA_PIN_NAME_SIZE);
-        b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[5].gpio.pinmap = 34;
     b->pins[5].gpio.parent_id = 0;
@@ -568,10 +568,10 @@ mraa_beaglebone()
 
     if (emmc_enabled == 1) {
         strncpy(b->pins[6].name, "MMC1_D3", MRAA_PIN_NAME_SIZE);
-        b->pins[6].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[6].name, "GPIO35", MRAA_PIN_NAME_SIZE);
-        b->pins[6].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[6].gpio.pinmap = 35;
     b->pins[6].gpio.parent_id = 0;
@@ -579,50 +579,50 @@ mraa_beaglebone()
 
     // TODO TIMER4
     strncpy(b->pins[7].name, "GPIO66", MRAA_PIN_NAME_SIZE);
-    b->pins[7].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[7].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[7].gpio.pinmap = 66;
     b->pins[7].gpio.parent_id = 0;
     b->pins[7].gpio.mux_total = 0;
 
     // TODO TIMER7
     strncpy(b->pins[8].name, "GPIO67", MRAA_PIN_NAME_SIZE);
-    b->pins[8].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[8].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[8].gpio.pinmap = 67;
     b->pins[8].gpio.parent_id = 0;
     b->pins[8].gpio.mux_total = 0;
 
     // TODO TIMER5
     strncpy(b->pins[9].name, "GPIO69", MRAA_PIN_NAME_SIZE);
-    b->pins[9].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[9].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[9].gpio.pinmap = 69;
     b->pins[9].gpio.parent_id = 0;
     b->pins[9].gpio.mux_total = 0;
 
     // TODO TIMER6
     strncpy(b->pins[10].name, "GPIO68", MRAA_PIN_NAME_SIZE);
-    b->pins[10].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[10].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[10].gpio.pinmap = 68;
     b->pins[10].gpio.parent_id = 0;
     b->pins[10].gpio.mux_total = 0;
 
     strncpy(b->pins[11].name, "GPIO45", MRAA_PIN_NAME_SIZE);
-    b->pins[11].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[11].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[11].gpio.pinmap = 45;
     b->pins[11].gpio.parent_id = 0;
     b->pins[11].gpio.mux_total = 0;
 
     strncpy(b->pins[12].name, "GPIO44", MRAA_PIN_NAME_SIZE);
-    b->pins[12].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[12].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[12].gpio.pinmap = 44;
     b->pins[12].gpio.parent_id = 0;
     b->pins[12].gpio.mux_total = 0;
 
     if (ehrpwm2b_enabled == 1) {
         strncpy(b->pins[13].name, "EHRPWM2B", MRAA_PIN_NAME_SIZE);
-        b->pins[13].capabilites = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
+        b->pins[13].capabilities = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[13].name, "GPIO23", MRAA_PIN_NAME_SIZE);
-        b->pins[13].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+        b->pins[13].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     }
     b->pins[13].gpio.pinmap = 23;
     b->pins[13].gpio.parent_id = 0;
@@ -631,42 +631,42 @@ mraa_beaglebone()
     b->pins[13].pwm.mux_total = 0;
 
     strncpy(b->pins[14].name, "GPIO26", MRAA_PIN_NAME_SIZE);
-    b->pins[14].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[14].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[14].gpio.pinmap = 26;
     b->pins[14].gpio.parent_id = 0;
     b->pins[14].gpio.mux_total = 0;
 
     strncpy(b->pins[15].name, "GPIO47", MRAA_PIN_NAME_SIZE);
-    b->pins[15].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[15].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[15].gpio.pinmap = 47;
     b->pins[15].gpio.parent_id = 0;
     b->pins[15].gpio.mux_total = 0;
 
     strncpy(b->pins[16].name, "GPIO46", MRAA_PIN_NAME_SIZE);
-    b->pins[16].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[16].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[16].gpio.pinmap = 46;
     b->pins[16].gpio.parent_id = 0;
     b->pins[16].gpio.mux_total = 0;
 
     // TODO PWM0_SYNCO
     strncpy(b->pins[17].name, "GPIO27", MRAA_PIN_NAME_SIZE);
-    b->pins[17].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[17].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[17].gpio.pinmap = 27;
     b->pins[17].gpio.parent_id = 0;
     b->pins[17].gpio.mux_total = 0;
 
     strncpy(b->pins[18].name, "GPIO65", MRAA_PIN_NAME_SIZE);
-    b->pins[18].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[18].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[18].gpio.pinmap = 65;
     b->pins[18].gpio.parent_id = 0;
     b->pins[18].gpio.mux_total = 0;
 
     if (ehrpwm2a_enabled == 1) {
         strncpy(b->pins[19].name, "EHRPWM2A", MRAA_PIN_NAME_SIZE);
-        b->pins[19].capabilites = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
+        b->pins[19].capabilities = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[19].name, "GPIO22", MRAA_PIN_NAME_SIZE);
-        b->pins[19].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+        b->pins[19].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     }
     b->pins[19].gpio.pinmap = 22;
     b->pins[19].gpio.parent_id = 0;
@@ -676,10 +676,10 @@ mraa_beaglebone()
 
     if (emmc_enabled == 1) {
         strncpy(b->pins[20].name, "MMC1_CMD", MRAA_PIN_NAME_SIZE);
-        b->pins[20].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[20].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[20].name, "GPIO63", MRAA_PIN_NAME_SIZE);
-        b->pins[20].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[20].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[20].gpio.pinmap = 63;
     b->pins[20].gpio.parent_id = 0;
@@ -687,10 +687,10 @@ mraa_beaglebone()
 
     if (emmc_enabled == 1) {
         strncpy(b->pins[21].name, "MMC1_CLK", MRAA_PIN_NAME_SIZE);
-        b->pins[21].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[21].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[21].name, "GPIO62", MRAA_PIN_NAME_SIZE);
-        b->pins[21].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[21].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[21].gpio.pinmap = 62;
     b->pins[21].gpio.parent_id = 0;
@@ -698,10 +698,10 @@ mraa_beaglebone()
 
     if (emmc_enabled == 1) {
         strncpy(b->pins[22].name, "MMC1_D5", MRAA_PIN_NAME_SIZE);
-        b->pins[22].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[22].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[22].name, "GPIO37", MRAA_PIN_NAME_SIZE);
-        b->pins[22].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[22].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[22].gpio.pinmap = 37;
     b->pins[22].gpio.parent_id = 0;
@@ -709,10 +709,10 @@ mraa_beaglebone()
 
     if (emmc_enabled == 1) {
         strncpy(b->pins[23].name, "MMC_D4", MRAA_PIN_NAME_SIZE);
-        b->pins[23].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[23].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[23].name, "GPIO36", MRAA_PIN_NAME_SIZE);
-        b->pins[23].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[23].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[23].gpio.pinmap = 36;
     b->pins[23].gpio.parent_id = 0;
@@ -720,10 +720,10 @@ mraa_beaglebone()
 
     if (emmc_enabled == 1) {
         strncpy(b->pins[24].name, "MMC_D1", MRAA_PIN_NAME_SIZE);
-        b->pins[24].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[24].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[24].name, "GPIO33", MRAA_PIN_NAME_SIZE);
-        b->pins[24].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[24].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[24].gpio.pinmap = 33;
     b->pins[24].gpio.parent_id = 0;
@@ -731,27 +731,27 @@ mraa_beaglebone()
 
     if (emmc_enabled == 1) {
         strncpy(b->pins[25].name, "MMC1_D0", MRAA_PIN_NAME_SIZE);
-        b->pins[25].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[25].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[25].name, "GPIO32", MRAA_PIN_NAME_SIZE);
-        b->pins[25].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[25].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[25].gpio.pinmap = 32;
     b->pins[25].gpio.parent_id = 0;
     b->pins[25].gpio.mux_total = 0;
 
     strncpy(b->pins[26].name, "GPIO61", MRAA_PIN_NAME_SIZE);
-    b->pins[26].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[26].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[26].gpio.pinmap = 61;
     b->pins[26].gpio.parent_id = 0;
     b->pins[26].gpio.mux_total = 0;
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[27].name, "LCD_VSYNC", MRAA_PIN_NAME_SIZE);
-        b->pins[27].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[27].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[27].name, "GPIO86", MRAA_PIN_NAME_SIZE);
-        b->pins[27].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[27].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[27].gpio.pinmap = 86;
     b->pins[27].gpio.parent_id = 0;
@@ -759,10 +759,10 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[28].name, "LCD_PCLK", MRAA_PIN_NAME_SIZE);
-        b->pins[28].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[28].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[28].name, "GPIO88", MRAA_PIN_NAME_SIZE);
-        b->pins[28].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[28].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[28].gpio.pinmap = 88;
     b->pins[28].gpio.parent_id = 0;
@@ -770,10 +770,10 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[29].name, "LCD_HSYNC", MRAA_PIN_NAME_SIZE);
-        b->pins[29].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[29].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[29].name, "GPIO87", MRAA_PIN_NAME_SIZE);
-        b->pins[29].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[29].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[29].gpio.pinmap = 87;
     b->pins[29].gpio.parent_id = 0;
@@ -781,10 +781,10 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[30].name, "LCD_AC_BIAS", MRAA_PIN_NAME_SIZE);
-        b->pins[30].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[30].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[30].name, "GPIO89", MRAA_PIN_NAME_SIZE);
-        b->pins[30].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[30].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[30].gpio.pinmap = 89;
     b->pins[30].gpio.parent_id = 0;
@@ -792,11 +792,11 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[31].name, "LCD_D14", MRAA_PIN_NAME_SIZE);
-        b->pins[31].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[31].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         // TODO UART5_CTS this is ignored when using ADAFRUIT
         strncpy(b->pins[31].name, "GPIO10", MRAA_PIN_NAME_SIZE);
-        b->pins[31].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[31].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[31].gpio.pinmap = 10;
     b->pins[31].gpio.parent_id = 0;
@@ -805,11 +805,11 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[32].name, "LCD_D15", MRAA_PIN_NAME_SIZE);
-        b->pins[32].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[32].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         // TODO UART5_RTS this is ignored when using ADAFRUIT
         strncpy(b->pins[32].name, "GPIO11", MRAA_PIN_NAME_SIZE);
-        b->pins[32].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[32].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[32].gpio.pinmap = 11;
     b->pins[32].gpio.parent_id = 0;
@@ -818,11 +818,11 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[33].name, "LCD_D13", MRAA_PIN_NAME_SIZE);
-        b->pins[33].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[33].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         // TODO UART4_RTS this is ignored when using ADAFRUIT
         strncpy(b->pins[33].name, "GPIO9", MRAA_PIN_NAME_SIZE);
-        b->pins[33].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[33].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[33].gpio.pinmap = 9;
     b->pins[33].gpio.parent_id = 0;
@@ -832,10 +832,10 @@ mraa_beaglebone()
     // TODO PWM_1B
     if (hdmi_enabled == 1) {
         strncpy(b->pins[34].name, "LCD_D11", MRAA_PIN_NAME_SIZE);
-        b->pins[34].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[34].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[34].name, "GPIO81", MRAA_PIN_NAME_SIZE);
-        b->pins[34].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+        b->pins[34].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     }
     b->pins[34].gpio.pinmap = 81;
     b->pins[34].gpio.parent_id = 0;
@@ -843,11 +843,11 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[35].name, "LCD_D12", MRAA_PIN_NAME_SIZE);
-        b->pins[35].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[35].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         // TODO UART4_CTS this is ignored when using ADAFRUIT
         strncpy(b->pins[35].name, "GPIO8", MRAA_PIN_NAME_SIZE);
-        b->pins[35].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[35].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[35].gpio.pinmap = 8;
     b->pins[35].gpio.parent_id = 0;
@@ -857,10 +857,10 @@ mraa_beaglebone()
     // TODO PWM_1A
     if (hdmi_enabled == 1) {
         strncpy(b->pins[36].name, "LCD_D10", MRAA_PIN_NAME_SIZE);
-        b->pins[36].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[36].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[36].name, "GPIO80", MRAA_PIN_NAME_SIZE);
-        b->pins[36].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+        b->pins[36].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     }
     b->pins[36].gpio.pinmap = 80;
     b->pins[36].gpio.parent_id = 0;
@@ -868,17 +868,17 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[37].name, "LCD_D8", MRAA_PIN_NAME_SIZE);
-        b->pins[37].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[37].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         if (uart5_enabled == 1) {
             strncpy(b->pins[37].name, "UART5TX", MRAA_PIN_NAME_SIZE);
-            b->pins[37].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+            b->pins[37].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
         } else {
             strncpy(b->pins[37].name, "GPIO78", MRAA_PIN_NAME_SIZE);
-            b->pins[37].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+            b->pins[37].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
         }
     }
-    b->pins[37].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[37].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[37].gpio.pinmap = 78;
     b->pins[37].gpio.parent_id = 0;
     b->pins[37].gpio.mux_total = 0;
@@ -886,15 +886,15 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[38].name, "LCD_D9", MRAA_PIN_NAME_SIZE);
-        b->pins[38].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[38].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         // TODO UART5_RX
         if (uart5_enabled == 1) {
             strncpy(b->pins[38].name, "UART5RX", MRAA_PIN_NAME_SIZE);
-            b->pins[38].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+            b->pins[38].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
         } else {
             strncpy(b->pins[38].name, "GPIO79", MRAA_PIN_NAME_SIZE);
-            b->pins[38].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+            b->pins[38].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
         }
     }
     b->pins[38].gpio.pinmap = 79;
@@ -904,10 +904,10 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[39].name, "LCD_D6", MRAA_PIN_NAME_SIZE);
-        b->pins[39].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[39].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[39].name, "GPIO76", MRAA_PIN_NAME_SIZE);
-        b->pins[39].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[39].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[39].gpio.pinmap = 76;
     b->pins[39].gpio.parent_id = 0;
@@ -915,10 +915,10 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[40].name, "LCD_D7", MRAA_PIN_NAME_SIZE);
-        b->pins[40].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[40].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[40].name, "GPIO77", MRAA_PIN_NAME_SIZE);
-        b->pins[40].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[40].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[40].gpio.pinmap = 77;
     b->pins[40].gpio.parent_id = 0;
@@ -926,10 +926,10 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[41].name, "LCD_D4", MRAA_PIN_NAME_SIZE);
-        b->pins[41].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[41].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[41].name, "GPIO74", MRAA_PIN_NAME_SIZE);
-        b->pins[41].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[41].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[41].gpio.pinmap = 74;
     b->pins[41].gpio.parent_id = 0;
@@ -937,10 +937,10 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[42].name, "LCD_D5", MRAA_PIN_NAME_SIZE);
-        b->pins[42].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[42].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[42].name, "GPIO75", MRAA_PIN_NAME_SIZE);
-        b->pins[42].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[42].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[42].gpio.pinmap = 75;
     b->pins[42].gpio.parent_id = 0;
@@ -948,10 +948,10 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[43].name, "LCD_D2", MRAA_PIN_NAME_SIZE);
-        b->pins[43].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[43].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[43].name, "GPIO72", MRAA_PIN_NAME_SIZE);
-        b->pins[43].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[43].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[43].gpio.pinmap = 72;
     b->pins[43].gpio.parent_id = 0;
@@ -959,10 +959,10 @@ mraa_beaglebone()
 
     if (hdmi_enabled == 1) {
         strncpy(b->pins[44].name, "LCD_D3", MRAA_PIN_NAME_SIZE);
-        b->pins[44].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[44].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[44].name, "GPIO73", MRAA_PIN_NAME_SIZE);
-        b->pins[44].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[44].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[44].gpio.pinmap = 73;
     b->pins[44].gpio.parent_id = 0;
@@ -971,10 +971,10 @@ mraa_beaglebone()
     // TODO PWM_2A
     if (hdmi_enabled == 1) {
         strncpy(b->pins[45].name, "LCD_D0", MRAA_PIN_NAME_SIZE);
-        b->pins[45].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[45].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[45].name, "GPIO70", MRAA_PIN_NAME_SIZE);
-        b->pins[45].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+        b->pins[45].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     }
     b->pins[45].gpio.pinmap = 70;
     b->pins[45].gpio.parent_id = 0;
@@ -983,51 +983,51 @@ mraa_beaglebone()
     // TODO PWM_2B
     if (hdmi_enabled == 1) {
         strncpy(b->pins[46].name, "LCD_D1", MRAA_PIN_NAME_SIZE);
-        b->pins[46].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[46].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[46].name, "GPIO71", MRAA_PIN_NAME_SIZE);
-        b->pins[46].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+        b->pins[46].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     }
     b->pins[46].gpio.pinmap = 71;
     b->pins[46].gpio.parent_id = 0;
     b->pins[46].gpio.mux_total = 0;
 
     strncpy(b->pins[47].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[47].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[47].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[48].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[48].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[48].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[49].name, "3.3V", MRAA_PIN_NAME_SIZE);
-    b->pins[49].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[49].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[50].name, "3.3V", MRAA_PIN_NAME_SIZE);
-    b->pins[50].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[50].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[51].name, "5V", MRAA_PIN_NAME_SIZE);
-    b->pins[51].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[51].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[52].name, "5V", MRAA_PIN_NAME_SIZE);
-    b->pins[52].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[52].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[53].name, "5V", MRAA_PIN_NAME_SIZE);
-    b->pins[53].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[53].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[54].name, "5V", MRAA_PIN_NAME_SIZE);
-    b->pins[54].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[54].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[55].name, "PWR", MRAA_PIN_NAME_SIZE);
-    b->pins[55].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[55].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[56].name, "RESET", MRAA_PIN_NAME_SIZE);
-    b->pins[56].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[56].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     if (uart4_enabled == 1) {
         strncpy(b->pins[57].name, "UART4_RX", MRAA_PIN_NAME_SIZE);
-        b->pins[57].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[57].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     } else {
         strncpy(b->pins[57].name, "GPIO30", MRAA_PIN_NAME_SIZE);
-        b->pins[57].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[57].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     }
     b->pins[57].gpio.pinmap = 30;
     b->pins[57].gpio.parent_id = 0;
@@ -1035,17 +1035,17 @@ mraa_beaglebone()
     b->pins[57].uart.mux_total = 0;
 
     strncpy(b->pins[58].name, "GPIO60", MRAA_PIN_NAME_SIZE);
-    b->pins[58].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[58].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[58].gpio.pinmap = 60;
     b->pins[58].gpio.parent_id = 0;
     b->pins[58].gpio.mux_total = 0;
 
     if (uart4_enabled == 1) {
         strncpy(b->pins[59].name, "UART4_TX", MRAA_PIN_NAME_SIZE);
-        b->pins[59].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[59].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     } else {
         strncpy(b->pins[59].name, "GPIO31", MRAA_PIN_NAME_SIZE);
-        b->pins[59].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[59].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     }
     b->pins[59].gpio.pinmap = 31;
     b->pins[59].gpio.parent_id = 0;
@@ -1054,10 +1054,10 @@ mraa_beaglebone()
 
     if (ehrpwm1a_enabled == 1) {
         strncpy(b->pins[60].name, "EHRPWM1A", MRAA_PIN_NAME_SIZE);
-        b->pins[60].capabilites = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
+        b->pins[60].capabilities = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[60].name, "GPIO50", MRAA_PIN_NAME_SIZE);
-        b->pins[60].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+        b->pins[60].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     }
     b->pins[60].gpio.pinmap = 50;
     b->pins[60].gpio.parent_id = 0;
@@ -1067,17 +1067,17 @@ mraa_beaglebone()
 
     // TODO PWM_TRIP2_IN (not a PWM output, but used for sync cf ref. manual)
     strncpy(b->pins[61].name, "GPIO48", MRAA_PIN_NAME_SIZE);
-    b->pins[61].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[61].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[61].gpio.pinmap = 48;
     b->pins[61].gpio.parent_id = 0;
     b->pins[61].gpio.mux_total = 0;
 
     if (ehrpwm1b_enabled == 1) {
         strncpy(b->pins[62].name, "EHRPWM1B", MRAA_PIN_NAME_SIZE);
-        b->pins[62].capabilites = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
+        b->pins[62].capabilities = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
     } else {
         strncpy(b->pins[62].name, "GPIO51", MRAA_PIN_NAME_SIZE);
-        b->pins[62].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+        b->pins[62].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     }
     b->pins[62].gpio.pinmap = 51;
     b->pins[62].gpio.parent_id = 0;
@@ -1088,15 +1088,15 @@ mraa_beaglebone()
     if ((i2c0_enabled == 1) || (spi0_enabled == 1)) {
         if (i2c0_enabled == 1) {
             strncpy(b->pins[63].name, "I2C1SCL", MRAA_PIN_NAME_SIZE);
-            b->pins[63].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 1, 0, 0 };
+            b->pins[63].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 1, 0, 0 };
         }
         if (spi0_enabled == 1) {
             strncpy(b->pins[63].name, "SPI0CS0", MRAA_PIN_NAME_SIZE);
-            b->pins[63].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
+            b->pins[63].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
         }
     } else {
         strncpy(b->pins[63].name, "GPIO4", MRAA_PIN_NAME_SIZE);
-        b->pins[63].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 1, 0, 0 };
+        b->pins[63].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 1, 0, 0 };
     }
     b->pins[63].gpio.pinmap = 4;
     b->pins[63].gpio.parent_id = 0;
@@ -1107,15 +1107,15 @@ mraa_beaglebone()
     if ((i2c0_enabled == 1) || (spi0_enabled == 1)) {
         if (i2c0_enabled == 1) {
             strncpy(b->pins[64].name, "I2C1SDA", MRAA_PIN_NAME_SIZE);
-            b->pins[64].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 1, 0, 0 };
+            b->pins[64].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 1, 0, 0 };
         }
         if (spi0_enabled == 1) {
             strncpy(b->pins[64].name, "SPI0D1", MRAA_PIN_NAME_SIZE);
-            b->pins[64].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
+            b->pins[64].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
         }
     } else {
         strncpy(b->pins[64].name, "GPIO5", MRAA_PIN_NAME_SIZE);
-        b->pins[64].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 1, 0, 0 };
+        b->pins[64].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 1, 0, 0 };
     }
     b->pins[64].gpio.pinmap = 5;
     b->pins[64].gpio.parent_id = 0;
@@ -1125,11 +1125,11 @@ mraa_beaglebone()
 
     if (i2c1_enabled == 1) {
         strncpy(b->pins[65].name, "I2C2SCL", MRAA_PIN_NAME_SIZE);
-        b->pins[65].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+        b->pins[65].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
         b->pins[65].i2c.mux_total = 0;
     } else {
         strncpy(b->pins[65].name, "GPIO13", MRAA_PIN_NAME_SIZE);
-        b->pins[65].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+        b->pins[65].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
     }
     b->pins[65].gpio.pinmap = 13;
     b->pins[65].gpio.parent_id = 0;
@@ -1138,11 +1138,11 @@ mraa_beaglebone()
 
     if (i2c1_enabled == 1) {
         strncpy(b->pins[66].name, "I2C2SDA", MRAA_PIN_NAME_SIZE);
-        b->pins[66].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+        b->pins[66].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
         b->pins[66].i2c.mux_total = 0;
     } else {
         strncpy(b->pins[66].name, "GPIO12", MRAA_PIN_NAME_SIZE);
-        b->pins[66].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+        b->pins[66].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
     }
     b->pins[66].gpio.pinmap = 12;
     b->pins[66].gpio.parent_id = 0;
@@ -1152,19 +1152,19 @@ mraa_beaglebone()
     if ((spi0_enabled == 1) || uart2_enabled == 1 || ehrpwm0b_enabled == 1) {
         if (uart2_enabled == 1) {
             strncpy(b->pins[67].name, "UART2_TX", MRAA_PIN_NAME_SIZE);
-            b->pins[67].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 1 };
+            b->pins[67].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 1 };
         }
         if (spi0_enabled == 1) {
             strncpy(b->pins[67].name, "SPI0D0", MRAA_PIN_NAME_SIZE);
-            b->pins[67].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
+            b->pins[67].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
         }
         if (ehrpwm0b_enabled == 1) {
             strncpy(b->pins[67].name, "EHRPWM0B", MRAA_PIN_NAME_SIZE);
-            b->pins[67].capabilites = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
+            b->pins[67].capabilities = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
         }
     } else {
         strncpy(b->pins[67].name, "GPIO3", MRAA_PIN_NAME_SIZE);
-        b->pins[67].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 1, 0, 0, 1 };
+        b->pins[67].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 1, 0, 0, 1 };
     }
     b->pins[67].gpio.pinmap = 3;
     b->pins[67].gpio.parent_id = 0;
@@ -1177,19 +1177,19 @@ mraa_beaglebone()
     if ((spi0_enabled == 1) || uart2_enabled == 1 || ehrpwm0a_enabled == 1) {
         if (uart2_enabled == 1) {
             strncpy(b->pins[68].name, "UART2_RX", MRAA_PIN_NAME_SIZE);
-            b->pins[68].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 1 };
+            b->pins[68].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 1 };
         }
         if (spi0_enabled == 1) {
             strncpy(b->pins[68].name, "SPI0CLK", MRAA_PIN_NAME_SIZE);
-            b->pins[68].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
+            b->pins[68].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
         }
         if (ehrpwm0a_enabled == 1) {
             strncpy(b->pins[68].name, "EHRPWM0A", MRAA_PIN_NAME_SIZE);
-            b->pins[68].capabilites = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
+            b->pins[68].capabilities = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
         }
     } else {
         strncpy(b->pins[68].name, "GPIO2", MRAA_PIN_NAME_SIZE);
-        b->pins[68].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 1, 0, 0, 1 };
+        b->pins[68].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 1, 0, 0, 1 };
     }
     b->pins[68].gpio.pinmap = 2;
     b->pins[68].gpio.parent_id = 0;
@@ -1201,17 +1201,17 @@ mraa_beaglebone()
 
     // TODO PWM0_SYNCO ?? PWM
     strncpy(b->pins[69].name, "GPIO49", MRAA_PIN_NAME_SIZE);
-    b->pins[69].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[69].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[69].gpio.pinmap = 49;
     b->pins[69].gpio.parent_id = 0;
     b->pins[69].gpio.mux_total = 0;
 
     if (uart1_enabled == 1) {
         strncpy(b->pins[70].name, "UART1_RX", MRAA_PIN_NAME_SIZE);
-        b->pins[70].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[70].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     } else {
         strncpy(b->pins[70].name, "GPIO15", MRAA_PIN_NAME_SIZE);
-        b->pins[70].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[70].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     }
     b->pins[70].gpio.pinmap = 15;
     b->pins[70].gpio.parent_id = 0;
@@ -1219,26 +1219,26 @@ mraa_beaglebone()
     b->pins[70].uart.mux_total = 0;
 
     strncpy(b->pins[71].name, "GPIO117", MRAA_PIN_NAME_SIZE);
-    b->pins[71].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[71].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[71].gpio.pinmap = 117;
     b->pins[71].gpio.parent_id = 0;
     b->pins[71].gpio.mux_total = 0;
 
     if (uart1_enabled == 1) {
         strncpy(b->pins[72].name, "UART1_RX", MRAA_PIN_NAME_SIZE);
-        b->pins[72].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[72].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     } else {
         strncpy(b->pins[72].name, "GPIO14", MRAA_PIN_NAME_SIZE);
-        b->pins[72].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+        b->pins[72].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     }
-    b->pins[72].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[72].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[72].gpio.pinmap = 14;
     b->pins[72].gpio.parent_id = 0;
     b->pins[72].gpio.mux_total = 0;
     b->pins[72].uart.mux_total = 0;
 
     strncpy(b->pins[73].name, "GPIO115", MRAA_PIN_NAME_SIZE);
-    b->pins[73].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[73].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[73].gpio.pinmap = 115;
     b->pins[73].gpio.parent_id = 0;
     b->pins[73].gpio.mux_total = 0;
@@ -1246,14 +1246,14 @@ mraa_beaglebone()
     if (emmc_enabled != 1) {
         if (spi1_enabled == 1) {
             strncpy(b->pins[74].name, "SPI1CS0", MRAA_PIN_NAME_SIZE);
-            b->pins[74].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
+            b->pins[74].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
         } else {
             strncpy(b->pins[74].name, "GPIO113", MRAA_PIN_NAME_SIZE);
-            b->pins[74].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+            b->pins[74].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
         }
     } else {
         strncpy(b->pins[74].name, "MCASP0XX", MRAA_PIN_NAME_SIZE);
-        b->pins[74].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
+        b->pins[74].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
     }
     b->pins[74].gpio.pinmap = 113;
     b->pins[74].gpio.parent_id = 0;
@@ -1263,14 +1263,14 @@ mraa_beaglebone()
     if (emmc_enabled != 1) {
         if (spi1_enabled == 1) {
             strncpy(b->pins[75].name, "SPI1D0", MRAA_PIN_NAME_SIZE);
-            b->pins[75].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
+            b->pins[75].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
         } else {
             strncpy(b->pins[75].name, "GPIO111", MRAA_PIN_NAME_SIZE);
-            b->pins[75].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+            b->pins[75].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
         }
     } else {
         strncpy(b->pins[75].name, "MMC1_SD", MRAA_PIN_NAME_SIZE);
-        b->pins[75].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[75].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[75].gpio.pinmap = 111;
     b->pins[75].gpio.parent_id = 0;
@@ -1280,14 +1280,14 @@ mraa_beaglebone()
     if (emmc_enabled != 1) {
         if (spi1_enabled == 1) {
             strncpy(b->pins[76].name, "SPI1D1", MRAA_PIN_NAME_SIZE);
-            b->pins[76].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
+            b->pins[76].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
         } else {
             strncpy(b->pins[76].name, "GPIO112", MRAA_PIN_NAME_SIZE);
-            b->pins[76].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+            b->pins[76].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
         }
     } else {
         strncpy(b->pins[76].name, "MMC2_SD", MRAA_PIN_NAME_SIZE);
-        b->pins[76].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[76].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[76].gpio.pinmap = 112;
     b->pins[76].gpio.parent_id = 0;
@@ -1297,14 +1297,14 @@ mraa_beaglebone()
     if (emmc_enabled != 1) {
         if (spi1_enabled == 1) {
             strncpy(b->pins[77].name, "SPI1CLK", MRAA_PIN_NAME_SIZE);
-            b->pins[77].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
+            b->pins[77].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
         } else {
             strncpy(b->pins[77].name, "GPIO110", MRAA_PIN_NAME_SIZE);
-            b->pins[77].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+            b->pins[77].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
         }
     } else {
         strncpy(b->pins[77].name, "MMC0_SD", MRAA_PIN_NAME_SIZE);
-        b->pins[77].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[77].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     }
     b->pins[77].gpio.pinmap = 110;
     b->pins[77].gpio.parent_id = 0;
@@ -1313,60 +1313,60 @@ mraa_beaglebone()
 
 
     strncpy(b->pins[78].name, "VDD_ADC", MRAA_PIN_NAME_SIZE);
-    b->pins[78].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[78].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     // TODO AIN4
     strncpy(b->pins[79].name, "AIN4", MRAA_PIN_NAME_SIZE);
-    b->pins[79].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
+    b->pins[79].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
 
     strncpy(b->pins[80].name, "GND_ADC", MRAA_PIN_NAME_SIZE);
-    b->pins[80].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[80].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     // TODO AIN6
     strncpy(b->pins[81].name, "AIN6", MRAA_PIN_NAME_SIZE);
-    b->pins[81].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
+    b->pins[81].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
     // TODO AIN5
     strncpy(b->pins[82].name, "AIN5", MRAA_PIN_NAME_SIZE);
-    b->pins[82].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
+    b->pins[82].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
     // TODO AIN2
     strncpy(b->pins[83].name, "AIN2", MRAA_PIN_NAME_SIZE);
-    b->pins[83].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
+    b->pins[83].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
     // TODO AIN3
     strncpy(b->pins[84].name, "AIN3", MRAA_PIN_NAME_SIZE);
-    b->pins[84].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
+    b->pins[84].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
     // TODO AIN0
     strncpy(b->pins[85].name, "AIN0", MRAA_PIN_NAME_SIZE);
-    b->pins[85].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
+    b->pins[85].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
     // TODO AIN1
     strncpy(b->pins[86].name, "AIN1", MRAA_PIN_NAME_SIZE);
-    b->pins[86].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
+    b->pins[86].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
 
     strncpy(b->pins[87].name, "GPIO20", MRAA_PIN_NAME_SIZE);
-    b->pins[87].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[87].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[87].gpio.pinmap = 20;
     b->pins[87].gpio.parent_id = 0;
     b->pins[87].gpio.mux_total = 0;
 
     strncpy(b->pins[88].name, "GPIO7", MRAA_PIN_NAME_SIZE);
-    b->pins[88].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[88].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[88].gpio.pinmap = 7;
     b->pins[88].gpio.parent_id = 0;
     b->pins[88].gpio.mux_total = 0;
 
     // GND
     strncpy(b->pins[89].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[89].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[89].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     // GND
     strncpy(b->pins[90].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[90].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[90].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     // GND
     strncpy(b->pins[91].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[91].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[91].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     // GND
     strncpy(b->pins[92].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[92].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[92].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     // BUS DEFINITIONS
     b->i2c_bus_count = 2;
@@ -1417,7 +1417,7 @@ mraa_beaglebone()
     b->gpio_count = 0;
     int i;
     for (i = 0; i < b->phy_pin_count; i++)
-        if (b->pins[i].capabilites.gpio)
+        if (b->pins[i].capabilities.gpio)
             b->gpio_count++;
 
     return b;

src/arm/raspberry_pi.c

@@ -292,63 +292,63 @@ mraa_raspberry_pi()
     b->adv_func->gpio_mmap_setup = &mraa_raspberry_pi_mmap_setup;
 
     strncpy(b->pins[0].name, "INVALID", MRAA_PIN_NAME_SIZE);
-    b->pins[0].capabilites = (mraa_pincapabilities_t){ 0, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[0].capabilities = (mraa_pincapabilities_t){ 0, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[1].name, "3V3", MRAA_PIN_NAME_SIZE);
-    b->pins[1].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[1].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[2].name, "5V", MRAA_PIN_NAME_SIZE);
-    b->pins[2].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[2].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[3].name, "SDA0", MRAA_PIN_NAME_SIZE);
-    b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+    b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
     b->pins[3].gpio.pinmap = 2;
     b->pins[3].gpio.mux_total = 0;
     b->pins[3].i2c.pinmap = 0;
     b->pins[3].i2c.mux_total = 0;
 
     strncpy(b->pins[4].name, "5V", MRAA_PIN_NAME_SIZE);
-    b->pins[4].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[5].name, "SCL0", MRAA_PIN_NAME_SIZE);
-    b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+    b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
     b->pins[5].gpio.pinmap = 3;
     b->pins[5].gpio.mux_total = 0;
     b->pins[5].i2c.pinmap = 0;
     b->pins[5].i2c.mux_total = 0;
 
     strncpy(b->pins[6].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[6].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[7].name, "GPIO4", MRAA_PIN_NAME_SIZE);
-    b->pins[7].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[7].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[7].gpio.pinmap = 4;
     b->pins[7].gpio.mux_total = 0;
 
     strncpy(b->pins[8].name, "UART_TX", MRAA_PIN_NAME_SIZE);
-    b->pins[8].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[8].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[8].gpio.pinmap = 14;
     b->pins[8].gpio.mux_total = 0;
     b->pins[8].uart.parent_id = 0;
     b->pins[8].uart.mux_total = 0;
 
     strncpy(b->pins[9].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[9].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[9].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[10].name, "UART_RX", MRAA_PIN_NAME_SIZE);
-    b->pins[10].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[10].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[10].gpio.pinmap = 15;
     b->pins[10].gpio.mux_total = 0;
     b->pins[10].uart.parent_id = 0;
     b->pins[10].uart.mux_total = 0;
 
     strncpy(b->pins[11].name, "GPIO17", MRAA_PIN_NAME_SIZE);
-    b->pins[11].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[11].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[11].gpio.pinmap = 17;
     b->pins[11].gpio.mux_total = 0;
 
     strncpy(b->pins[12].name, "GPIO18", MRAA_PIN_NAME_SIZE);
-    b->pins[12].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[12].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[12].gpio.pinmap = 18;
     b->pins[12].gpio.mux_total = 0;
 
@@ -359,71 +359,71 @@ mraa_raspberry_pi()
         strncpy(b->pins[13].name, "GPIO27", MRAA_PIN_NAME_SIZE);
         b->pins[13].gpio.pinmap = 27;
     }
-    b->pins[13].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[13].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[13].gpio.mux_total = 0;
 
     strncpy(b->pins[14].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[14].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[14].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[15].name, "GPIO22", MRAA_PIN_NAME_SIZE);
-    b->pins[15].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[15].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[15].gpio.pinmap = 22;
     b->pins[15].gpio.mux_total = 0;
 
     strncpy(b->pins[16].name, "GPIO23", MRAA_PIN_NAME_SIZE);
-    b->pins[16].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[16].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[16].gpio.pinmap = 23;
     b->pins[16].gpio.mux_total = 0;
 
     strncpy(b->pins[17].name, "3V3", MRAA_PIN_NAME_SIZE);
-    b->pins[17].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[17].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[18].name, "GPIO24", MRAA_PIN_NAME_SIZE);
-    b->pins[18].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[18].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[18].gpio.pinmap = 24;
     b->pins[18].gpio.mux_total = 0;
 
     strncpy(b->pins[19].name, "SPI_MOSI", MRAA_PIN_NAME_SIZE);
-    b->pins[19].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[19].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[19].gpio.pinmap = 10;
     b->pins[19].gpio.mux_total = 0;
     b->pins[19].spi.pinmap = 0;
     b->pins[19].spi.mux_total = 0;
 
     strncpy(b->pins[20].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[20].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[20].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[21].name, "SPI_MISO", MRAA_PIN_NAME_SIZE);
-    b->pins[21].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[21].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[21].gpio.pinmap = 9;
     b->pins[21].gpio.mux_total = 0;
     b->pins[21].spi.pinmap = 0;
     b->pins[21].spi.mux_total = 0;
 
     strncpy(b->pins[22].name, "GPIO25", MRAA_PIN_NAME_SIZE);
-    b->pins[22].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[22].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[22].gpio.pinmap = 25;
     b->pins[22].gpio.mux_total = 0;
 
     strncpy(b->pins[23].name, "SPI_CLK", MRAA_PIN_NAME_SIZE);
-    b->pins[23].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[23].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[23].gpio.pinmap = 11;
     b->pins[23].gpio.mux_total = 0;
     b->pins[23].spi.pinmap = 0;
     b->pins[23].spi.mux_total = 0;
 
     strncpy(b->pins[24].name, "SPI_CS0", MRAA_PIN_NAME_SIZE);
-    b->pins[24].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[24].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[24].gpio.pinmap = 8;
     b->pins[24].gpio.mux_total = 0;
     b->pins[24].spi.pinmap = 0;
     b->pins[24].spi.mux_total = 0;
 
     strncpy(b->pins[25].name, "GND", MRAA_PIN_NAME_SIZE);
-    b->pins[25].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[25].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[26].name, "SPI_CS1", MRAA_PIN_NAME_SIZE);
-    b->pins[26].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[26].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[26].gpio.pinmap = 7;
     b->pins[26].gpio.mux_total = 0;
     b->pins[26].spi.pinmap = 0;
@@ -432,36 +432,36 @@ mraa_raspberry_pi()
     if ((platform_detected == PLATFORM_RASPBERRY_PI_A_REV_2) ||
         (platform_detected == PLATFORM_RASPBERRY_PI_B_REV_2)) {
         strncpy(b->pins[27].name, "5V", MRAA_PIN_NAME_SIZE);
-        b->pins[27].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[27].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[28].name, "3V3", MRAA_PIN_NAME_SIZE);
-        b->pins[28].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[28].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[29].name, "GPIO8", MRAA_PIN_NAME_SIZE);
-        b->pins[29].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[29].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[29].gpio.pinmap = 8;
         b->pins[29].gpio.mux_total = 0;
 
         strncpy(b->pins[30].name, "GPIO9", MRAA_PIN_NAME_SIZE);
-        b->pins[30].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[30].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[30].gpio.pinmap = 9;
         b->pins[30].gpio.mux_total = 0;
 
         strncpy(b->pins[31].name, "GPIO10", MRAA_PIN_NAME_SIZE);
-        b->pins[31].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[31].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[31].gpio.pinmap = 10;
         b->pins[31].gpio.mux_total = 0;
 
         strncpy(b->pins[32].name, "GPIO11", MRAA_PIN_NAME_SIZE);
         b->pins[32].gpio.pinmap = 11;
         b->pins[32].gpio.mux_total = 0;
-        b->pins[32].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[32].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[33].name, "GND", MRAA_PIN_NAME_SIZE);
-        b->pins[33].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[33].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[34].name, "GND", MRAA_PIN_NAME_SIZE);
-        b->pins[34].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[34].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     }
 
     // BUS DEFINITIONS
@@ -493,62 +493,62 @@ mraa_raspberry_pi()
         (platform_detected == PLATFORM_RASPBERRY_PI2_B_REV_1)) {
 
         strncpy(b->pins[27].name, "ID_SD", MRAA_PIN_NAME_SIZE);
-        b->pins[27].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[27].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[28].name, "ID_SC", MRAA_PIN_NAME_SIZE);
-        b->pins[28].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[28].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[29].name, "GPIO05", MRAA_PIN_NAME_SIZE);
-        b->pins[29].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[29].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[29].gpio.pinmap = 5;
         b->pins[29].gpio.mux_total = 0;
 
         strncpy(b->pins[30].name, "GND", MRAA_PIN_NAME_SIZE);
-        b->pins[30].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[30].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[31].name, "GPIO06", MRAA_PIN_NAME_SIZE);
-        b->pins[31].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[31].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[31].gpio.pinmap = 6;
         b->pins[31].gpio.mux_total = 0;
 
         strncpy(b->pins[32].name, "GPIO12", MRAA_PIN_NAME_SIZE);
-        b->pins[32].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[32].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[32].gpio.pinmap = 12;
         b->pins[32].gpio.mux_total = 0;
 
         strncpy(b->pins[33].name, "GPIO13", MRAA_PIN_NAME_SIZE);
-        b->pins[33].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[33].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[33].gpio.pinmap = 13;
         b->pins[33].gpio.mux_total = 0;
 
         strncpy(b->pins[34].name, "GND", MRAA_PIN_NAME_SIZE);
-        b->pins[34].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[34].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[35].name, "GPIO19", MRAA_PIN_NAME_SIZE);
-        b->pins[35].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[35].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[35].gpio.pinmap = 19;
         b->pins[35].gpio.mux_total = 0;
 
         strncpy(b->pins[36].name, "GPIO16", MRAA_PIN_NAME_SIZE);
-        b->pins[36].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[36].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[36].gpio.pinmap = 16;
         b->pins[36].gpio.mux_total = 0;
 
         strncpy(b->pins[37].name, "GPIO26", MRAA_PIN_NAME_SIZE);
-        b->pins[37].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[37].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[37].gpio.pinmap = 26;
         b->pins[37].gpio.mux_total = 0;
 
         strncpy(b->pins[38].name, "GPIO20", MRAA_PIN_NAME_SIZE);
-        b->pins[38].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[38].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[38].gpio.pinmap = 20;
         b->pins[38].gpio.mux_total = 0;
 
         strncpy(b->pins[39].name, "GND", MRAA_PIN_NAME_SIZE);
-        b->pins[39].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+        b->pins[39].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
         strncpy(b->pins[40].name, "GPIO21", MRAA_PIN_NAME_SIZE);
-        b->pins[40].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+        b->pins[40].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
         b->pins[40].gpio.pinmap = 21;
         b->pins[40].gpio.mux_total = 0;
     }
@@ -556,7 +556,7 @@ mraa_raspberry_pi()
     b->gpio_count = 0;
     int i;
     for (i = 0; i < b->phy_pin_count; i++) {
-        if (b->pins[i].capabilites.gpio) {
+        if (b->pins[i].capabilities.gpio) {
             b->gpio_count++;
         }
     }

src/firmata/firmata_mraa.c

@@ -351,6 +351,9 @@ mraa_firmata_aio_read(mraa_aio_context dev)
 static mraa_result_t
 mraa_firmata_aio_init_internal_replace(mraa_aio_context dev, int aio)
 {
+    // set the channel, since we override internal it's never set
+    // offset by 14 because it makes total logical sense.
+    dev->channel = aio + 14;
     // firmata considers A0 pin0 as well as actual pin0 :/
     firmata_pinMode(firmata_dev, aio, MODE_ANALOG);
     // register for updates on that ADC channel
@@ -568,69 +571,69 @@ mraa_firmata_plat_init(const char* uart_dev)
     }
 
     strncpy(b->pins[0].name, "IO0", 8);
-    b->pins[0].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[0].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[0].gpio.pinmap = 0;
     strncpy(b->pins[1].name, "IO1", 8);
-    b->pins[1].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[1].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[1].gpio.pinmap = 1;
     strncpy(b->pins[2].name, "IO2", 8);
-    b->pins[2].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[2].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[2].gpio.pinmap = 2;
     strncpy(b->pins[3].name, "IO3", 8);
-    b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[3].gpio.pinmap = 3;
     strncpy(b->pins[4].name, "IO4", 8);
-    b->pins[4].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[4].gpio.pinmap = 4;
     strncpy(b->pins[5].name, "IO5", 8);
-    b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[5].gpio.pinmap = 5;
     strncpy(b->pins[6].name, "IO6", 8);
-    b->pins[6].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[6].gpio.pinmap = 6;
     strncpy(b->pins[7].name, "IO7", 8);
-    b->pins[7].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[7].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[7].gpio.pinmap = 7;
     strncpy(b->pins[8].name, "IO8", 8);
-    b->pins[8].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[8].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[8].gpio.pinmap = 8;
     strncpy(b->pins[9].name, "IO9", 8);
-    b->pins[9].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[9].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[9].gpio.pinmap = 9;
     strncpy(b->pins[10].name, "IO10", 8);
-    b->pins[10].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[10].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[10].gpio.pinmap = 10;
     strncpy(b->pins[11].name, "IO11", 8);
-    b->pins[11].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[11].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[11].gpio.pinmap = 11;
     strncpy(b->pins[12].name, "IO12", 8);
-    b->pins[12].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[12].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[12].gpio.pinmap = 12;
     strncpy(b->pins[13].name, "IO13", 8);
-    b->pins[13].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[13].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[13].gpio.pinmap = 13;
     strncpy(b->pins[10].name, "A0", 8);
-    b->pins[14].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[14].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[14].gpio.pinmap = 14;
     b->pins[14].aio.pinmap = 14;
     strncpy(b->pins[11].name, "A1", 8);
-    b->pins[15].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[15].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[15].gpio.pinmap = 15;
     b->pins[15].aio.pinmap = 15;
     strncpy(b->pins[12].name, "A2", 8);
-    b->pins[16].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[16].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[16].gpio.pinmap = 16;
     b->pins[16].aio.pinmap = 16;
     strncpy(b->pins[13].name, "A3", 8);
-    b->pins[17].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[17].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[17].gpio.pinmap = 17;
     b->pins[17].aio.pinmap = 17;
     strncpy(b->pins[13].name, "A4", 8);
-    b->pins[18].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[18].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[18].gpio.pinmap = 18;
     b->pins[18].aio.pinmap = 18;
     strncpy(b->pins[13].name, "A5", 8);
-    b->pins[19].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[19].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[19].gpio.pinmap = 19;
     b->pins[19].aio.pinmap = 19;
 

src/gpio/gpio.c

@@ -151,7 +151,7 @@ mraa_gpio_init(int pin)
         syslog(LOG_ERR, "gpio: init: pin %i beyond platform pin count (%i)", pin, board->phy_pin_count);
         return NULL;
     }
-    if (board->pins[pin].capabilites.gpio != 1) {
+    if (board->pins[pin].capabilities.gpio != 1) {
         syslog(LOG_ERR, "gpio: init: pin %i not capable of gpio", pin);
         return NULL;
     }
@@ -382,6 +382,10 @@ mraa_gpio_isr(mraa_gpio_context dev, mraa_gpio_edge_t mode, void (*fptr)(void*),
         return MRAA_ERROR_INVALID_HANDLE;
     }
 
+    if (IS_FUNC_DEFINED(dev, gpio_isr_replace)) {
+        return dev->advance_func->gpio_isr_replace(dev, mode, fptr, args);
+    }
+
     // we only allow one isr per mraa_gpio_context
     if (dev->thread_id != 0) {
         return MRAA_ERROR_NO_RESOURCES;
@@ -417,6 +421,10 @@ mraa_gpio_isr_exit(mraa_gpio_context dev)
         return MRAA_ERROR_INVALID_HANDLE;
     }
 
+    if (IS_FUNC_DEFINED(dev, gpio_isr_exit_replace)) {
+        return dev->advance_func->gpio_isr_exit_replace(dev);
+    }
+
     // wasting our time, there is no isr to exit from
     if (dev->thread_id == 0 && dev->isr_value_fp == -1) {
         return ret;
@@ -605,6 +613,15 @@ mraa_gpio_read_dir(mraa_gpio_context dev, mraa_gpio_dir_t *dir)
         return MRAA_ERROR_INVALID_HANDLE;
     }
 
+    if (dir == NULL) {
+        syslog(LOG_ERR, "gpio: read_dir: output parameter for dir is invalid");
+        return MRAA_ERROR_INVALID_HANDLE;
+    }
+
+    if (IS_FUNC_DEFINED(dev, gpio_read_dir_replace)) {
+        return dev->advance_func->gpio_read_dir_replace(dev, dir);
+    }
+
     snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/direction", dev->pin);
     fd = open(filepath, O_RDONLY);
     if (fd == -1) {

src/i2c/i2c.c

@@ -34,6 +34,9 @@
 #include <inttypes.h>
 #include <sys/types.h>
 #include <sys/errno.h>
+#if defined(MSYS)
+#define __USE_LINUX_IOCTL_DEFS
+#endif
 #include <sys/ioctl.h>
 #include "linux/i2c-dev.h"
 #include <errno.h>
@@ -194,6 +197,11 @@ mraa_i2c_init_raw(unsigned int bus)
 mraa_result_t
 mraa_i2c_frequency(mraa_i2c_context dev, mraa_i2c_mode_t mode)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: frequency: context is invalid");
+        return MRAA_ERROR_INVALID_HANDLE;
+    }
+
     if (IS_FUNC_DEFINED(dev, i2c_set_frequency_replace)) {
         return dev->advance_func->i2c_set_frequency_replace(dev, mode);
     }
@@ -203,6 +211,11 @@ mraa_i2c_frequency(mraa_i2c_context dev, mraa_i2c_mode_t mode)
 int
 mraa_i2c_read(mraa_i2c_context dev, uint8_t* data, int length)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: read: context is invalid");
+        return -1;
+    }
+
     int bytes_read = 0;
     if (IS_FUNC_DEFINED(dev, i2c_read_replace)) {
         bytes_read = dev->advance_func->i2c_read_replace(dev, data, length);
@@ -220,6 +233,11 @@ mraa_i2c_read(mraa_i2c_context dev, uint8_t* data, int length)
 int
 mraa_i2c_read_byte(mraa_i2c_context dev)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: read_byte: context is invalid");
+        return -1;
+    }
+
     if (IS_FUNC_DEFINED(dev, i2c_read_byte_replace))
         return dev->advance_func->i2c_read_byte_replace(dev);
     i2c_smbus_data_t d;
@@ -233,6 +251,11 @@ mraa_i2c_read_byte(mraa_i2c_context dev)
 int
 mraa_i2c_read_byte_data(mraa_i2c_context dev, uint8_t command)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: read_byte_data: context is invalid");
+        return -1;
+    }
+
     if (IS_FUNC_DEFINED(dev, i2c_read_byte_data_replace))
         return dev->advance_func->i2c_read_byte_data_replace(dev, command);
     i2c_smbus_data_t d;
@@ -246,6 +269,11 @@ mraa_i2c_read_byte_data(mraa_i2c_context dev, uint8_t command)
 int
 mraa_i2c_read_word_data(mraa_i2c_context dev, uint8_t command)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: read_word_data: context is invalid");
+        return -1;
+    }
+
     if (IS_FUNC_DEFINED(dev, i2c_read_word_data_replace))
         return dev->advance_func->i2c_read_word_data_replace(dev, command);
     i2c_smbus_data_t d;
@@ -259,6 +287,11 @@ mraa_i2c_read_word_data(mraa_i2c_context dev, uint8_t command)
 int
 mraa_i2c_read_bytes_data(mraa_i2c_context dev, uint8_t command, uint8_t* data, int length)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: read_bytes_data: context is invalid");
+        return -1;
+    }
+
     if (IS_FUNC_DEFINED(dev, i2c_read_bytes_data_replace))
         return dev->advance_func->i2c_read_bytes_data_replace(dev, command, data, length);
     struct i2c_rdwr_ioctl_data d;
@@ -289,6 +322,11 @@ mraa_i2c_read_bytes_data(mraa_i2c_context dev, uint8_t command, uint8_t* data, i
 mraa_result_t
 mraa_i2c_write(mraa_i2c_context dev, const uint8_t* data, int length)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: write: context is invalid");
+        return MRAA_ERROR_INVALID_HANDLE;
+    }
+
     if (IS_FUNC_DEFINED(dev, i2c_write_replace))
         return dev->advance_func->i2c_write_replace(dev, data, length);
     i2c_smbus_data_t d;
@@ -316,6 +354,11 @@ mraa_i2c_write(mraa_i2c_context dev, const uint8_t* data, int length)
 mraa_result_t
 mraa_i2c_write_byte(mraa_i2c_context dev, const uint8_t data)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: write_byte: context is invalid");
+        return MRAA_ERROR_INVALID_HANDLE;
+    }
+
     if (IS_FUNC_DEFINED(dev, i2c_write_byte_replace)) {
         return dev->advance_func->i2c_write_byte_replace(dev, data);
     } else {
@@ -330,6 +373,11 @@ mraa_i2c_write_byte(mraa_i2c_context dev, const uint8_t data)
 mraa_result_t
 mraa_i2c_write_byte_data(mraa_i2c_context dev, const uint8_t data, const uint8_t command)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: write_byte_data: context is invalid");
+        return MRAA_ERROR_INVALID_HANDLE;
+    }
+
     if (IS_FUNC_DEFINED(dev, i2c_write_byte_data_replace))
         return dev->advance_func->i2c_write_byte_data_replace(dev, data, command);
     i2c_smbus_data_t d;
@@ -344,6 +392,11 @@ mraa_i2c_write_byte_data(mraa_i2c_context dev, const uint8_t data, const uint8_t
 mraa_result_t
 mraa_i2c_write_word_data(mraa_i2c_context dev, const uint16_t data, const uint8_t command)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: write_word_data: context is invalid");
+        return MRAA_ERROR_INVALID_HANDLE;
+    }
+
     if (IS_FUNC_DEFINED(dev, i2c_write_word_data_replace))
         return dev->advance_func->i2c_write_word_data_replace(dev, data, command);
     i2c_smbus_data_t d;
@@ -359,6 +412,7 @@ mraa_result_t
 mraa_i2c_address(mraa_i2c_context dev, uint8_t addr)
 {
     if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: address: context is invalid");
         return MRAA_ERROR_INVALID_HANDLE;
     }
 
@@ -378,6 +432,15 @@ mraa_i2c_address(mraa_i2c_context dev, uint8_t addr)
 mraa_result_t
 mraa_i2c_stop(mraa_i2c_context dev)
 {
+    if (dev == NULL) {
+        syslog(LOG_ERR, "i2c: stop: context is invalid");
+        return MRAA_ERROR_INVALID_HANDLE;
+    }
+
+    if (IS_FUNC_DEFINED(dev, i2c_stop_replace)) {
+        return dev->advance_func->i2c_stop_replace(dev);
+    }
+
     free(dev);
     return MRAA_SUCCESS;
 }

src/iio/iio.c

@@ -27,13 +27,15 @@
 #include "dirent.h"
 #include <string.h>
 #include <poll.h>
+#if defined(MSYS)
+#define __USE_LINUX_IOCTL_DEFS
+#endif
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 
 #define MAX_SIZE 128
 #define IIO_DEVICE "iio:device"
 #define IIO_SCAN_ELEM "scan_elements"
-#define IIO_MOUNTING_MATRIX "mounting_matrix"
 #define IIO_SLASH_DEV "/dev/" IIO_DEVICE
 #define IIO_SYSFS_DEVICE "/sys/bus/iio/devices/" IIO_DEVICE
 #define IIO_EVENTS "events"
@@ -546,18 +548,18 @@ mraa_iio_event_extract_event(struct iio_event_data* event,
 }
 
 mraa_result_t
-mraa_iio_get_mounting_matrix(mraa_iio_context dev, float mm[9])
+mraa_iio_get_mount_matrix(mraa_iio_context dev, const char *sysfs_name, float mm[9])
 {
     char buf[MAX_SIZE];
     FILE* fp;
     int ret;
 
     memset(buf, 0, MAX_SIZE);
-    snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_MOUNTING_MATRIX, dev->num);
+    snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, sysfs_name);
     fp = fopen(buf, "r");
     if (fp != NULL) {
-        ret = fscanf(fp, "%f %f %f\n%f %f %f\n%f %f %f\n", &mm[0], &mm[1], &mm[2], &mm[3], &mm[4], &mm[5],
-               &mm[6], &mm[7], &mm[8]);
+        ret = fscanf(fp, "%f, %f, %f; %f, %f, %f; %f, %f, %f\n", &mm[0], &mm[1], &mm[2], &mm[3],
+                     &mm[4], &mm[5],&mm[6], &mm[7], &mm[8]);
         fclose(fp);
         if (ret != 9) {
             return MRAA_ERROR_UNSPECIFIED;

src/java/CMakeLists.txt

@@ -33,7 +33,7 @@ add_custom_command (TARGET mraajava
   COMMAND cmake -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/mraa
   COMMAND ${JAVAC} *.java -d ${CMAKE_CURRENT_BINARY_DIR}
   COMMAND cmake -E echo "Creating jar"
-  COMMAND ${JAR} cvf mraa.jar mraa
+  COMMAND ${JAR} cvmf manifest.txt mraa.jar mraa
 )
 
 if (DOXYGEN_FOUND)

src/java/manifest.txt.in

@@ -0,0 +1,7 @@
+Manifest-version: 1.0
+
+Name: mraa/
+Specification-Title: mraa
+Specification-Version: @VERSION_SHORT@
+Package-Title: mraa
+Package-Version: @VERSION_SHORT@

src/java/mraajava.i

@@ -96,5 +96,34 @@ class Spi;
             System.err.println("Native code library failed to load. \n" + e);
             System.exit(1);
         }
+
+        String javaAPIVersion = mraa.class.getPackage().getSpecificationVersion();
+        String nativeAPIVersion = mraa.getVersion().substring(1);
+
+        String javaMajor = javaAPIVersion.substring(0, javaAPIVersion.indexOf('.'));
+        String nativeMajor = nativeAPIVersion.substring(0, nativeAPIVersion.indexOf('.'));
+
+        if(Integer.parseInt(javaMajor) < Integer.parseInt(nativeMajor)){
+            System.err.println("Java library is out of date. Please update the Java library.");
+            System.err.println("Native library version is " + nativeAPIVersion + ". Java library version is " + javaAPIVersion + ".");
+            System.exit(1);
+        }
+        if(Integer.parseInt(javaMajor) > Integer.parseInt(nativeMajor)){
+            System.err.println("Native library is out of date. Please update the Native library.");
+            System.err.println("Native library version is " + nativeAPIVersion + ". Java library version is " + javaAPIVersion + ".");
+            System.exit(1);
+        }
+
+        String javaMinor = javaAPIVersion.substring(javaMajor.length() + 1, javaAPIVersion.indexOf('.', javaMajor.length() + 1));
+        String nativeMinor = nativeAPIVersion.substring(nativeMajor.length() + 1, nativeAPIVersion.indexOf('.', nativeMajor.length() + 1));
+
+        if(Integer.parseInt(javaMinor) < Integer.parseInt(nativeMinor)){
+            System.err.println("Java library is out of date. Please consider updating the Java library.");
+            System.err.println("Native library version is " + nativeAPIVersion + ". Java library version is " + javaAPIVersion + ".");
+        }
+        if(Integer.parseInt(javaMinor) > Integer.parseInt(nativeMinor)){
+            System.err.println("Native library is out of date. Please consider updating the Native library.");
+            System.err.println("Native library version is " + nativeAPIVersion + ". Java library version is " + javaAPIVersion + ".");
+        }
     }
 %}

src/json/jsonplatform.c

@@ -0,0 +1,716 @@
+/*
+ * Author: Houman Brinjcargorabi <Houman.Brinjcargorabi@intel.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * 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 <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+
+#include <json-c/json.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+
+#include "mraa_internal.h"
+
+typedef mraa_result_t (*init_plat_func_t)(json_object*, mraa_board_t*, int);
+
+mraa_result_t
+mraa_init_json_platform_get_pin(json_object* jobj, const char* io, const char* key, int index, int* pin)
+{
+    json_object* jobj_temp = NULL;
+    if (json_object_object_get_ex(jobj, key, &jobj_temp)) {
+        if (!json_object_is_type(jobj_temp, json_type_int)) {
+            syslog(LOG_ERR, "init_json_platform: %s %s at position: %d is not an int", io, key, index);
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+        *pin = (unsigned int) json_object_get_int(jobj_temp);
+        return MRAA_SUCCESS;
+    }
+    syslog(LOG_ERR, "init_json_platform: No %s specified for %s at position: %d", key, io, index);
+    return MRAA_ERROR_NO_DATA_AVAILABLE;
+}
+
+mraa_result_t
+mraa_init_json_platform_get_index(json_object* jobj, const char* io, const char* key, int index, int* pos, int upper)
+{
+    json_object* jobj_temp = NULL;
+    if (json_object_object_get_ex(jobj, key, &jobj_temp)) {
+        if (!json_object_is_type(jobj_temp, json_type_int)) {
+            syslog(LOG_ERR, "init_json_platform: %s index at position: %d not an int", io, index);
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+
+        *pos = (int) json_object_get_int(jobj_temp);
+        if (*pos < 0 || *pos > upper) {
+            syslog(LOG_ERR,
+                   "init_json_platform: %s %s at position: %d, gave: %d which was out of range", io,
+                   key, index, *pos);
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+        return MRAA_SUCCESS;
+    }
+    syslog(LOG_ERR, "init_json_platform: An %s was not found for the %s", key, io);
+    return MRAA_ERROR_NO_DATA_AVAILABLE;
+}
+
+mraa_result_t
+mraa_init_json_platform_platform(json_object* jobj_platform, mraa_board_t* board, int index)
+{
+    json_object* jobj_temp = NULL;
+    const char* temp_string = NULL;
+    int temp_count = 0;
+    int length = 0;
+    mraa_result_t ret = MRAA_SUCCESS;
+
+    // Set the platform name
+    if (json_object_object_get_ex(jobj_platform, NAME_KEY, &jobj_temp)) {
+        if (!json_object_is_type(jobj_temp, json_type_string)) {
+            syslog(LOG_ERR, "init_json_platform: Platform name not a string");
+            return MRAA_ERROR_NO_RESOURCES;
+        }
+        temp_string = json_object_get_string(jobj_temp);
+        if (temp_string == NULL || (length = strlen(temp_string)) == 0) {
+            syslog(LOG_ERR, "init_json_platform: Empty string provided for \"%s\" key in platform", NAME_KEY);
+            return MRAA_ERROR_NO_DATA_AVAILABLE;
+        }
+        board->platform_name = (char*) calloc(length, sizeof(char));
+        strncpy(board->platform_name, temp_string, length);
+    } else {
+        syslog(LOG_ERR, "init_json_platform: No \"%s\" key in platform", NAME_KEY);
+        return MRAA_ERROR_NO_DATA_AVAILABLE;
+    }
+
+    // Get the physical pincount
+    ret = mraa_init_json_platform_get_pin(jobj_platform, PLATFORM_KEY, PIN_COUNT_KEY, index,
+                                          &(board->phy_pin_count));
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+
+    // Setup the pins
+    board->pins = (mraa_pininfo_t*) calloc(board->phy_pin_count, sizeof(mraa_pininfo_t));
+    if (board->pins == NULL) {
+        syslog(LOG_ERR, "init_json_platform: Unable to allocate space for the pins");
+        return MRAA_ERROR_INVALID_RESOURCE;
+    }
+
+    // set the inital counts to -1 so we know if they don't exist
+    board->gpio_count = -1;
+    board->aio_count = -1;
+    board->uart_dev_count = -1;
+    board->i2c_bus_count = -1;
+    board->spi_bus_count = -1;
+
+    // Check to see if they've provided a GPIO count
+    ret = mraa_init_json_platform_get_index(jobj_platform, PLATFORM_KEY, GPIO_COUNT_KEY, index,
+                                            &(board->gpio_count), board->phy_pin_count);
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        return ret;
+    }
+
+    // Check to see if they've provided a AIO count
+    ret = mraa_init_json_platform_get_index(jobj_platform, PLATFORM_KEY, AIO_COUNT_KEY, index,
+                                            &(board->aio_count), board->phy_pin_count);
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        return ret;
+    }
+
+    // Check to see if they've provided a UART count
+    ret = mraa_init_json_platform_get_index(jobj_platform, PLATFORM_KEY, UART_COUNT_KEY, index,
+                                            &(board->uart_dev_count), 6);
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        return ret;
+    }
+    // Check to see if they've provided a I2C count
+    ret = mraa_init_json_platform_get_index(jobj_platform, PLATFORM_KEY, I2C_COUNT_KEY, index,
+                                            &(board->i2c_bus_count), 12);
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        return ret;
+    }
+    // Check to see if they've provided a SPI count
+    ret = mraa_init_json_platform_get_index(jobj_platform, PLATFORM_KEY, SPI_COUNT_KEY, index,
+                                            &(board->spi_bus_count), 12);
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        return ret;
+    }
+
+    // Set the PWM default numbers
+    board->pwm_default_period = -1;
+    board->pwm_max_period = -1;
+    board->pwm_min_period = -1;
+
+    // Setup the PWM rates if they exist
+    ret = mraa_init_json_platform_get_pin(jobj_platform, PLATFORM_KEY, PWMDEFAULT_KEY, index,
+                                          &(board->pwm_default_period));
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        return ret;
+    }
+    ret = mraa_init_json_platform_get_pin(jobj_platform, PLATFORM_KEY, PWMMAX_KEY, index,
+                                          &(board->pwm_max_period));
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        return ret;
+    }
+    ret = mraa_init_json_platform_get_pin(jobj_platform, PLATFORM_KEY, PWMMIN_KEY, index,
+                                          &(board->pwm_min_period));
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        return ret;
+    }
+
+    // A hacky logical xor to ensure the value's have all been set or none should have been set
+    // Here we infer that IF A != B and B != C then A == C since they're working on binary values
+    if (((board->pwm_default_period == -1) != (board->pwm_max_period == -1)) ||
+        ((board->pwm_min_period == -1) != (board->pwm_max_period == -1))) {
+        syslog(LOG_ERR, "init_json_platform: One of more PWM settings missing in the platform"
+                        "configuration");
+        return MRAA_ERROR_INVALID_RESOURCE;
+    }
+    // Set our platform type
+    board->platform_type = MRAA_JSON_PLATFORM;
+    board->adv_func = (mraa_adv_func_t*) calloc(1, sizeof(mraa_adv_func_t));
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_init_json_platform_io(json_object* jobj_io, mraa_board_t* board, int index)
+{
+    const char* temp_string = NULL;
+    json_object* jobj_temp = NULL;
+    int pos = 0;
+    int invalid = 0;
+    pos = index;
+
+    // set the label for the IO
+    if (json_object_object_get_ex(jobj_io, LABEL_KEY, &jobj_temp)) {
+        if (!json_object_is_type(jobj_temp, json_type_string)) {
+            syslog(LOG_ERR, "init_json_platform: IO label at position: %d not a string", index);
+            return MRAA_ERROR_NO_RESOURCES;
+        }
+        temp_string = json_object_get_string(jobj_temp);
+        // set the gpio label
+        strncpy(board->pins[pos].name, temp_string, 8);
+    } else {
+        syslog(LOG_ERR, "init_json_platform: No IO Label");
+        return MRAA_ERROR_INVALID_RESOURCE;
+    }
+    if (json_object_object_get_ex(jobj_io, INVALID_KEY, &jobj_temp)) {
+        if (!json_object_is_type(jobj_temp, json_type_boolean)) {
+            syslog(LOG_ERR, "init_json_platform: Default I2C device key has an incorrect value");
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+        invalid = json_object_get_boolean(jobj_temp);
+    }
+    if (invalid) {
+        board->pins[pos].capabilities = (mraa_pincapabilities_t){ 0, 0, 0, 0, 0, 0, 0, 0 };
+    } else {
+        board->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    }
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_init_json_platform_gpio(json_object* jobj_gpio, mraa_board_t* board, int index)
+{
+    int pos = 0;
+    mraa_result_t ret = MRAA_SUCCESS;
+
+    // Get the gpio index
+    ret = mraa_init_json_platform_get_index(jobj_gpio, GPIO_KEY, INDEX_KEY, index, &pos,
+                                            board->phy_pin_count - 1);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+    // Get the gpio sysfs pin;
+    ret = mraa_init_json_platform_get_pin(jobj_gpio, GPIO_KEY, RAW_PIN_KEY, index,
+                                          &(board->pins[pos].gpio.pinmap));
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+    board->pins[pos].capabilities.gpio = 1;
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_init_json_platform_aio(json_object* jobj_aio, mraa_board_t* board, int index)
+{
+    int pos = 0;
+    mraa_result_t ret = MRAA_SUCCESS;
+
+    // Get the gpio index
+    ret = mraa_init_json_platform_get_index(jobj_aio, AIO_KEY, INDEX_KEY, index, &pos, board->phy_pin_count - 1);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+
+    // Get the gpio sysfs pin;
+    ret = mraa_init_json_platform_get_pin(jobj_aio, AIO_KEY, RAW_PIN_KEY, index,
+                                          &(board->pins[pos].aio.pinmap));
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+
+    board->pins[pos].capabilities.aio = 1;
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_init_json_platform_i2c(json_object* jobj_i2c, mraa_board_t* board, int index)
+{
+    int pos = 0;
+    int pin = 0;
+    int sysfs_pin = 0;
+    mraa_result_t ret = MRAA_SUCCESS;
+    json_object* jobj_temp = NULL;
+
+    // Get the I2C bus array index
+    ret = mraa_init_json_platform_get_index(jobj_i2c, I2C_KEY, INDEX_KEY, index, &pos, board->i2c_bus_count - 1);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+    // Get the sysfs pin
+    ret = mraa_init_json_platform_get_pin(jobj_i2c, I2C_KEY, RAW_PIN_KEY, index, &sysfs_pin);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+    // Setup the sda pin
+    ret = mraa_init_json_platform_get_index(jobj_i2c, I2C_KEY, SDAPIN_KEY, index, &pin,
+                                            board->phy_pin_count - 1);
+    if (ret == MRAA_ERROR_NO_DATA_AVAILABLE) {
+        board->i2c_bus[pos].sda = -1;
+    } else if (ret == MRAA_SUCCESS) {
+        board->pins[pin].capabilities.i2c = 1;
+        board->pins[pin].i2c.pinmap = sysfs_pin;
+        board->i2c_bus[pos].sda = pin;
+    } else {
+        return ret;
+    }
+    // Setup the scl pin
+    ret = mraa_init_json_platform_get_index(jobj_i2c, I2C_KEY, SCLPIN_KEY, index, &pin,
+                                            board->phy_pin_count - 1);
+    if (ret == MRAA_ERROR_NO_DATA_AVAILABLE) {
+        board->i2c_bus[pos].scl = -1;
+    } else if (ret == MRAA_SUCCESS) {
+        board->pins[pin].capabilities.i2c = 1;
+        board->pins[pin].i2c.pinmap = sysfs_pin;
+        board->i2c_bus[pos].scl = pin;
+    } else {
+        return ret;
+    }
+
+    board->i2c_bus[pos].bus_id = pos;
+
+    // check to see if this i2c is the default one
+    if (json_object_object_get_ex(jobj_i2c, DEFAULT_KEY, &jobj_temp)) {
+        if (!json_object_is_type(jobj_temp, json_type_boolean)) {
+            syslog(LOG_ERR, "init_json_platform: Default I2C device key has an incorrect value");
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+        if (json_object_get_boolean(jobj_temp)) {
+            board->def_i2c_bus = pos;
+        }
+    }
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_init_json_platform_pwm(json_object* jobj_pwm, mraa_board_t* board, int index)
+{
+    int pos = 0;
+    int parent_id = 0;
+    int sysfs_pin = 0;
+    mraa_result_t ret = MRAA_SUCCESS;
+
+    // Get the index into the physical pin array
+    ret = mraa_init_json_platform_get_index(jobj_pwm, PWM_KEY, INDEX_KEY, index, &pos, board->phy_pin_count - 1);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+    // Get the parent id
+    ret = mraa_init_json_platform_get_pin(jobj_pwm, PWM_KEY, CHIP_ID_KEY, index, &parent_id);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+    // Get the sysfs pin
+    ret = mraa_init_json_platform_get_pin(jobj_pwm, PWM_KEY, RAW_PIN_KEY, index, &sysfs_pin);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+
+    board->pins[pos].capabilities.pwm = 1;
+    board->pins[pos].pwm.pinmap = sysfs_pin;
+    board->pins[pos].pwm.parent_id = parent_id;
+    return ret;
+}
+
+mraa_result_t
+mraa_init_json_platform_spi(json_object* jobj_spi, mraa_board_t* board, int index)
+{
+    int pos = 0;
+    int pin = 0;
+    int parent_id = 0;
+    json_object* jobj_temp = NULL;
+    mraa_result_t ret = MRAA_SUCCESS;
+
+    // Get the index into the physical pin array
+    ret = mraa_init_json_platform_get_index(jobj_spi, SPI_KEY, INDEX_KEY, index, &pos, board->spi_bus_count - 1);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+
+    // Get the parent id
+    ret = mraa_init_json_platform_get_pin(jobj_spi, SPI_KEY, CHIP_ID_KEY, index, &parent_id);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+
+    // Setup the clock pin
+    ret = mraa_init_json_platform_get_index(jobj_spi, SPI_KEY, CLOCK_KEY, index, &pin, board->phy_pin_count - 1);
+    if (ret == MRAA_ERROR_NO_DATA_AVAILABLE) {
+        board->spi_bus[pos].sclk = -1;
+    } else if (ret == MRAA_SUCCESS) {
+        board->pins[pin].capabilities.spi = 1;
+        board->pins[pin].spi.parent_id = parent_id;
+        board->spi_bus[pos].sclk = pin;
+    } else {
+        return ret;
+    }
+    // Setup the MISO pin
+    ret = mraa_init_json_platform_get_index(jobj_spi, SPI_KEY, MISO_KEY, index, &pin, board->phy_pin_count - 1);
+    if (ret == MRAA_ERROR_NO_DATA_AVAILABLE) {
+        board->spi_bus[pos].miso = -1;
+    } else if (ret == MRAA_SUCCESS) {
+        board->pins[pin].capabilities.spi = 1;
+        board->pins[pin].spi.parent_id = parent_id;
+        board->spi_bus[pos].miso = pin;
+    } else {
+        return ret;
+    }
+    // Setup the MOSI pin
+    ret = mraa_init_json_platform_get_index(jobj_spi, SPI_KEY, MOSI_KEY, index, &pin, board->phy_pin_count - 1);
+    if (ret == MRAA_ERROR_NO_DATA_AVAILABLE) {
+        board->spi_bus[pos].mosi = -1;
+    } else if (ret == MRAA_SUCCESS) {
+        board->pins[pin].capabilities.spi = 1;
+        board->pins[pin].spi.parent_id = parent_id;
+        board->spi_bus[pos].mosi = pin;
+    } else {
+        return ret;
+    }
+    // Setup the CS pin
+    ret = mraa_init_json_platform_get_index(jobj_spi, SPI_KEY, CS_KEY, index, &pin, board->phy_pin_count - 1);
+    if (ret == MRAA_ERROR_NO_DATA_AVAILABLE) {
+        board->spi_bus[pos].cs = -1;
+    } else if (ret == MRAA_SUCCESS) {
+        board->pins[pin].capabilities.spi = 1;
+        board->pins[pin].spi.parent_id = parent_id;
+        board->spi_bus[pos].cs = pin;
+    } else {
+        return ret;
+    }
+    // check to see if this SPI is the default one
+    if (json_object_object_get_ex(jobj_spi, DEFAULT_KEY, &jobj_temp)) {
+        if (!json_object_is_type(jobj_temp, json_type_boolean)) {
+            syslog(LOG_ERR, "init_json_platform: Default I2C device key has an incorrect value");
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+        if (json_object_get_boolean(jobj_temp)) {
+            board->def_spi_bus = pos;
+        }
+    }
+    return ret;
+}
+
+mraa_result_t
+mraa_init_json_platform_uart(json_object* jobj_uart, mraa_board_t* board, int index)
+{
+    json_object* jobj_temp = NULL;
+    mraa_result_t ret = MRAA_SUCCESS;
+    int pos = 0;
+    int pin = 0;
+    int sysfs_pin = 0;
+    int parent_id = 0;
+    int length = 0;
+    const char* temp_string = NULL;
+
+    // Get the index into the uart bus
+    ret = mraa_init_json_platform_get_index(jobj_uart, UART_KEY, INDEX_KEY, index, &pos,
+                                            board->uart_dev_count - 1);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+
+    // Get the parent id
+    ret = mraa_init_json_platform_get_pin(jobj_uart, UART_KEY, CHIP_ID_KEY, index, &parent_id);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+    // Get the sysfs pin
+    ret = mraa_init_json_platform_get_pin(jobj_uart, UART_KEY, RAW_PIN_KEY, index, &sysfs_pin);
+    if (ret != MRAA_SUCCESS) {
+        return ret;
+    }
+
+    // Setup the rx pin
+    ret = mraa_init_json_platform_get_index(jobj_uart, UART_KEY, RXPIN_KEY, index, &pin,
+                                            board->phy_pin_count - 1);
+    if (ret == MRAA_ERROR_NO_DATA_AVAILABLE) {
+        board->uart_dev[pos].rx = -1;
+    } else if (ret == MRAA_SUCCESS) {
+        board->pins[pin].capabilities.uart = 1;
+        board->pins[pin].uart.pinmap = sysfs_pin;
+        board->pins[pin].uart.parent_id = parent_id;
+        board->uart_dev[pos].rx = pin;
+    } else {
+        return ret;
+    }
+
+    // Setup the TX pin
+    ret = mraa_init_json_platform_get_index(jobj_uart, UART_KEY, TXPIN_KEY, index, &pin,
+                                            board->phy_pin_count - 1);
+    if (ret == MRAA_ERROR_NO_DATA_AVAILABLE) {
+        board->uart_dev[pos].tx = -1;
+    } else if (ret == MRAA_SUCCESS) {
+        board->pins[pin].capabilities.uart = 1;
+        board->pins[pin].uart.pinmap = sysfs_pin;
+        board->pins[pin].uart.parent_id = parent_id;
+        board->uart_dev[pos].tx = pin;
+    } else {
+        return ret;
+    }
+
+    // Setup the path
+    if (json_object_object_get_ex(jobj_uart, UART_PATH_KEY, &jobj_temp)) {
+        if (!json_object_is_type(jobj_temp, json_type_string)) {
+            syslog(LOG_ERR, "init_json_platform: UART Path at index: %d was not a string", index);
+            return MRAA_ERROR_NO_RESOURCES;
+        }
+        temp_string = json_object_get_string(jobj_temp);
+        if (temp_string == NULL || (length = strlen(temp_string)) == 0) {
+            syslog(LOG_ERR, "init_json_platform: UART Path at index: %d was empty", index);
+            return MRAA_ERROR_NO_DATA_AVAILABLE;
+        }
+        board->uart_dev[pos].device_path = (char*) calloc(length, sizeof(char));
+        strncpy(board->uart_dev[pos].device_path, temp_string, length);
+    } else {
+        syslog(LOG_ERR, "init_json_platform: UART config at index: %d needs a path", index);
+        return MRAA_ERROR_NO_DATA_AVAILABLE;
+    }
+
+    // If this element is supposed to be default set it.
+    if (json_object_object_get_ex(jobj_uart, DEFAULT_KEY, &jobj_temp)) {
+        if (!json_object_is_type(jobj_temp, json_type_boolean)) {
+            syslog(LOG_ERR, "init_json_platform: Default UART device key has an incorrect value");
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+        if (json_object_get_boolean(jobj_temp)) {
+            board->def_uart_dev = pos;
+        }
+    }
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_init_json_platform_loop(json_object* jobj_platform, const char* obj_key, mraa_board_t* board, init_plat_func_t func)
+{
+    mraa_result_t ret = MRAA_SUCCESS;
+    int i = 0, array_length = 0;
+    json_object *jobj_temp = NULL, *jobj_io = NULL;
+    if (json_object_object_get_ex(jobj_platform, obj_key, &jobj_temp)) {
+        array_length = json_object_array_length(jobj_temp);
+        for (i = 0; i < array_length; i++) {
+            // Get the json object at position i
+            jobj_io = json_object_array_get_idx(jobj_temp, i);
+            // Check to see it's the right type
+            if (!json_object_is_type(jobj_io, json_type_object)) {
+                syslog(LOG_ERR, "init_json_platform: One of more of the elements in the \"%s\" "
+                                "array where not JSON objects",
+                       obj_key);
+                return MRAA_ERROR_INVALID_RESOURCE;
+            }
+            ret = (*func)(jobj_io, board, i);
+            if (ret != MRAA_SUCCESS) {
+                return ret;
+            }
+        }
+    } else {
+        syslog(LOG_ERR, "init_json_platform: No \"%s\" info found in json file", obj_key);
+        ret = MRAA_ERROR_NO_DATA_AVAILABLE;
+    }
+    return ret;
+}
+
+mraa_result_t
+mraa_init_json_platform_size_check(json_object* jobj_platform,
+                                   const char* obj_key,
+                                   mraa_board_t* board,
+                                   init_plat_func_t func,
+                                   int range)
+{
+    json_object* jobj_temp = NULL;
+    mraa_result_t ret = MRAA_SUCCESS;
+    int array_length = 0;
+    if (json_object_object_get_ex(jobj_platform, obj_key, &jobj_temp)) {
+        // Make sure the value for the key is an array
+        if (!json_object_is_type(jobj_temp, json_type_array)) {
+            syslog(LOG_ERR, "init_json_platform: json key \"%s\" should be an array", obj_key);
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+        // make sure we don't have more than our range
+        array_length = json_object_array_length(jobj_temp);
+        if (array_length > range) {
+            syslog(LOG_ERR,
+                   "init_json_platform: The size of the %s array given was %d, max was: %d",
+                   obj_key, array_length, range);
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+        ret = mraa_init_json_platform_loop(jobj_platform, obj_key, board, func);
+        if (ret != MRAA_SUCCESS) {
+            return ret;
+        }
+        return MRAA_SUCCESS;
+    }
+    syslog(LOG_NOTICE, "init_json_platform: %s wasn't found in the json file", obj_key);
+    return MRAA_ERROR_NO_DATA_AVAILABLE;
+}
+
+mraa_result_t
+mraa_init_json_platform(const char* platform_json)
+{
+    mraa_result_t ret = MRAA_SUCCESS;
+    char* buffer = NULL;
+    struct stat st;
+    int file_lock = 0, array_length = 0, i = 0;
+    json_object *jobj_platform = NULL, *jobj_temp = NULL;
+    mraa_board_t* board = NULL;
+
+    // Try to lock the file for use
+    if ((file_lock = open(platform_json, O_RDONLY)) == -1) {
+        syslog(LOG_ERR, "init_json_platform: Failed to open platform file");
+        return MRAA_ERROR_INVALID_RESOURCE;
+    }
+
+    if (fstat(file_lock, &st) != 0 || (!S_ISREG(st.st_mode))) {
+        syslog(LOG_ERR, "init_json_platform: Failed to retrieve information about a file or the "
+                        "file specified is not actually a file");
+        close(file_lock);
+        return MRAA_ERROR_INVALID_RESOURCE;
+    }
+
+    buffer = mmap(0, st.st_size, PROT_READ, MAP_SHARED, file_lock, 0);
+    close(file_lock);
+    if (buffer == MAP_FAILED) {
+        syslog(LOG_ERR, "init_json_platform: Failed to read platform file");
+        return MRAA_ERROR_INVALID_RESOURCE;
+    }
+
+    // Parse the json file
+    jobj_platform = json_tokener_parse(buffer);
+    // Allocate some memory for the board information
+    board = (mraa_board_t*) calloc(1, sizeof(mraa_board_t));
+    if (board == NULL) {
+        munmap(buffer, st.st_size);
+        return MRAA_ERROR_INVALID_HANDLE;
+    }
+
+    // Call our helper to go through and init our board for the "Platform" data
+    ret = mraa_init_json_platform_loop(jobj_platform, PLATFORM_KEY, board, mraa_init_json_platform_platform);
+    if (ret != MRAA_SUCCESS) {
+        goto unsuccessful;
+    }
+
+    // Setup the IO's with their labels
+    ret = mraa_init_json_platform_size_check(jobj_platform, IO_KEY, board,
+                                             mraa_init_json_platform_io, board->phy_pin_count);
+    if (ret != MRAA_SUCCESS) {
+        goto unsuccessful;
+    }
+
+    // Setup GPIO
+    ret = mraa_init_json_platform_size_check(jobj_platform, GPIO_KEY, board,
+                                             mraa_init_json_platform_gpio, board->phy_pin_count);
+    if (ret != MRAA_SUCCESS) {
+        goto unsuccessful;
+    }
+
+    // Setup AIO
+    ret = mraa_init_json_platform_size_check(jobj_platform, AIO_KEY, board,
+                                             mraa_init_json_platform_aio, board->phy_pin_count);
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        goto unsuccessful;
+    }
+
+    // Setup SPI
+    ret = mraa_init_json_platform_size_check(jobj_platform, SPI_KEY, board,
+                                             mraa_init_json_platform_spi, board->spi_bus_count);
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        goto unsuccessful;
+    }
+
+    // Setup I2C
+    ret = mraa_init_json_platform_size_check(jobj_platform, I2C_KEY, board,
+                                             mraa_init_json_platform_i2c, board->i2c_bus_count);
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        goto unsuccessful;
+    }
+
+    // Setup UART
+    ret = mraa_init_json_platform_size_check(jobj_platform, UART_KEY, board,
+                                             mraa_init_json_platform_uart, board->uart_dev_count);
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        for (i = 0; i < board->uart_dev_count; i++) {
+            if (board->uart_dev[i].device_path != NULL) {
+                free(plat->uart_dev[i].device_path);
+            }
+        }
+        goto unsuccessful;
+    }
+
+    // Setup PWM
+    ret = mraa_init_json_platform_size_check(jobj_platform, PWM_KEY, board,
+                                             mraa_init_json_platform_pwm, board->phy_pin_count);
+    if (ret != MRAA_SUCCESS && ret != MRAA_ERROR_NO_DATA_AVAILABLE) {
+        goto unsuccessful;
+    }
+
+    // Free the old empty platform
+    free(plat);
+    // Set the new one in it's place
+    plat = board;
+    platform_name = plat->platform_name;
+
+    // We made it to the end without anything going wrong, just cleanup
+    ret = MRAA_SUCCESS;
+    syslog(LOG_NOTICE, "init_json_platform: Platform %s initialised via json", platform_name);
+    goto cleanup;
+
+unsuccessful:
+    free(board->platform_name);
+    free(board->pins);
+    free(board->adv_func);
+    free(board);
+cleanup:
+    json_object_put(jobj_platform);
+    munmap(buffer, st.st_size);
+    return ret;
+}

src/mock/CMakeLists.txt

@@ -0,0 +1,3 @@
+message (INFO " - Adding mock platform")
+set (mraa_LIB_PLAT_SRCS_NOAUTO ${mraa_LIB_SRCS_NOAUTO}
+     ${mraa_LIB_MOCK_SRCS_NOAUTO} PARENT_SCOPE)

src/mock/mock.c

@@ -0,0 +1,43 @@
+/*
+ * Author: Alex Tereschenko <alext.mkrs@gmail.com>
+ * Copyright (c) 2016 Alex Tereschenko.
+ *
+ * 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 <stdlib.h>
+
+#include "mraa_internal.h"
+
+#include "mock/mock_board.h"
+
+mraa_platform_t
+mraa_mock_platform()
+{
+    mraa_platform_t platform_type = MRAA_MOCK_PLATFORM;
+    plat = mraa_mock_board();
+
+    if (plat == NULL) {
+        syslog(LOG_ERR, "Was not able to initialize mock platform");
+        return MRAA_ERROR_PLATFORM_NOT_INITIALISED;
+    }
+
+    return platform_type;
+}

src/mock/mock_board.c

@@ -0,0 +1,136 @@
+/*
+ * Author: Alex Tereschenko <alext.mkrs@gmail.com>
+ * Copyright (c) 2016 Alex Tereschenko.
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "mock/mock_board.h"
+#include "mock/mock_board_gpio.h"
+#include "mock/mock_board_aio.h"
+#include "mock/mock_board_i2c.h"
+
+#define PLATFORM_NAME "MRAA mock platform"
+
+mraa_board_t*
+mraa_mock_board()
+{
+    mraa_board_t* b = (mraa_board_t*) calloc(1, sizeof(mraa_board_t));
+    if (b == NULL) {
+        return NULL;
+    }
+
+    // General board definitions
+    b->platform_name = PLATFORM_NAME;
+    b->phy_pin_count = MRAA_MOCK_PINCOUNT;
+    b->gpio_count = 1;
+    b->aio_count = 1;
+    b->adc_raw = 12;
+    b->adc_supported = 10;
+
+    b->i2c_bus_count = 1;
+    b->i2c_bus[0].bus_id = 0;
+    b->i2c_bus[0].sda = 2;
+    b->i2c_bus[0].scl = 3;
+    b->def_i2c_bus = b->i2c_bus[0].bus_id;
+
+    b->spi_bus_count = 0;
+
+    b->pwm_default_period = 0;
+    b->pwm_max_period = 0;
+    b->pwm_min_period = 0;
+
+    b->pins = (mraa_pininfo_t*) malloc(sizeof(mraa_pininfo_t) * MRAA_MOCK_PINCOUNT);
+    if (b->pins == NULL) {
+        goto error;
+    }
+
+    b->adv_func = (mraa_adv_func_t*) calloc(1, sizeof(mraa_adv_func_t));
+    if (b->adv_func == NULL) {
+        free(b->pins);
+        goto error;
+    }
+
+    // Replace functions
+    b->adv_func->gpio_init_internal_replace = &mraa_mock_gpio_init_internal_replace;
+    b->adv_func->gpio_close_replace = &mraa_mock_gpio_close_replace;
+    b->adv_func->gpio_dir_replace = &mraa_mock_gpio_dir_replace;
+    b->adv_func->gpio_read_dir_replace = &mraa_mock_gpio_read_dir_replace;
+    b->adv_func->gpio_read_replace = &mraa_mock_gpio_read_replace;
+    b->adv_func->gpio_write_replace = &mraa_mock_gpio_write_replace;
+    b->adv_func->gpio_edge_mode_replace = &mraa_mock_gpio_edge_mode_replace;
+    b->adv_func->gpio_isr_replace = &mraa_mock_gpio_isr_replace;
+    b->adv_func->gpio_isr_exit_replace = &mraa_mock_gpio_isr_exit_replace;
+    b->adv_func->gpio_mode_replace = &mraa_mock_gpio_mode_replace;
+    b->adv_func->aio_init_internal_replace = &mraa_mock_aio_init_internal_replace;
+    b->adv_func->aio_close_replace = &mraa_mock_aio_close_replace;
+    b->adv_func->aio_read_replace = &mraa_mock_aio_read_replace;
+    b->adv_func->i2c_init_bus_replace = &mraa_mock_i2c_init_bus_replace;
+    b->adv_func->i2c_stop_replace = &mraa_mock_i2c_stop_replace;
+    b->adv_func->i2c_set_frequency_replace = &mraa_mock_i2c_set_frequency_replace;
+    b->adv_func->i2c_address_replace = &mraa_mock_i2c_address_replace;
+    b->adv_func->i2c_read_replace = &mraa_mock_i2c_read_replace;
+    b->adv_func->i2c_read_byte_replace = &mraa_mock_i2c_read_byte_replace;
+    b->adv_func->i2c_read_byte_data_replace = &mraa_mock_i2c_read_byte_data_replace;
+    b->adv_func->i2c_read_bytes_data_replace = &mraa_mock_i2c_read_bytes_data_replace;
+    b->adv_func->i2c_read_word_data_replace = &mraa_mock_i2c_read_word_data_replace;
+    b->adv_func->i2c_write_replace = &mraa_mock_i2c_write_replace;
+    b->adv_func->i2c_write_byte_replace = &mraa_mock_i2c_write_byte_replace;
+    b->adv_func->i2c_write_byte_data_replace = &mraa_mock_i2c_write_byte_data_replace;
+    b->adv_func->i2c_write_word_data_replace = &mraa_mock_i2c_write_word_data_replace;
+
+    // Pin definitions
+    int pos = 0;
+
+    strncpy(b->pins[pos].name, "GPIO0", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 0;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "ADC0", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 1, 0 };
+    b->pins[pos].aio.pinmap = 0;
+    b->pins[pos].aio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2C0SDA", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].i2c.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2C0SCL", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].i2c.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    pos++;
+
+    return b;
+
+error:
+    syslog(LOG_CRIT, "MRAA mock: Platform failed to initialise");
+    free(b);
+    return NULL;
+}

src/mock/mock_board_aio.c

@@ -0,0 +1,52 @@
+/*
+ * Author: Alex Tereschenko <alext.mkrs@gmail.com>
+ * Copyright (c) 2016 Alex Tereschenko.
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "mock/mock_board_aio.h"
+
+mraa_result_t
+mraa_mock_aio_init_internal_replace(mraa_aio_context dev, int pin)
+{
+    dev->channel = pin;
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_mock_aio_close_replace(mraa_aio_context dev)
+{
+    free(dev);
+    return MRAA_SUCCESS;
+}
+
+int
+mraa_mock_aio_read_replace(mraa_aio_context dev)
+{
+    // return some random number between 0 and max value, based on the resolution
+    int max_value = (1 << dev->value_bit) - 1;
+    srand(time(NULL));
+    return rand() % max_value;
+}

src/mock/mock_board_gpio.c

@@ -0,0 +1,130 @@
+/*
+ * Author: Alex Tereschenko <alext.mkrs@gmail.com>
+ * Copyright (c) 2016 Alex Tereschenko.
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "mock/mock_board_gpio.h"
+
+mraa_result_t
+mraa_mock_gpio_init_internal_replace(mraa_gpio_context dev, int pin)
+{
+    dev->value_fp = -1;
+    dev->isr_value_fp = -1;
+    dev->isr_thread_terminating = 0;
+    dev->phy_pin = pin;
+    // We are always the owner
+    dev->owner = 1;
+#ifndef HAVE_PTHREAD_CANCEL
+    dev->isr_control_pipe[0] = dev->isr_control_pipe[1] = -1;
+#endif
+
+    // We start as INPUT and LOW
+    dev->mock_dir = MRAA_GPIO_IN;
+    dev->mock_state = 0;
+
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_mock_gpio_close_replace(mraa_gpio_context dev)
+{
+    free(dev);
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_mock_gpio_dir_replace(mraa_gpio_context dev, mraa_gpio_dir_t dir)
+{
+    switch (dir) {
+        case MRAA_GPIO_OUT_HIGH:
+            dev->mock_dir = MRAA_GPIO_OUT;
+            return mraa_gpio_write(dev, 1);
+        case MRAA_GPIO_OUT_LOW:
+            dev->mock_dir = MRAA_GPIO_OUT;
+            return mraa_gpio_write(dev, 0);
+        case MRAA_GPIO_IN:
+        case MRAA_GPIO_OUT:
+            dev->mock_dir = dir;
+            return MRAA_SUCCESS;
+        default:
+            syslog(LOG_ERR, "gpio: dir: invalid direction '%d' to set", (int) dir);
+            return MRAA_ERROR_INVALID_PARAMETER;
+    }
+}
+
+mraa_result_t
+mraa_mock_gpio_read_dir_replace(mraa_gpio_context dev, mraa_gpio_dir_t* dir)
+{
+    *dir = dev->mock_dir;
+    return MRAA_SUCCESS;
+}
+
+int
+mraa_mock_gpio_read_replace(mraa_gpio_context dev)
+{
+    return dev->mock_state;
+}
+
+mraa_result_t
+mraa_mock_gpio_write_replace(mraa_gpio_context dev, int value)
+{
+    if ((value < 0) || (value > 1)) {
+        syslog(LOG_ERR, "gpio: write: incorrect value '%d' passed to write(), must be 0 or 1", value);
+        return MRAA_ERROR_INVALID_PARAMETER;
+    }
+
+    if (dev->mock_dir == MRAA_GPIO_IN) {
+        syslog(LOG_ERR, "gpio: write: cannot write to pin set to INPUT");
+        return MRAA_ERROR_INVALID_RESOURCE;
+    }
+
+    dev->mock_state = value;
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_mock_gpio_edge_mode_replace(mraa_gpio_context dev, mraa_gpio_edge_t mode)
+{
+    return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
+}
+
+mraa_result_t
+mraa_mock_gpio_isr_replace(mraa_gpio_context dev, mraa_gpio_edge_t mode, void (*fptr)(void*), void* args)
+{
+    return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
+}
+
+mraa_result_t
+mraa_mock_gpio_isr_exit_replace(mraa_gpio_context dev)
+{
+    return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
+}
+
+mraa_result_t
+mraa_mock_gpio_mode_replace(mraa_gpio_context dev, mraa_gpio_mode_t mode)
+{
+    return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
+}

src/mock/mock_board_i2c.c

@@ -0,0 +1,246 @@
+/*
+ * Author: Alex Tereschenko <alext.mkrs@gmail.com>
+ * Copyright (c) 2016 Alex Tereschenko.
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "mock/mock_board.h"
+#include "mock/mock_board_gpio.h"
+#include "mock/mock_board_aio.h"
+#include "mock/mock_board_i2c.h"
+
+mraa_result_t
+mraa_mock_i2c_init_bus_replace(mraa_i2c_context dev)
+{
+    dev->mock_dev_addr = MOCK_I2C_DEV_ADDR;
+    dev->mock_dev_data_len = MOCK_I2C_DEV_DATA_LEN;
+
+    dev->mock_dev_data = (uint8_t*) calloc(dev->mock_dev_data_len, sizeof(uint8_t));
+    if (dev->mock_dev_data == NULL) {
+        syslog(LOG_CRIT, "i2c%i: init: Failed to allocate memory for mock device context", dev->busnum);
+        return MRAA_ERROR_NO_RESOURCES;
+    }
+
+    // Set initial values for mock device "data registers"
+    memset(dev->mock_dev_data, MOCK_I2C_DEV_DATA_INIT_BYTE, dev->mock_dev_data_len);
+
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_mock_i2c_stop_replace(mraa_i2c_context dev)
+{
+    free(dev->mock_dev_data);
+    free(dev);
+    return MRAA_SUCCESS;
+}
+
+
+mraa_result_t
+mraa_mock_i2c_set_frequency_replace(mraa_i2c_context dev, mraa_i2c_mode_t mode)
+{
+    switch (mode) {
+        case MRAA_I2C_STD:
+        case MRAA_I2C_FAST:
+        case MRAA_I2C_HIGH:
+            return MRAA_SUCCESS;
+            break;
+        default:
+            syslog(LOG_ERR, "i2c%i: set_frequency: Invalid I2C frequency selected", dev->busnum);
+            return MRAA_ERROR_INVALID_PARAMETER;
+    }
+}
+
+mraa_result_t
+mraa_mock_i2c_address_replace(mraa_i2c_context dev, uint8_t addr)
+{
+    const uint8_t MAX_I2C_ADDR = 0x7F;
+
+    if (addr > MAX_I2C_ADDR) {
+        syslog(LOG_ERR, "i2c%i: address: Slave address 0x%X is bigger than max supported (0x%X)",
+               dev->busnum, addr, MAX_I2C_ADDR);
+        return MRAA_ERROR_INVALID_PARAMETER;
+    }
+
+    return MRAA_SUCCESS;
+}
+
+int
+mraa_mock_i2c_read_replace(mraa_i2c_context dev, uint8_t* data, int length)
+{
+    if (dev->addr == dev->mock_dev_addr) {
+        // Account for possible mismatch between length and our "register" range
+        int copy_len = (length <= dev->mock_dev_data_len) ? length : dev->mock_dev_data_len;
+        memcpy(data, dev->mock_dev_data, copy_len);
+        return copy_len;
+    } else {
+        // Not our mock device
+        return -1;
+    }
+}
+
+int
+mraa_mock_i2c_read_byte_replace(mraa_i2c_context dev)
+{
+    if (dev->addr == dev->mock_dev_addr) {
+        return dev->mock_dev_data[0];
+    } else {
+        // Not our mock device
+        return -1;
+    }
+}
+
+int
+mraa_mock_i2c_read_byte_data_replace(mraa_i2c_context dev, uint8_t command)
+{
+    if (dev->addr == dev->mock_dev_addr) {
+        if (command < dev->mock_dev_data_len) {
+            return dev->mock_dev_data[command];
+        } else {
+            syslog(LOG_ERR,
+                   "i2c%i: read_byte_data: Command/register number is too big, max is 0x%X",
+                   dev->busnum, dev->mock_dev_data_len - 1);
+            return -1;
+        }
+    } else {
+        // Not our mock device
+        return -1;
+    }
+}
+
+int
+mraa_mock_i2c_read_bytes_data_replace(mraa_i2c_context dev, uint8_t command, uint8_t* data, int length)
+{
+    if (dev->addr == dev->mock_dev_addr) {
+        if (command >= dev->mock_dev_data_len) {
+            syslog(LOG_ERR,
+                   "i2c%i: read_bytes_data: Command/register number is too big, max is 0x%X",
+                   dev->busnum, dev->mock_dev_data_len - 1);
+            return -1;
+        }
+
+        if (length <= 0) {
+            syslog(LOG_ERR,
+                   "i2c%i: read_bytes_data: Length to read is invalid (%d), cannot proceed",
+                   dev->busnum, length);
+            return -1;
+        }
+
+        int i = 0;
+        // We read requested length, but only up to mock device data length
+        for (i = command; (i < (command + length)) && (i < dev->mock_dev_data_len); ++i) {
+            data[i - command] = dev->mock_dev_data[i];
+        }
+        return (i - command);
+    } else {
+        // Not our mock device
+        return -1;
+    }
+}
+
+int
+mraa_mock_i2c_read_word_data_replace(mraa_i2c_context dev, uint8_t command)
+{
+    if (dev->addr == dev->mock_dev_addr) {
+        if ((command + 1) < dev->mock_dev_data_len) {
+            // Let's say the device is big-endian
+            int result = (dev->mock_dev_data[command] << 8) + dev->mock_dev_data[command + 1];
+            return result;
+        } else {
+            syslog(LOG_ERR,
+                   "i2c%i: read_word_data: Command/register number is too big, max is 0x%X",
+                   dev->busnum, dev->mock_dev_data_len - 2);
+            return -1;
+        }
+    } else {
+        // Not our mock device
+        return -1;
+    }
+}
+
+mraa_result_t
+mraa_mock_i2c_write_replace(mraa_i2c_context dev, const uint8_t* data, int length)
+{
+    if (dev->addr == dev->mock_dev_addr) {
+        int copy_len = (length <= dev->mock_dev_data_len) ? length : dev->mock_dev_data_len;
+        memcpy(dev->mock_dev_data, data, copy_len);
+        return MRAA_SUCCESS;
+    } else {
+        // Not our mock device
+        return MRAA_ERROR_UNSPECIFIED;
+    }
+}
+
+mraa_result_t
+mraa_mock_i2c_write_byte_replace(mraa_i2c_context dev, const uint8_t data)
+{
+    if (dev->addr == dev->mock_dev_addr) {
+        dev->mock_dev_data[0] = data;
+        return MRAA_SUCCESS;
+    } else {
+        // Not our mock device
+        return MRAA_ERROR_UNSPECIFIED;
+    }
+}
+
+mraa_result_t
+mraa_mock_i2c_write_byte_data_replace(mraa_i2c_context dev, const uint8_t data, const uint8_t command)
+{
+    if (dev->addr == dev->mock_dev_addr) {
+        if (command < dev->mock_dev_data_len) {
+            dev->mock_dev_data[command] = data;
+            return MRAA_SUCCESS;
+        } else {
+            syslog(LOG_ERR,
+                   "i2c%i: write_byte_data: Command/register number is too big, max is 0x%X",
+                   dev->busnum, dev->mock_dev_data_len - 1);
+            return MRAA_ERROR_UNSPECIFIED;
+        }
+    } else {
+        // Not our mock device
+        return MRAA_ERROR_UNSPECIFIED;
+    }
+}
+
+mraa_result_t
+mraa_mock_i2c_write_word_data_replace(mraa_i2c_context dev, const uint16_t data, const uint8_t command)
+{
+    if (dev->addr == dev->mock_dev_addr) {
+        if ((command + 1) < dev->mock_dev_data_len) {
+            // Let's say the device is big-endian
+            dev->mock_dev_data[command] = (data & 0xFF00) >> 8;
+            dev->mock_dev_data[command + 1] = data & 0x00FF;
+            return MRAA_SUCCESS;
+        } else {
+            syslog(LOG_ERR,
+                   "i2c%i: write_word_data: Command/register number is too big, max is 0x%X",
+                   dev->busnum, dev->mock_dev_data_len - 2);
+            return MRAA_ERROR_UNSPECIFIED;
+        }
+    } else {
+        // Not our mock device
+        return MRAA_ERROR_UNSPECIFIED;
+    }
+}

src/mraa.c

@@ -36,11 +36,14 @@
 #include <glob.h>
 #include <ftw.h>
 #include <dirent.h>
-#include <sys/stat.h>
 #include <fcntl.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdbool.h>
+#include <errno.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <limits.h>
+
 
 #if defined(IMRAA)
 #include <json-c/json.h>
@@ -52,13 +55,20 @@
 #include "firmata/firmata_mraa.h"
 #include "gpio.h"
 #include "version.h"
+#include "i2c.h"
+#include "pwm.h"
+#include "aio.h"
+#include "spi.h"
+#include "uart.h"
 
 #define IIO_DEVICE_WILDCARD "iio:device*"
+
+
 mraa_board_t* plat = NULL;
 mraa_iio_info_t* plat_iio = NULL;
 mraa_lang_func_t* lang_func = NULL;
 
-static char* platform_name = NULL;
+char* platform_name = NULL;
 static char* platform_long_name = NULL;
 
 static int num_i2c_devices = 0;
@@ -92,7 +102,9 @@ imraa_init()
     if (plat != NULL) {
         return MRAA_SUCCESS;
     }
-
+    char* env_var;
+    mraa_result_t ret;
+    mraa_platform_t platform_type = MRAA_NULL_PLATFORM;
     uid_t proc_euid = geteuid();
     struct passwd* proc_user = getpwuid(proc_euid);
 
@@ -106,16 +118,34 @@ imraa_init()
     syslog(LOG_NOTICE, "libmraa version %s initialised by user '%s' with EUID %d",
            mraa_get_version(), (proc_user != NULL) ? proc_user->pw_name : "<unknown>", proc_euid);
 
-    mraa_platform_t platform_type;
+    // Check to see if the enviroment variable has been set
+    env_var = getenv(MRAA_JSONPLAT_ENV_VAR);
+    if (env_var != NULL) {
+        // We only care about success, the init will write to syslog if things went wrong
+        switch ((ret = mraa_init_json_platform(env_var))) {
+            case MRAA_SUCCESS:
+                platform_type = plat->platform_type;
+                break;
+            default:
+                syslog(LOG_NOTICE, "libmraa was unable to initialise a platform from json");
+        }
+    }
+
+    // Not an else because if the env var didn't load what we wanted maybe we can still load something
+    if (platform_type == MRAA_NULL_PLATFORM) {
 #if defined(X86PLAT)
-    // Use runtime x86 platform detection
-    platform_type = mraa_x86_platform();
+        // Use runtime x86 platform detection
+        platform_type = mraa_x86_platform();
 #elif defined(ARMPLAT)
-    // Use runtime ARM platform detection
-    platform_type = mraa_arm_platform();
+        // Use runtime ARM platform detection
+        platform_type = mraa_arm_platform();
+#elif defined(MOCKPLAT)
+        // Use mock platform
+        platform_type = mraa_mock_platform();
 #else
 #error mraa_ARCH NOTHING
 #endif
+    }
 
     if (plat != NULL) {
         plat->platform_type = platform_type;
@@ -196,6 +226,7 @@ mraa_init()
 void
 mraa_deinit()
 {
+    int i = 0;
     if (plat != NULL) {
         if (plat->pins != NULL) {
             free(plat->pins);
@@ -207,6 +238,19 @@ mraa_deinit()
             }
             free(sub_plat);
         }
+#if defined(JSONPLAT)
+        if (plat->platform_type == MRAA_JSON_PLATFORM) {
+            // Free the platform name
+            free(plat->platform_name);
+
+            // Free the UART device path
+            for (i = 0; i < plat->uart_dev_count; i++) {
+                if (plat->uart_dev[i].device_path != NULL) {
+                    free(plat->uart_dev[i].device_path);
+                }
+            }
+        }
+#endif
         free(plat);
 
     }
@@ -285,7 +329,8 @@ mraa_setup_mux_mapped(mraa_pin_t meta)
     unsigned int mi;
     mraa_result_t ret;
     mraa_gpio_context mux_i = NULL;
-    int last_pin = -1;
+    // avoids the unsigned comparison and we should never have a pin that is UINT_MAX!
+    unsigned int last_pin = UINT_MAX;
 
     for (mi = 0; mi < meta.mux_total; mi++) {
 
@@ -535,35 +580,35 @@ mraa_pin_mode_test(int pin, mraa_pinmodes_t mode)
 
     switch (mode) {
         case MRAA_PIN_VALID:
-            if (current_plat->pins[pin].capabilites.valid == 1)
+            if (current_plat->pins[pin].capabilities.valid == 1)
                 return 1;
             break;
         case MRAA_PIN_GPIO:
-            if (current_plat->pins[pin].capabilites.gpio == 1)
+            if (current_plat->pins[pin].capabilities.gpio == 1)
                 return 1;
             break;
         case MRAA_PIN_PWM:
-            if (current_plat->pins[pin].capabilites.pwm == 1)
+            if (current_plat->pins[pin].capabilities.pwm == 1)
                 return 1;
             break;
         case MRAA_PIN_FAST_GPIO:
-            if (current_plat->pins[pin].capabilites.fast_gpio == 1)
+            if (current_plat->pins[pin].capabilities.fast_gpio == 1)
                 return 1;
             break;
         case MRAA_PIN_SPI:
-            if (current_plat->pins[pin].capabilites.spi == 1)
+            if (current_plat->pins[pin].capabilities.spi == 1)
                 return 1;
             break;
         case MRAA_PIN_I2C:
-            if (current_plat->pins[pin].capabilites.i2c == 1)
+            if (current_plat->pins[pin].capabilities.i2c == 1)
                 return 1;
             break;
         case MRAA_PIN_AIO:
-            if (current_plat->pins[pin].capabilites.aio == 1)
+            if (current_plat->pins[pin].capabilities.aio == 1)
                 return 1;
             break;
         case MRAA_PIN_UART:
-            if (current_plat->pins[pin].capabilites.uart == 1)
+            if (current_plat->pins[pin].capabilities.uart == 1)
                 return 1;
             break;
         default:
@@ -1073,3 +1118,163 @@ mraa_add_from_lockfile(const char* imraa_lock_file)
     return ret;
 }
 #endif
+
+void
+mraa_to_upper(char* s)
+{
+    char* t = s;
+    for (; *t; ++t) {
+        *t = toupper(*t);
+    }
+}
+
+mraa_result_t
+mraa_atoi(char* intStr, int* value)
+{
+    char* end;
+    // here 10 determines the number base in which strol is to work
+    long val = strtol(intStr, &end, 10);
+    if (*end != '\0' || errno == ERANGE || end == intStr || val > INT_MAX || val < INT_MIN) {
+        *value = 0;
+        return MRAA_ERROR_UNSPECIFIED;
+    }
+    *value = (int) val;
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_init_io_helper(char** str, int* value, const char* delim)
+{
+    // This function is a result of a repeated pattern within mraa_init_io
+    // when determining if a value can be derived from a string
+    char* token;
+    token = strsep(str, delim);
+    // check to see if empty string returned
+    if (token == NULL) {
+        *value = 0;
+        return MRAA_ERROR_NO_DATA_AVAILABLE;
+    }
+    return mraa_atoi(token, value);
+}
+
+void*
+mraa_init_io(const char* desc)
+{
+    const char* delim = "-";
+    int length = 0, raw = 0;
+    int pin = 0, id = 0;
+    // 256 denotes the maximum size of our buffer
+    // 8 denotes the maximum size of our type rounded to the nearest power of 2
+    // max size is 4 + 1 for the \0 = 5 rounded to 8
+    char buffer[256] = { 0 }, type[8] = { 0 };
+    char *token = 0, *str = 0;
+    if (desc == NULL) {
+        return NULL;
+    }
+    length = strlen(desc);
+    // Check to see the length is less than or equal to 255 which means
+    // byte 256 is supposed to be \0
+    if (length > 255 || length == 0) {
+        return NULL;
+    }
+    strncpy(buffer, desc, length);
+
+    str = buffer;
+    token = strsep(&str, delim);
+    length = strlen(token);
+    // Check to see they haven't given us a type whose length is greater than the
+    // largest type we know about
+    if (length > 4) {
+        syslog(LOG_ERR, "mraa_init_io: An invalid IO type was provided");
+        return NULL;
+    }
+    strncpy(type, token, length);
+    mraa_to_upper(type);
+    token = strsep(&str, delim);
+    // Check that they've given us more information than just the type
+    if (token == NULL) {
+        syslog(LOG_ERR, "mraa_init_io: Missing information after type");
+        return NULL;
+    }
+    // If we cannot convert the pin to a number maybe it says raw?
+    if (mraa_atoi(token, &pin) != MRAA_SUCCESS) {
+        mraa_to_upper(token);
+        if (strncmp(token, "RAW", 3)) {
+            syslog(LOG_ERR, "mraa_init_io: Description does not adhere to a known format");
+            return NULL;
+        }
+        raw = 1;
+    }
+    if (!raw && str != NULL) {
+        syslog(LOG_ERR, "mraa_init_io: More information than required was provided");
+        return NULL;
+    }
+
+    if (strncmp(type, "GPIO", 4) == 0) {
+        if (raw) {
+            if (mraa_init_io_helper(&str, &pin, delim) == MRAA_SUCCESS) {
+                return (void*) mraa_gpio_init_raw(pin);
+            }
+            syslog(LOG_ERR, "mraa_init_io: Invalid Raw description for GPIO");
+            return NULL;
+        }
+        return (void*) mraa_gpio_init(pin);
+    } else if (strncmp(type, "I2C", 3) == 0) {
+        if (raw) {
+            if (mraa_init_io_helper(&str, &pin, delim) == MRAA_SUCCESS) {
+                return (void*) mraa_i2c_init_raw(pin);
+            }
+            syslog(LOG_ERR, "mraa_init_io: Invalid Raw description for I2C");
+            return NULL;
+        }
+        return (void*) mraa_i2c_init(pin);
+    } else if (strncmp(type, "AIO", 3) == 0) {
+        if (raw) {
+            syslog(LOG_ERR, "mraa_init_io: Aio doesn't have a RAW mode");
+            return NULL;
+        }
+        return (void*) mraa_aio_init(pin);
+    } else if (strncmp(type, "PWM", 3) == 0) {
+        if (raw) {
+            if (mraa_init_io_helper(&str, &id, delim) != MRAA_SUCCESS) {
+                syslog(LOG_ERR, "mraa_init_io: Pwm, unable to convert the chip id string into a useable Int");
+                return NULL;
+            }
+            if (mraa_init_io_helper(&str, &pin, delim) != MRAA_SUCCESS) {
+                syslog(LOG_ERR, "mraa_init_io: Pwm, unable to convert the pin string into a useable Int");
+                return NULL;
+            }
+            return (void*) mraa_pwm_init_raw(id, pin);
+        }
+        return (void*) mraa_pwm_init(pin);
+    } else if (strncmp(type, "SPI", 3) == 0) {
+        if (raw) {
+            if (mraa_init_io_helper(&str, &id, delim) != MRAA_SUCCESS) {
+                syslog(LOG_ERR, "mraa_init_io: Spi, unable to convert the bus string into a useable Int");
+                return NULL;
+            }
+            if (mraa_init_io_helper(&str, &pin, delim) != MRAA_SUCCESS) {
+                syslog(LOG_ERR, "mraa_init_io: Spi, unable to convert the cs string into a useable Int");
+                return NULL;
+            }
+            return (void*) mraa_spi_init_raw(id, pin);
+        }
+        return (void*) mraa_spi_init(pin);
+    } else if (strncmp(type, "UART", 4) == 0) {
+        if (raw) {
+            return (void*) mraa_uart_init_raw(str);
+        }
+        return (void*) mraa_uart_init(pin);
+    }
+    syslog(LOG_ERR, "mraa_init_io: Invalid IO type given.");
+    return NULL;
+}
+
+
+#ifndef JSONPLAT
+mraa_result_t
+mraa_init_json_platform(const char* desc)
+{
+    return MRAA_ERROR_FEATURE_NOT_SUPPORTED;
+}
+#endif

src/mraa.i

@@ -41,6 +41,19 @@
 %include "types.hpp"
 
 %include "common.hpp"
+%template (gpioFromDesc) mraa::initIo<mraa::Gpio>;
+%template (aioFromDesc) mraa::initIo<mraa::Aio>;
+%template (uartFromDesc) mraa::initIo<mraa::Uart>;
+%template (spiFromDesc) mraa::initIo<mraa::Spi>;
+%template (i2cFromDesc) mraa::initIo<mraa::I2c>;
+%template (pwmFromDesc) mraa::initIo<mraa::Pwm>;
+
+%ignore Aio(void* aio_context);
+%ignore Pwm(void* pwm_context);
+%ignore Uart(void* uart_context);
+%ignore Spi(void* spi_context);
+%ignore I2c(void* i2c_context);
+%ignore Gpio(void* gpio_context);
 
 %ignore Gpio::nop(uv_work_t* req);
 %ignore Gpio::v8isr(uv_work_t* req);

src/pwm/pwm.c

@@ -233,7 +233,7 @@ mraa_pwm_init(int pin)
         syslog(LOG_ERR, "pwm_init: pin %i beyond platform definition", pin);
         return NULL;
     }
-    if (board->pins[pin].capabilites.pwm != 1) {
+    if (board->pins[pin].capabilities.pwm != 1) {
         syslog(LOG_ERR, "pwm_init: pin %i not capable of pwm", pin);
         return NULL;
     }
@@ -249,28 +249,6 @@ mraa_pwm_init(int pin)
             return NULL;
     }
 
-    if (board->pins[pin].capabilites.gpio == 1) {
-        // This deserves more investigation
-        mraa_gpio_context mux_i;
-        mux_i = mraa_gpio_init_raw(board->pins[pin].gpio.pinmap);
-        if (mux_i == NULL) {
-            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_init", pin);
-            return NULL;
-        }
-        if (mraa_gpio_dir(mux_i, MRAA_GPIO_OUT) != MRAA_SUCCESS) {
-            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_dir", pin);
-            return NULL;
-        }
-        if (mraa_gpio_write(mux_i, 1) != MRAA_SUCCESS) {
-            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_write", pin);
-            return NULL;
-        }
-        if (mraa_gpio_close(mux_i) != MRAA_SUCCESS) {
-            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_close", pin);
-            return NULL;
-        }
-    }
-
     if (board->pins[pin].pwm.mux_total > 0) {
         if (mraa_setup_mux_mapped(board->pins[pin].pwm) != MRAA_SUCCESS) {
             syslog(LOG_ERR, "pwm_init: Failed to set-up pwm%i multiplexer", pin);
@@ -340,6 +318,13 @@ mraa_pwm_write(mraa_pwm_context dev, float percentage)
         return MRAA_ERROR_INVALID_HANDLE;
     }
 
+    if (IS_FUNC_DEFINED(dev, pwm_write_pre)) {
+        if (dev->advance_func->pwm_write_pre(dev, percentage) != MRAA_SUCCESS) {
+            syslog(LOG_ERR, "mraa_pwm_write (pwm%i): pwm_write_pre failed, see syslog", dev->pin);
+            return MRAA_ERROR_UNSPECIFIED;
+        }
+    }
+
     if (dev->period == -1) {
         if (mraa_pwm_read_period(dev) <= 0)
             return MRAA_ERROR_NO_DATA_AVAILABLE;
@@ -433,6 +418,13 @@ mraa_pwm_enable(mraa_pwm_context dev, int enable)
         return dev->advance_func->pwm_enable_replace(dev, enable);
     }
 
+    if (IS_FUNC_DEFINED(dev, pwm_enable_pre)) {
+        if (dev->advance_func->pwm_enable_pre(dev, enable) != MRAA_SUCCESS) {
+            syslog(LOG_ERR, "mraa_pwm_enable (pwm%i): pwm_enable_pre failed, see syslog", dev->pin);
+            return MRAA_ERROR_UNSPECIFIED;
+        }
+    }
+
     char bu[MAX_SIZE];
     snprintf(bu, MAX_SIZE, "/sys/class/pwm/pwmchip%d/pwm%d/enable", dev->chipid, dev->pin);
 

src/python/CMakeLists.txt

@@ -1,50 +1,5 @@
-find_package (PythonLibs ${PYTHONBUILD_VERSION} REQUIRED)
+set_source_files_properties (mraapython.i PROPERTIES CPLUSPLUS ON)
+set_source_files_properties (mraapython.i PROPERTIES SWIG_FLAGS "-I${CMAKE_BINARY_DIR}/src")
 
-include_directories(
-  ${CMAKE_CURRENT_SOURCE_DIR}/..
-  ${PYTHON_INCLUDE_DIRS}
-)
-
-set_source_files_properties (mraa.i PROPERTIES CPLUSPLUS ON)
-set_source_files_properties (mraa.i PROPERTIES SWIG_FLAGS "-I${CMAKE_BINARY_DIR}/src")
-swig_add_module (python-mraa python mraa.i mraapy.c)
-swig_link_libraries (python-mraa ${PYTHON_LIBRARIES} mraa)
-
-if (DOXYGEN_FOUND)
-  foreach (_file ${DOCCLASSES})
-    add_dependencies (${SWIG_MODULE_python-mraa_REAL_NAME} ${_file}class_doc_i)
-  endforeach ()
-  add_dependencies (${SWIG_MODULE_python-mraa_REAL_NAME} common_hpp_doc_i)
-
-  add_custom_target (pydoc
-    pydoc -w ${CMAKE_CURRENT_BINARY_DIR}/mraa.py ${CMAKE_CURRENT_BINARY_DIR}/
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    COMMENT "Generating API documentation with pydoc" VERBATIM
-  )
-endif ()
-
-set_target_properties (${SWIG_MODULE_python-mraa_REAL_NAME} PROPERTIES
-  OUTPUT_NAME _mraa
-  COMPILE_FLAGS "${CMAKE_C_FLAGS} -DSWIGPYTHON=${SWIG_FOUND}"
-)
-
-execute_process (
-   COMMAND ${PYTHON_EXECUTABLE} -c
-       "import site, sys; sys.stdout.write(site.PREFIXES[-1])"
-   OUTPUT_VARIABLE PYTHON_PREFIX
-)
-file (TO_CMAKE_PATH "${PYTHON_PREFIX}" PYTHON_PREFIX)
-execute_process (
-   COMMAND ${PYTHON_EXECUTABLE} -c
-       "import site, sys; sys.stdout.write(site.getusersitepackages().replace(site.getuserbase(), site.PREFIXES[-1]))"
-   OUTPUT_VARIABLE PYTHON_SITE_DIR
-)
-file (TO_CMAKE_PATH "${PYTHON_SITE_DIR}" PYTHON_SITE_DIR)
-string (REGEX REPLACE "^${PYTHON_PREFIX}/" ""
-   PYTHON_SITE_DIR "${PYTHON_SITE_DIR}")
-
-install (FILES ${CMAKE_CURRENT_BINARY_DIR}/_mraa.so
-         ${CMAKE_CURRENT_BINARY_DIR}/mraa.py
-         DESTINATION ${PYTHON_SITE_DIR})
-
-add_subdirectory (docs)
+add_subdirectory (python2)
+add_subdirectory (python3)

src/python/mraapython.i

@@ -1,7 +1,3 @@
-%module(docstring="Python interface to libmraa") mraa
-
-%feature("autodoc", "3");
-
 %include typemaps.i
 %include carrays.i
 

src/python/python2/CMakeLists.txt

@@ -0,0 +1,39 @@
+set_source_files_properties (mraa2.i PROPERTIES CPLUSPLUS ON)
+set_source_files_properties (mraa2.i PROPERTIES SWIG_FLAGS "-I${CMAKE_BINARY_DIR}/src")
+
+if (PYTHON2_LIBRARY)
+    message ("PYTHON2 attempting to build!")
+
+    swig_add_module (python2-mraa python mraa2.i ../mraapy.c)
+    swig_link_libraries (python2-mraa ${PYTHON2_LIBRARIES} mraa)
+
+    target_include_directories(${SWIG_MODULE_python2-mraa_REAL_NAME}
+      PUBLIC
+      "${CMAKE_CURRENT_SOURCE_DIR}/../.."
+      "${PYTHON2_INCLUDE_DIR}"
+    )
+
+    if (DOXYGEN_FOUND AND PYTHON2_EXECUTABLE)
+      foreach (_file ${DOCCLASSES})
+        add_dependencies (${SWIG_MODULE_python2-mraa_REAL_NAME} ${_file}class_doc_i)
+      endforeach ()
+      add_dependencies (${SWIG_MODULE_python2-mraa_REAL_NAME} common_hpp_doc_i)
+
+      add_custom_target (pydoc
+        python2 /usr/bin/pydoc -w ${CMAKE_CURRENT_BINARY_DIR}/mraa.py ${CMAKE_CURRENT_BINARY_DIR}/
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        COMMENT "Generating API documentation with pydoc" VERBATIM
+      )
+    endif ()
+
+    set_target_properties (${SWIG_MODULE_python2-mraa_REAL_NAME} PROPERTIES
+      OUTPUT_NAME _mraa
+      COMPILE_FLAGS "${CMAKE_C_FLAGS} -DSWIGPYTHON=${SWIG_FOUND}"
+    )
+
+    install (FILES ${CMAKE_CURRENT_BINARY_DIR}/_mraa${CMAKE_SHARED_LIBRARY_SUFFIX}
+             ${CMAKE_CURRENT_BINARY_DIR}/mraa.py
+             DESTINATION ${CMAKE_INSTALL_PREFIX}/${PYTHON2_PACKAGES_PATH})
+endif()
+
+add_subdirectory (docs)

src/python/python2/docs/CMakeLists.txt

@@ -36,6 +36,6 @@ if (DOXYGEN_FOUND)
       COMMENT "Building HTML documentation with Sphinx"
     )
 
-    add_dependencies (sphinx ${SWIG_MODULE_python-mraa_REAL_NAME})
+    add_dependencies (sphinx ${SWIG_MODULE_python2-mraa_REAL_NAME})
   endif ()
 endif ()

src/python/python2/docs/conf.py.in

@@ -19,7 +19,7 @@ import os
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
-sys.path.insert(0, "@CMAKE_BINARY_DIR@/src/python")
+sys.path.insert(0, "@CMAKE_BINARY_DIR@/src/python/python2")
 
 # -- General configuration ------------------------------------------------
 

src/python/python2/mraa2.i

@@ -0,0 +1,5 @@
+%module(docstring="Python interface to libmraa") mraa                                                                                          
+
+%feature("autodoc", "3");
+
+%include ../mraapython.i

src/python/python3/CMakeLists.txt

@@ -0,0 +1,38 @@
+set_source_files_properties (mraa3.i PROPERTIES CPLUSPLUS ON)
+set_source_files_properties (mraa3.i PROPERTIES SWIG_FLAGS "-I${CMAKE_BINARY_DIR}/src")
+
+if (PYTHON3_LIBRARY)
+    message ("PYTHON3 attempting to build!")
+
+    swig_add_module (python3-mraa python mraa3.i ../mraapy.c)
+    swig_link_libraries (python3-mraa ${PYTHON3_LIBRARIES} mraa)
+
+    target_include_directories(${SWIG_MODULE_python3-mraa_REAL_NAME}
+      PUBLIC
+      "${CMAKE_CURRENT_SOURCE_DIR}/../.."
+      "${PYTHON3_INCLUDE_DIR}"
+    )
+
+    if (DOXYGEN_FOUND AND PYTHON3_EXECUTABLE)
+      foreach (_file ${DOCCLASSES})
+        add_dependencies (${SWIG_MODULE_python3-mraa_REAL_NAME} ${_file}class_doc_i)
+      endforeach ()
+      add_dependencies (${SWIG_MODULE_python3-mraa_REAL_NAME} common_hpp_doc_i)
+
+      add_custom_target (pydoc3
+        python3 /usr/bin/pydoc -w ${CMAKE_CURRENT_BINARY_DIR}/mraa.py ${CMAKE_CURRENT_BINARY_DIR}/
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        COMMENT "Generating API documentation with pydoc" VERBATIM
+      )
+    endif ()
+
+
+    set_target_properties (${SWIG_MODULE_python3-mraa_REAL_NAME} PROPERTIES
+      OUTPUT_NAME _mraa
+      COMPILE_FLAGS "${CMAKE_C_FLAGS} -DSWIGPYTHON=${SWIG_FOUND}"
+    )
+
+    install (FILES ${CMAKE_CURRENT_BINARY_DIR}/_mraa${CMAKE_SHARED_LIBRARY_SUFFIX}
+             ${CMAKE_CURRENT_BINARY_DIR}/mraa.py
+             DESTINATION ${CMAKE_INSTALL_PREFIX}/${PYTHON3_PACKAGES_PATH})
+endif ()

src/python/python3/mraa3.i

@@ -0,0 +1,3 @@
+%module(docstring="Python interface to libmraa") mraa
+
+%include ../mraapython.i

src/spi/spi.c

@@ -25,8 +25,17 @@
 
 #include <stdlib.h>
 #include <string.h>
+#if defined(MSYS)
+#define __USE_LINUX_IOCTL_DEFS
+#endif
 #include <sys/ioctl.h>
+#if defined(MSYS)
+// There's no spidev.h on MSYS, so we need to provide our own,
+// and only *after* including ioctl.h as that one contains prerequisites.
+#include "linux/spi_kernel_headers.h"
+#else
 #include <linux/spi/spidev.h>
+#endif
 #include <stdio.h>
 #include <fcntl.h>
 #include <unistd.h>

src/uart/uart.c

@@ -102,10 +102,12 @@ uint2speed(unsigned int speed)
             return B2500000;
         case 3000000:
             return B3000000;
+#if !defined(MSYS)
         case 3500000:
             return B3500000;
         case 4000000:
             return B4000000;
+#endif
         default:
             // if we are here, then an unsupported baudrate was selected.
             return 0;

src/usb/ftdi_ft4222.c

@@ -1063,14 +1063,14 @@ mraa_ftdi_ft4222()
     // I2c pins (these are virtual, entries are required to configure i2c layer)
     // We currently assume that GPIO 0/1 are reserved for i2c operation
     strncpy(sub_plat->pins[pinIndex].name, "IGPIO0/SCL0", MRAA_PIN_NAME_SIZE);
-    sub_plat->pins[pinIndex].capabilites = pinCapsI2cGpio;
+    sub_plat->pins[pinIndex].capabilities = pinCapsI2cGpio;
     sub_plat->pins[pinIndex].gpio.pinmap = pinIndex;
     sub_plat->pins[pinIndex].gpio.mux_total = 0;
     sub_plat->pins[pinIndex].i2c.mux_total = 0;
     sub_plat->i2c_bus[bus].scl = pinIndex;
     pinIndex++;
     strncpy(sub_plat->pins[pinIndex].name, "IGPIO1/SDA0", MRAA_PIN_NAME_SIZE);
-    sub_plat->pins[pinIndex].capabilites = pinCapsI2cGpio;
+    sub_plat->pins[pinIndex].capabilities = pinCapsI2cGpio;
     sub_plat->pins[pinIndex].gpio.pinmap = pinIndex;
     sub_plat->pins[pinIndex].gpio.mux_total = 0;
     sub_plat->pins[pinIndex].i2c.mux_total = 0;
@@ -1079,12 +1079,12 @@ mraa_ftdi_ft4222()
 
     // FTDI4222 gpio
     strncpy(sub_plat->pins[pinIndex].name, "INT-GPIO2", MRAA_PIN_NAME_SIZE);
-    sub_plat->pins[pinIndex].capabilites = pinCapsGpio;
+    sub_plat->pins[pinIndex].capabilities = pinCapsGpio;
     sub_plat->pins[pinIndex].gpio.pinmap = pinIndex;
     sub_plat->pins[pinIndex].gpio.mux_total = 0;
     pinIndex++;
     strncpy(sub_plat->pins[pinIndex].name, "INT-GPIO3", MRAA_PIN_NAME_SIZE);
-    sub_plat->pins[pinIndex].capabilites = pinCapsGpio;
+    sub_plat->pins[pinIndex].capabilities = pinCapsGpio;
     sub_plat->pins[pinIndex].gpio.pinmap = pinIndex;
     sub_plat->pins[pinIndex].gpio.mux_total = 0;
     pinIndex++;
@@ -1093,7 +1093,7 @@ mraa_ftdi_ft4222()
     int i;
     for (i = 0; i < numI2cGpioExpanderPins; ++i) {
         snprintf(sub_plat->pins[pinIndex].name, MRAA_PIN_NAME_SIZE, "EXP-GPIO%d", i);
-        sub_plat->pins[pinIndex].capabilites = pinCapsGpio;
+        sub_plat->pins[pinIndex].capabilities = pinCapsGpio;
         sub_plat->pins[pinIndex].gpio.pinmap = pinIndex;
         sub_plat->pins[pinIndex].gpio.mux_total = 0;
         pinIndex++;
@@ -1104,11 +1104,11 @@ mraa_ftdi_ft4222()
         sub_plat->i2c_bus[bus].bus_id = bus;
         sub_plat->pins[pinIndex].i2c.mux_total = 0;
         snprintf(sub_plat->pins[pinIndex].name, MRAA_PIN_NAME_SIZE, "SDA%d", bus);
-        sub_plat->pins[pinIndex].capabilites = pinCapsI2c;
+        sub_plat->pins[pinIndex].capabilities = pinCapsI2c;
         sub_plat->i2c_bus[bus].sda = pinIndex;
         pinIndex++;
         snprintf(sub_plat->pins[pinIndex].name, MRAA_PIN_NAME_SIZE, "SCL%d", bus);
-        sub_plat->pins[pinIndex].capabilites = pinCapsI2c;
+        sub_plat->pins[pinIndex].capabilities = pinCapsI2c;
         sub_plat->pins[pinIndex].i2c.mux_total = 0;
         sub_plat->i2c_bus[bus].scl = pinIndex;
         pinIndex++;

src/x86/intel_cherryhills.c

@@ -61,32 +61,32 @@ mraa_intel_cherryhills()
     int pos = 0;
     //Physical header where these pins are: J3E5
     strncpy(b->pins[pos].name, "GSUS6", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 416;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
 
     strncpy(b->pins[pos].name, "GSUS8", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 409;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
 
     strncpy(b->pins[pos].name, "GSUS7", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 414;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
 
     //Physical header where these pins are: J3E3
     strncpy(b->pins[pos].name, "GSUS0", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 406;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
 
     strncpy(b->pins[pos].name, "GSUS1", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 410;
     b->pins[pos].gpio.mux_total = 0;
     pos++;

src/x86/intel_de3815.c

@@ -64,63 +64,63 @@ mraa_intel_de3815()
     }
 
     strncpy(b->pins[0].name, "1.8v", 8);
-    b->pins[0].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[0].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[1].name, "GND", 8);
-    b->pins[1].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[1].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[2].name, "HDMIcec", 8);
-    b->pins[2].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[2].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[3].name, "DMICclk", 8);
-    b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[4].name, "3.3v", 8);
-    b->pins[4].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[5].name, "DMICda", 8);
-    b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[6].name, "Key", 8);
-    b->pins[6].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[7].name, "SMB-A", 8);
-    b->pins[7].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[7].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[8].name, "5v", 8);
-    b->pins[8].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[8].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[9].name, "SCI", 8);
-    b->pins[9].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[9].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[10].name, "PWM0", 8);
-    b->pins[10].capabilites = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
+    b->pins[10].capabilities = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
     b->pins[10].pwm.pinmap = 0;
     b->pins[10].pwm.parent_id = 0;
     b->pins[10].pwm.mux_total = 0;
 
     strncpy(b->pins[11].name, "PWM1", 8);
-    b->pins[11].capabilites = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
+    b->pins[11].capabilities = (mraa_pincapabilities_t){ 1, 0, 1, 0, 0, 0, 0, 0 };
     b->pins[11].pwm.pinmap = 0;
     b->pins[11].pwm.parent_id = 1;
     b->pins[11].pwm.mux_total = 0;
 
     strncpy(b->pins[12].name, "I2C0SCL", 8);
-    b->pins[12].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[12].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[12].i2c.pinmap = 1;
     b->pins[12].i2c.mux_total = 0;
 
     strncpy(b->pins[13].name, "I2C0SDA", 8);
-    b->pins[13].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[13].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[13].i2c.pinmap = 1;
     b->pins[13].i2c.mux_total = 0;
 
     strncpy(b->pins[14].name, "I2C1SCL", 8);
-    b->pins[14].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[14].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[14].i2c.pinmap = 1;
     b->pins[14].i2c.mux_total = 0;
 
     strncpy(b->pins[15].name, "I2C1SDA", 8);
-    b->pins[15].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[15].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[15].i2c.pinmap = 1;
     b->pins[15].i2c.mux_total = 0;
 
     strncpy(b->pins[16].name, "SMB_CLK", 8);
-    b->pins[16].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[16].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[17].name, "SMB_SDA", 8);
-    b->pins[17].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[17].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     b->i2c_bus_count = 0;
     int i2c_num = -1;

src/x86/intel_edison_fab_c.c

@@ -49,14 +49,14 @@
 typedef struct {
     int sysfs;
     int mode;
-} mraa_intel_edision_pindef_t;
+} mraa_intel_edison_pindef_t;
 
 typedef struct {
-    mraa_intel_edision_pindef_t gpio;
-    mraa_intel_edision_pindef_t pwm;
-    mraa_intel_edision_pindef_t i2c;
-    mraa_intel_edision_pindef_t spi;
-    mraa_intel_edision_pindef_t uart;
+    mraa_intel_edison_pindef_t gpio;
+    mraa_intel_edison_pindef_t pwm;
+    mraa_intel_edison_pindef_t i2c;
+    mraa_intel_edison_pindef_t spi;
+    mraa_intel_edison_pindef_t uart;
 } mraa_intel_edison_pinmodes_t;
 
 static mraa_gpio_context tristate;
@@ -76,6 +76,9 @@ static int mmap_fd = 0;
 static int mmap_size;
 static unsigned int mmap_count = 0;
 
+// PWM 0% duty workaround state array
+static int pwm_disabled[4] = { 0 };
+
 mraa_result_t
 mraa_intel_edison_spi_lsbmode_replace(mraa_spi_context dev, mraa_boolean_t lsb)
 {
@@ -367,6 +370,30 @@ mraa_intel_edison_aio_init_post(mraa_aio_context dev)
     return mraa_gpio_write(tristate, 1);
 }
 
+mraa_result_t
+mraa_intel_edison_pwm_enable_pre(mraa_pwm_context dev, int enable) {
+    // PWM 0% duty workaround: update state array
+    // if someone first ran write(0) and then enable(1).
+    if ((pwm_disabled[dev->pin] == 1) && (enable == 1)) { pwm_disabled[dev->pin] = 0; }
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_intel_edison_pwm_write_pre(mraa_pwm_context dev, float percentage) {
+    // PWM 0% duty workaround: set the state array and enable/disable pin accordingly
+    if (percentage == 0.0f) {
+        syslog(LOG_INFO, "edison_pwm_write_pre (pwm%i): requested zero duty cycle, disabling PWM on the pin", dev->pin);
+        pwm_disabled[dev->pin] = 1;
+        return mraa_pwm_enable(dev, 0);
+    } else if (pwm_disabled[dev->pin] == 1) {
+        syslog(LOG_INFO, "edison_pwm_write_pre (pwm%i): Re-enabling the pin after setting non-zero duty", dev->pin);
+        pwm_disabled[dev->pin] = 0;
+        return mraa_pwm_enable(dev, 1);
+    }
+
+    return MRAA_SUCCESS;
+}
+
 mraa_result_t
 mraa_intel_edison_pwm_init_pre(int pin)
 {
@@ -377,7 +404,7 @@ mraa_intel_edison_pwm_init_pre(int pin)
         return MRAA_ERROR_INVALID_RESOURCE;
     }
 
-    if (!plat->pins[pin].capabilites.pwm) {
+    if (!plat->pins[pin].capabilities.pwm) {
         return MRAA_ERROR_INVALID_RESOURCE;
     }
 
@@ -414,6 +441,7 @@ mraa_intel_edison_pwm_init_pre(int pin)
 mraa_result_t
 mraa_intel_edison_pwm_init_post(mraa_pwm_context pwm)
 {
+    pwm_disabled[pwm->pin] = 0;
     return mraa_gpio_write(tristate, 1);
 }
 
@@ -525,7 +553,7 @@ mraa_intel_edison_gpio_mode_replace(mraa_gpio_context dev, mraa_gpio_mode_t mode
 }
 
 mraa_result_t
-mraa_intel_edsion_mb_gpio_mode(mraa_gpio_context dev, mraa_gpio_mode_t mode)
+mraa_intel_edison_mb_gpio_mode(mraa_gpio_context dev, mraa_gpio_mode_t mode)
 {
     if (dev->value_fp != -1) {
         if (close(dev->value_fp) != 0) {
@@ -631,7 +659,7 @@ mraa_intel_edison_uart_init_post(mraa_uart_context uart)
 }
 
 static mraa_result_t
-mraa_intel_edsion_mmap_unsetup()
+mraa_intel_edison_mmap_unsetup()
 {
     if (mmap_reg == NULL) {
         syslog(LOG_ERR, "edison mmap: null register cant unsetup");
@@ -692,7 +720,7 @@ mraa_intel_edison_mmap_setup(mraa_gpio_context dev, mraa_boolean_t en)
         dev->mmap_read = NULL;
         mmap_count--;
         if (mmap_count == 0) {
-            return mraa_intel_edsion_mmap_unsetup();
+            return mraa_intel_edison_mmap_unsetup();
         }
         return MRAA_SUCCESS;
     }
@@ -802,16 +830,18 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     }
     b->adv_func->gpio_init_post = &mraa_intel_edison_gpio_init_post;
     b->adv_func->pwm_init_pre = &mraa_intel_edison_pwm_init_pre;
+    b->adv_func->pwm_enable_pre = &mraa_intel_edison_pwm_enable_pre;
+    b->adv_func->pwm_write_pre = &mraa_intel_edison_pwm_write_pre;
     b->adv_func->i2c_init_pre = &mraa_intel_edison_i2c_init_pre;
     b->adv_func->i2c_set_frequency_replace = &mraa_intel_edison_i2c_freq;
     b->adv_func->spi_init_pre = &mraa_intel_edison_spi_init_pre;
-    b->adv_func->gpio_mode_replace = &mraa_intel_edsion_mb_gpio_mode;
+    b->adv_func->gpio_mode_replace = &mraa_intel_edison_mb_gpio_mode;
     b->adv_func->uart_init_pre = &mraa_intel_edison_uart_init_pre;
     b->adv_func->gpio_mmap_setup = &mraa_intel_edison_mmap_setup;
 
     int pos = 0;
     strncpy(b->pins[pos].name, "J17-1", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 182;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].pwm.pinmap = 2;
@@ -820,27 +850,27 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     pos++;
 
     strncpy(b->pins[pos].name, "J17-2", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
     strncpy(b->pins[pos].name, "J17-3", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
     strncpy(b->pins[pos].name, "J17-4", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
 
     strncpy(b->pins[pos].name, "J17-5", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 135;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
 
     strncpy(b->pins[pos].name, "J17-6", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
 
     strncpy(b->pins[pos].name, "J17-7", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
     b->pins[pos].gpio.pinmap = 27;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].i2c.pinmap = 1;
@@ -848,7 +878,7 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     pos++;
 
     strncpy(b->pins[pos].name, "J17-8", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
     b->pins[pos].gpio.pinmap = 20;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].i2c.pinmap = 1;
@@ -856,7 +886,7 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     pos++;
 
     strncpy(b->pins[pos].name, "J17-9", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
     b->pins[pos].gpio.pinmap = 28;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].i2c.pinmap = 1;
@@ -864,7 +894,7 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     pos++;
 
     strncpy(b->pins[pos].name, "J17-10", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 111;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].spi.pinmap = 5;
@@ -872,7 +902,7 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     pos++;
 
     strncpy(b->pins[pos].name, "J17-11", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 109;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].spi.pinmap = 5;
@@ -880,25 +910,25 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     pos++;
 
     strncpy(b->pins[pos].name, "J17-12", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 115;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].spi.pinmap = 5;
     b->pins[pos].spi.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J17-13", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
 
     strncpy(b->pins[pos].name, "J17-14", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 128;
     b->pins[pos].gpio.parent_id = 0;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
 
     strncpy(b->pins[pos].name, "J18-1", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0 , 0};
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0 , 0};
     b->pins[pos].gpio.pinmap = 13;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].pwm.pinmap = 1;
@@ -907,22 +937,22 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     pos++;
 
     strncpy(b->pins[pos].name, "J18-2", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 165;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J18-3", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
     strncpy(b->pins[pos].name, "J18-4", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
     strncpy(b->pins[pos].name, "J18-5", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
 
     strncpy(b->pins[pos].name, "J18-6", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
     b->pins[pos].gpio.pinmap = 19;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].i2c.pinmap = 1;
@@ -930,7 +960,7 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     pos++;
 
     strncpy(b->pins[pos].name, "J18-7", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 12;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].pwm.pinmap = 0;
@@ -939,7 +969,7 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     pos++;
 
     strncpy(b->pins[pos].name, "J18-8", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 183;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].pwm.pinmap = 3;
@@ -947,18 +977,18 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     b->pins[pos].pwm.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J18-9", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
 
     strncpy(b->pins[pos].name, "J18-10", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 110;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].spi.pinmap = 5;
     b->pins[pos].spi.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J18-11", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 114;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].spi.pinmap = 5;
@@ -966,12 +996,12 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     pos++;
 
     strncpy(b->pins[pos].name, "J18-12", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 129;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J18-13", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[pos].gpio.pinmap = 130;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].uart.pinmap = 0;
@@ -980,41 +1010,41 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
 
     pos++;
     strncpy(b->pins[pos].name, "J18-14", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
 
     strncpy(b->pins[pos].name, "J19-1", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
     strncpy(b->pins[pos].name, "J19-2", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
     strncpy(b->pins[pos].name, "J19-3", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
 
     strncpy(b->pins[pos].name, "J19-4", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 44;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J19-5", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 46;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J19-6", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 48;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
 
     strncpy(b->pins[pos].name, "J19-7", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
 
     strncpy(b->pins[pos].name, "J19-8", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[pos].gpio.pinmap = 131;
     b->pins[pos].gpio.mux_total = 0;
     b->pins[pos].uart.pinmap = 0;
@@ -1023,98 +1053,98 @@ mraa_intel_edison_miniboard(mraa_board_t* b)
     pos++;
 
     strncpy(b->pins[pos].name, "J19-9", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 14;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
 
     strncpy(b->pins[pos].name, "J19-10", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 40;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J19-11", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 43;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J19-12", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 77;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J19-13", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 82;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J19-14", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 83;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
 
     strncpy(b->pins[pos].name, "J20-1", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
     strncpy(b->pins[pos].name, "J20-2", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
     strncpy(b->pins[pos].name, "J20-3", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     pos++;
     strncpy(b->pins[pos].name, "J20-4", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 45;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J20-5", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 47;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J20-6", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 49;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J20-7", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 15;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J20-8", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 84;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J20-9", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 42;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J20-10", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 41;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J20-11", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 78;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J20-12", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 79;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J20-13", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 80;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
     strncpy(b->pins[pos].name, "J20-14", 8);
-    b->pins[pos].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[pos].gpio.pinmap = 81;
     b->pins[pos].gpio.mux_total = 0;
     pos++;
@@ -1259,6 +1289,8 @@ mraa_intel_edison_fab_c()
     b->adv_func->aio_init_post = &mraa_intel_edison_aio_init_post;
     b->adv_func->pwm_init_pre = &mraa_intel_edison_pwm_init_pre;
     b->adv_func->pwm_init_post = &mraa_intel_edison_pwm_init_post;
+    b->adv_func->pwm_enable_pre = &mraa_intel_edison_pwm_enable_pre;
+    b->adv_func->pwm_write_pre = &mraa_intel_edison_pwm_write_pre;
     b->adv_func->spi_init_pre = &mraa_intel_edison_spi_init_pre;
     b->adv_func->spi_init_post = &mraa_intel_edison_spi_init_post;
     b->adv_func->gpio_mode_replace = &mraa_intel_edison_gpio_mode_replace;
@@ -1274,8 +1306,9 @@ mraa_intel_edison_fab_c()
     }
 
     if (mraa_gpio_read_dir(tristate, &tristate_dir) != MRAA_SUCCESS) {
-       free(b->adv_func);
-       goto error;
+        free(b->pins);
+        free(b->adv_func);
+        goto error;
     }
 
     if (tristate_dir != MRAA_GPIO_OUT) {
@@ -1292,7 +1325,7 @@ mraa_intel_edison_fab_c()
     b->pwm_min_period = 1;
 
     strncpy(b->pins[0].name, "IO0", 8);
-    b->pins[0].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[0].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[0].gpio.pinmap = 130;
     b->pins[0].gpio.parent_id = 0;
     b->pins[0].gpio.mux_total = 1;
@@ -1304,7 +1337,7 @@ mraa_intel_edison_fab_c()
     b->pins[0].uart.mux_total = 0;
 
     strncpy(b->pins[1].name, "IO1", 8);
-    b->pins[1].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[1].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[1].gpio.pinmap = 131;
     b->pins[1].gpio.parent_id = 0;
     b->pins[1].gpio.mux_total = 1;
@@ -1316,7 +1349,7 @@ mraa_intel_edison_fab_c()
     b->pins[1].uart.mux_total = 0;
 
     strncpy(b->pins[2].name, "IO2", 8);
-    b->pins[2].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[2].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[2].gpio.pinmap = 128;
     b->pins[2].gpio.parent_id = 0;
     b->pins[2].gpio.mux_total = 1;
@@ -1325,7 +1358,7 @@ mraa_intel_edison_fab_c()
     b->pins[2].gpio.mux[0].value = MRAA_GPIO_IN;
 
     strncpy(b->pins[3].name, "IO3", 8);
-    b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[3].gpio.pinmap = 12;
     b->pins[3].gpio.parent_id = 0;
     b->pins[3].gpio.mux_total = 1;
@@ -1337,7 +1370,7 @@ mraa_intel_edison_fab_c()
     b->pins[3].pwm.mux_total = 0;
 
     strncpy(b->pins[4].name, "IO4", 8);
-    b->pins[4].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[4].gpio.pinmap = 129;
     b->pins[4].gpio.parent_id = 0;
     b->pins[4].gpio.mux_total = 1;
@@ -1346,7 +1379,7 @@ mraa_intel_edison_fab_c()
     b->pins[4].gpio.mux[0].value = MRAA_GPIO_IN;
 
     strncpy(b->pins[5].name, "IO5", 8);
-    b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[5].gpio.pinmap = 13;
     b->pins[5].gpio.parent_id = 0;
     b->pins[5].gpio.mux_total = 1;
@@ -1358,7 +1391,7 @@ mraa_intel_edison_fab_c()
     b->pins[5].pwm.mux_total = 0;
 
     strncpy(b->pins[6].name, "IO6", 8);
-    b->pins[6].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[6].gpio.pinmap = 182;
     b->pins[6].gpio.parent_id = 0;
     b->pins[6].gpio.mux_total = 1;
@@ -1370,7 +1403,7 @@ mraa_intel_edison_fab_c()
     b->pins[6].pwm.mux_total = 0;
 
     strncpy(b->pins[7].name, "IO7", 8);
-    b->pins[7].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[7].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[7].gpio.pinmap = 48;
     b->pins[7].gpio.parent_id = 0;
     b->pins[7].gpio.mux_total = 1;
@@ -1379,7 +1412,7 @@ mraa_intel_edison_fab_c()
     b->pins[7].gpio.mux[0].value = MRAA_GPIO_IN;
 
     strncpy(b->pins[8].name, "IO8", 8);
-    b->pins[8].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[8].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[8].gpio.pinmap = 49;
     b->pins[8].gpio.parent_id = 0;
     b->pins[8].gpio.mux_total = 1;
@@ -1388,7 +1421,7 @@ mraa_intel_edison_fab_c()
     b->pins[8].gpio.mux[0].value = MRAA_GPIO_IN;
 
     strncpy(b->pins[9].name, "IO9", 8);
-    b->pins[9].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[9].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[9].gpio.pinmap = 183;
     b->pins[9].gpio.parent_id = 0;
     b->pins[9].gpio.mux_total = 1;
@@ -1400,7 +1433,7 @@ mraa_intel_edison_fab_c()
     b->pins[9].pwm.mux_total = 0;
 
     strncpy(b->pins[10].name, "IO10", 8);
-    b->pins[10].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[10].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[10].gpio.pinmap = 41;
     b->pins[10].gpio.parent_id = 0;
     b->pins[10].gpio.mux_total = 3;
@@ -1426,7 +1459,7 @@ mraa_intel_edison_fab_c()
     b->pins[10].spi.mux[2].value = 1;
 
     strncpy(b->pins[11].name, "IO11", 8);
-    b->pins[11].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[11].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[11].gpio.pinmap = 43;
     b->pins[11].gpio.parent_id = 0;
     b->pins[11].gpio.mux_total = 3;
@@ -1452,7 +1485,7 @@ mraa_intel_edison_fab_c()
     b->pins[11].spi.mux[2].value = 1;
 
     strncpy(b->pins[12].name, "IO12", 8);
-    b->pins[12].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[12].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[12].gpio.pinmap = 42;
     b->pins[12].gpio.parent_id = 0;
     b->pins[12].gpio.mux_total = 2;
@@ -1472,7 +1505,7 @@ mraa_intel_edison_fab_c()
     b->pins[12].spi.mux[1].value = 1;
 
     strncpy(b->pins[13].name, "IO13", 8);
-    b->pins[13].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[13].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[13].gpio.pinmap = 40;
     b->pins[13].gpio.parent_id = 0;
     b->pins[13].gpio.mux_total = 2;
@@ -1492,7 +1525,7 @@ mraa_intel_edison_fab_c()
     b->pins[13].spi.mux[1].value = 1;
 
     strncpy(b->pins[14].name, "A0", 8);
-    b->pins[14].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[14].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[14].aio.pinmap = 0;
     b->pins[14].aio.mux_total = 2;
     b->pins[14].aio.mux[0].pincmd = PINCMD_SET_DIRECTION;
@@ -1511,7 +1544,7 @@ mraa_intel_edison_fab_c()
     b->pins[14].gpio.mux[1].value = 0;
 
     strncpy(b->pins[15].name, "A1", 8);
-    b->pins[15].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[15].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[15].aio.pinmap = 1;
     b->pins[15].aio.mux_total = 2;
     b->pins[15].aio.mux[0].pincmd = PINCMD_SET_DIRECTION;
@@ -1530,7 +1563,7 @@ mraa_intel_edison_fab_c()
     b->pins[15].gpio.mux[1].value = 0;
 
     strncpy(b->pins[16].name, "A2", 8);
-    b->pins[16].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[16].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[16].aio.pinmap = 2;
     b->pins[16].aio.mux_total = 2;
     b->pins[16].aio.mux[0].pincmd = PINCMD_SET_DIRECTION;
@@ -1549,7 +1582,7 @@ mraa_intel_edison_fab_c()
     b->pins[16].gpio.mux[1].value = 0;
 
     strncpy(b->pins[17].name, "A3", 8);
-    b->pins[17].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[17].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[17].aio.pinmap = 3;
     b->pins[17].aio.mux_total = 2;
     b->pins[17].aio.mux[0].pincmd = PINCMD_SET_DIRECTION;
@@ -1568,7 +1601,7 @@ mraa_intel_edison_fab_c()
     b->pins[17].gpio.mux[1].value = 0;
 
     strncpy(b->pins[18].name, "A4", 8);
-    b->pins[18].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
+    b->pins[18].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
     b->pins[18].i2c.pinmap = 1;
     b->pins[18].i2c.mux_total = 2;
     b->pins[18].i2c.mux[0].pincmd = PINCMD_SET_DIRECTION;
@@ -1595,7 +1628,7 @@ mraa_intel_edison_fab_c()
     b->pins[18].gpio.mux[1].value = 0;
 
     strncpy(b->pins[19].name, "A5", 8);
-    b->pins[19].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
+    b->pins[19].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
     b->pins[19].i2c.pinmap = 1;
     b->pins[19].i2c.mux_total = 2;
     b->pins[19].i2c.mux[0].pincmd = PINCMD_SET_DIRECTION;

src/x86/intel_galileo_rev_d.c

@@ -140,6 +140,34 @@ mraa_intel_galileo_g1_spi_lsbmode_replace(mraa_spi_context dev, mraa_boolean_t l
     return MRAA_SUCCESS;
 }
 
+mraa_result_t
+mraa_intel_galileo_g1_pwm_init_pre(int pin)
+{
+    // Gen1 galileo has no kernel muxing for GPIOs/PWM so ends up with leakage
+    // on the PWM pins from the GPIO pins if not set to output high
+    if (plat->pins[pin].capabilities.gpio == 1) {
+        mraa_gpio_context mux_i;
+        mux_i = mraa_gpio_init_raw(plat->pins[pin].gpio.pinmap);
+        if (mux_i == NULL) {
+            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_init", pin);
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+        if (mraa_gpio_dir(mux_i, MRAA_GPIO_OUT) != MRAA_SUCCESS) {
+            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_dir", pin);
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+        if (mraa_gpio_write(mux_i, 1) != MRAA_SUCCESS) {
+            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_write", pin);
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+        if (mraa_gpio_close(mux_i) != MRAA_SUCCESS) {
+            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_close", pin);
+            return MRAA_ERROR_INVALID_RESOURCE;
+        }
+    }
+    return MRAA_SUCCESS;
+}
+
 mraa_board_t*
 mraa_intel_galileo_rev_d()
 {
@@ -166,6 +194,7 @@ mraa_intel_galileo_rev_d()
     }
     b->adv_func->gpio_mmap_setup = &mraa_intel_galileo_g1_mmap_setup;
     b->adv_func->spi_lsbmode_replace = &mraa_intel_galileo_g1_spi_lsbmode_replace;
+    b->adv_func->pwm_init_pre = mraa_intel_galileo_g1_pwm_init_pre;
 
     b->pins = (mraa_pininfo_t*) calloc(MRAA_INTEL_GALILEO_REV_D_PINCOUNT, sizeof(mraa_pininfo_t));
     if (b->pins == NULL) {
@@ -175,7 +204,7 @@ mraa_intel_galileo_rev_d()
 
     // GPIO IO0 - IO10
     strncpy(b->pins[0].name, "IO0", 8);
-    b->pins[0].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[0].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[0].gpio.pinmap = 50;
     b->pins[0].gpio.parent_id = 0;
     b->pins[0].gpio.mux_total = 1;
@@ -190,7 +219,7 @@ mraa_intel_galileo_rev_d()
     b->pins[0].uart.mux[0].value = 0;
 
     strncpy(b->pins[1].name, "IO1", 8);
-    b->pins[1].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[1].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
     b->pins[1].gpio.pinmap = 51;
     b->pins[1].gpio.mux_total = 1;
     b->pins[1].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -204,7 +233,7 @@ mraa_intel_galileo_rev_d()
     b->pins[1].uart.mux[0].value = 0;
 
     strncpy(b->pins[2].name, "IO2", 8);
-    b->pins[2].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 1, 0, 0, 0, 0 };
+    b->pins[2].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 1, 0, 0, 0, 0 };
     b->pins[2].gpio.pinmap = 32;
     b->pins[2].gpio.mux_total = 1;
     b->pins[2].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -226,7 +255,7 @@ mraa_intel_galileo_rev_d()
     b->pins[2].mmap.bit_pos = 6;
 
     strncpy(b->pins[3].name, "IO3", 8);
-    b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 1, 0, 0, 0, 0 };
+    b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 1, 0, 0, 0, 0 };
     b->pins[3].gpio.pinmap = 18;
     b->pins[3].gpio.mux_total = 1;
     b->pins[3].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -255,12 +284,12 @@ mraa_intel_galileo_rev_d()
 
 
     strncpy(b->pins[4].name, "IO4", 8);
-    b->pins[4].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[4].gpio.pinmap = 28;
     b->pins[4].gpio.mux_total = 0;
 
     strncpy(b->pins[5].name, "IO5", 8);
-    b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[5].gpio.pinmap = 17;
     b->pins[5].gpio.mux_total = 0;
     b->pins[5].pwm.pinmap = 5;
@@ -269,24 +298,24 @@ mraa_intel_galileo_rev_d()
 
     strncpy(b->pins[6].name, "IO6", 8);
     b->pins[6].gpio.pinmap = 24;
-    b->pins[6].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[6].gpio.mux_total = 0;
     b->pins[6].pwm.pinmap = 6;
     b->pins[6].pwm.parent_id = 0;
     b->pins[6].pwm.mux_total = 0;
 
     strncpy(b->pins[7].name, "IO7", 8);
-    b->pins[7].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[7].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[7].gpio.pinmap = 27;
     b->pins[7].gpio.mux_total = 0;
 
     strncpy(b->pins[8].name, "IO8", 8);
-    b->pins[8].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[8].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[8].gpio.pinmap = 26;
     b->pins[8].gpio.mux_total = 0;
 
     strncpy(b->pins[9].name, "IO9", 8);
-    b->pins[9].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[9].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[9].gpio.pinmap = 19;
     b->pins[9].gpio.mux_total = 0;
     b->pins[9].pwm.pinmap = 1;
@@ -294,7 +323,7 @@ mraa_intel_galileo_rev_d()
     b->pins[9].pwm.mux_total = 0;
 
     strncpy(b->pins[10].name, "IO10", 8);
-    b->pins[10].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 1, 0, 0, 0 };
+    b->pins[10].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 1, 0, 0, 0 };
     b->pins[10].gpio.pinmap = 16;
     b->pins[10].gpio.mux_total = 1;
     b->pins[10].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -313,7 +342,7 @@ mraa_intel_galileo_rev_d()
     b->pins[10].spi.mux[0].value = 0;
 
     strncpy(b->pins[11].name, "IO11", 8);
-    b->pins[11].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 1, 0, 0, 0 };
+    b->pins[11].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 1, 0, 0, 0 };
     b->pins[11].gpio.pinmap = 25;
     b->pins[11].gpio.mux_total = 1;
     b->pins[11].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -332,7 +361,7 @@ mraa_intel_galileo_rev_d()
     b->pins[11].spi.mux[0].value = 0;
 
     strncpy(b->pins[12].name, "IO12", 8);
-    b->pins[12].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[12].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[12].gpio.pinmap = 38;
     b->pins[12].gpio.mux_total = 1;
     b->pins[12].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -345,7 +374,7 @@ mraa_intel_galileo_rev_d()
     b->pins[12].spi.mux[0].value = 0;
 
     strncpy(b->pins[13].name, "IO13", 8);
-    b->pins[13].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[13].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[13].gpio.pinmap = 39;
     b->pins[13].gpio.mux_total = 1;
     b->pins[13].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -358,7 +387,7 @@ mraa_intel_galileo_rev_d()
     b->pins[13].spi.mux[0].value = 0;
 
     strncpy(b->pins[14].name, "A0", 8);
-    b->pins[14].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[14].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[14].gpio.pinmap = 44;
     b->pins[14].gpio.mux_total = 1;
     b->pins[14].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -371,7 +400,7 @@ mraa_intel_galileo_rev_d()
     b->pins[14].aio.mux[0].value = 0;
 
     strncpy(b->pins[15].name, "A1", 8);
-    b->pins[15].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[15].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[15].gpio.pinmap = 45;
     b->pins[15].gpio.mux_total = 1;
     b->pins[15].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -384,7 +413,7 @@ mraa_intel_galileo_rev_d()
     b->pins[15].aio.mux[0].value = 0;
 
     strncpy(b->pins[16].name, "A2", 8);
-    b->pins[16].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[16].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[16].gpio.pinmap = 46;
     b->pins[16].gpio.mux_total = 1;
     b->pins[16].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -397,7 +426,7 @@ mraa_intel_galileo_rev_d()
     b->pins[16].aio.mux[0].value = 0;
 
     strncpy(b->pins[17].name, "A3", 8);
-    b->pins[17].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[17].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[17].gpio.pinmap = 47;
     b->pins[17].gpio.mux_total = 1;
     b->pins[17].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -410,7 +439,7 @@ mraa_intel_galileo_rev_d()
     b->pins[17].aio.mux[0].value = 0;
 
     strncpy(b->pins[18].name, "A4", 8);
-    b->pins[18].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
+    b->pins[18].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
     b->pins[18].gpio.pinmap = 48;
     b->pins[18].gpio.mux_total = 2;
     b->pins[18].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;
@@ -434,7 +463,7 @@ mraa_intel_galileo_rev_d()
     b->pins[18].aio.mux[1].value = 0;
 
     strncpy(b->pins[19].name, "A5", 8);
-    b->pins[19].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
+    b->pins[19].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
     b->pins[19].gpio.pinmap = 49;
     b->pins[19].gpio.mux_total = 2;
     b->pins[19].gpio.mux[0].pincmd = PINCMD_SET_OUT_VALUE;

src/x86/intel_galileo_rev_g.c

@@ -296,7 +296,7 @@ mraa_intel_galileo_gen2()
     }
 
     strncpy(b->pins[0].name, "IO0", 8);
-    b->pins[0].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 1, 0, 0, 0, 1 };
+    b->pins[0].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 1, 0, 0, 0, 1 };
     b->pins[0].gpio.pinmap = 11;
     b->pins[0].gpio.parent_id = 0;
     b->pins[0].gpio.mux_total = 1;
@@ -329,7 +329,7 @@ mraa_intel_galileo_gen2()
     b->pins[0].uart.mux[1].value = 1;
 
     strncpy(b->pins[1].name, "IO1", 8);
-    b->pins[1].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 1, 0, 0, 0, 1 };
+    b->pins[1].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 1, 0, 0, 0, 1 };
     b->pins[1].gpio.pinmap = 12;
     b->pins[1].gpio.parent_id = 0;
     b->pins[1].gpio.mux_total = 2;
@@ -371,14 +371,14 @@ mraa_intel_galileo_gen2()
     b->pins[1].uart.mux[2].value = 0;
 
     strncpy(b->pins[2].name, "IO2", 8);
-    b->pins[2].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 1, 0, 0, 0, 0};
+    b->pins[2].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 1, 0, 0, 0, 0};
     b->pins[2].gpio.pinmap = 13;
     b->pins[2].gpio.parent_id = 0;
     b->pins[2].gpio.mux_total = 2;
     b->pins[2].gpio.mux[0].pincmd = PINCMD_SET_DIRECTION;
     b->pins[2].gpio.mux[0].pin = 35;
     b->pins[2].gpio.mux[0].value = MRAA_GPIO_IN;
-    b->pins[2].gpio.mux[0].pincmd = PINCMD_SET_VALUE;
+    b->pins[2].gpio.mux[1].pincmd = PINCMD_SET_VALUE;
     b->pins[2].gpio.mux[1].pin = 77;
     b->pins[2].gpio.mux[1].value = 0;
     b->pins[2].gpio.complex_cap = (mraa_pin_cap_complex_t){ 1, 1, 0, 1, 1 };
@@ -402,7 +402,7 @@ mraa_intel_galileo_gen2()
     b->pins[2].mmap.bit_pos = 5;
 
     strncpy(b->pins[3].name, "IO3", 8);
-    b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 1, 0, 0, 0, 0 };
+    b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 1, 0, 0, 0, 0 };
     b->pins[3].gpio.pinmap = 14;
     b->pins[3].gpio.parent_id = 0;
     b->pins[3].gpio.mux_total = 3;
@@ -454,7 +454,7 @@ mraa_intel_galileo_gen2()
     b->pins[3].mmap.bit_pos = 6;
 
     strncpy(b->pins[4].name, "IO4", 8);
-    b->pins[4].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[4].gpio.pinmap = 6;
     b->pins[4].gpio.parent_id = 0;
     b->pins[4].gpio.mux_total = 1;
@@ -465,7 +465,7 @@ mraa_intel_galileo_gen2()
     b->pins[4].gpio.output_enable = 36;
 
     strncpy(b->pins[5].name, "IO5", 8);
-    b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0 , 0 };
+    b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0 , 0 };
     b->pins[5].gpio.pinmap = 0;
     b->pins[5].gpio.parent_id = 0;
     b->pins[5].gpio.mux_total = 2;
@@ -491,7 +491,7 @@ mraa_intel_galileo_gen2()
     b->pins[5].pwm.mux[2].value = 0;
 
     strncpy(b->pins[6].name, "IO6", 8);
-    b->pins[6].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[6].gpio.pinmap = 1;
     b->pins[6].gpio.parent_id = 0;
     b->pins[6].gpio.mux_total = 2;
@@ -517,7 +517,7 @@ mraa_intel_galileo_gen2()
     b->pins[6].pwm.mux[2].value = 0;
 
     strncpy(b->pins[7].name, "IO7", 8);
-    b->pins[7].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[7].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[7].gpio.pinmap = 38;
     b->pins[7].gpio.parent_id = 0;
     b->pins[7].gpio.mux_total = 1;
@@ -527,7 +527,7 @@ mraa_intel_galileo_gen2()
     b->pins[7].gpio.complex_cap = (mraa_pin_cap_complex_t){ 1, 0, 0, 1, 1 };
 
     strncpy(b->pins[8].name, "IO8", 8);
-    b->pins[8].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[8].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
     b->pins[8].gpio.pinmap = 40;
     b->pins[8].gpio.parent_id = 0;
     b->pins[8].gpio.mux_total = 1;
@@ -537,7 +537,7 @@ mraa_intel_galileo_gen2()
     b->pins[8].gpio.complex_cap = (mraa_pin_cap_complex_t){ 1, 0, 0, 1, 1 };
 
     strncpy(b->pins[9].name, "IO9", 8);
-    b->pins[9].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[9].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
     b->pins[9].gpio.pinmap = 4;
     b->pins[9].gpio.parent_id = 0;
     b->pins[9].gpio.mux_total = 2;
@@ -563,7 +563,7 @@ mraa_intel_galileo_gen2()
     b->pins[9].pwm.mux[2].value = 0;
 
     strncpy(b->pins[10].name, "IO10", 8);
-    b->pins[10].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 1, 1, 0, 0, 0 };
+    b->pins[10].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 1, 1, 0, 0, 0 };
     b->pins[10].gpio.pinmap = 10;
     b->pins[10].gpio.parent_id = 0;
     b->pins[10].gpio.mux_total = 2;
@@ -617,7 +617,7 @@ mraa_intel_galileo_gen2()
     b->pins[10].spi.mux[2].value = 0;
 
     strncpy(b->pins[11].name, "IO11", 8);
-    b->pins[11].capabilites = (mraa_pincapabilities_t){ 1, 1, 1, 0, 1, 0, 0, 0 };
+    b->pins[11].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 1, 0, 0, 0 };
     b->pins[11].gpio.pinmap = 5;
     b->pins[11].gpio.parent_id = 0;
     b->pins[11].gpio.mux_total = 3;
@@ -663,7 +663,7 @@ mraa_intel_galileo_gen2()
     b->pins[11].spi.mux[3].value = 0;
 
     strncpy(b->pins[12].name, "IO12", 8);
-    b->pins[12].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 1, 1, 0, 0, 0 };
+    b->pins[12].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 1, 1, 0, 0, 0 };
     b->pins[12].gpio.pinmap = 15;
     b->pins[12].gpio.parent_id = 0;
     b->pins[12].gpio.mux_total = 1;
@@ -696,7 +696,7 @@ mraa_intel_galileo_gen2()
     b->pins[12].mmap.bit_pos = 7;
 
     strncpy(b->pins[13].name, "IO13", 8);
-    b->pins[13].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[13].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
     b->pins[13].gpio.pinmap = 7;
     b->pins[13].gpio.parent_id = 0;
     b->pins[13].gpio.mux_total = 2;
@@ -722,7 +722,7 @@ mraa_intel_galileo_gen2()
 
     // ANALOG
     strncpy(b->pins[14].name, "A0", 8);
-    b->pins[14].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[14].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[14].gpio.complex_cap = (mraa_pin_cap_complex_t){ 1, 0, 0, 1, 1 };
     b->pins[14].aio.pinmap = 0;
     b->pins[14].aio.mux_total = 2;
@@ -739,7 +739,7 @@ mraa_intel_galileo_gen2()
     b->pins[14].gpio.mux[0].value = MRAA_GPIO_IN;
 
     strncpy(b->pins[15].name, "A1", 8);
-    b->pins[15].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[15].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[15].gpio.complex_cap = (mraa_pin_cap_complex_t){ 1, 0, 0, 1, 1 };
     b->pins[15].aio.pinmap = 1;
     b->pins[15].aio.mux_total = 2;
@@ -756,7 +756,7 @@ mraa_intel_galileo_gen2()
     b->pins[15].gpio.mux[0].value = MRAA_GPIO_IN;
 
     strncpy(b->pins[16].name, "A2", 8);
-    b->pins[16].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[16].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[16].gpio.complex_cap = (mraa_pin_cap_complex_t){ 1, 0, 0, 1, 1 };
     b->pins[16].aio.pinmap = 2;
     b->pins[16].aio.mux_total = 2;
@@ -773,7 +773,7 @@ mraa_intel_galileo_gen2()
     b->pins[16].gpio.mux[0].value = MRAA_GPIO_IN;
 
     strncpy(b->pins[17].name, "A3", 8);
-    b->pins[17].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
+    b->pins[17].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
     b->pins[17].gpio.complex_cap = (mraa_pin_cap_complex_t){ 1, 0, 0, 1, 1 };
     b->pins[17].aio.pinmap = 3;
     b->pins[17].aio.mux_total = 2;
@@ -790,7 +790,7 @@ mraa_intel_galileo_gen2()
     b->pins[17].gpio.mux[0].value = MRAA_GPIO_IN;
 
     strncpy(b->pins[18].name, "A4", 8);
-    b->pins[18].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
+    b->pins[18].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
     b->pins[18].gpio.complex_cap = (mraa_pin_cap_complex_t){ 1, 0, 0, 1, 1 };
     b->pins[18].i2c.pinmap = 1;
     b->pins[18].i2c.mux_total = 3;
@@ -827,7 +827,7 @@ mraa_intel_galileo_gen2()
     b->pins[18].gpio.mux[2].value = 1;
 
     strncpy(b->pins[19].name, "A5", 8);
-    b->pins[19].capabilites = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
+    b->pins[19].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 1, 0 };
     b->pins[19].gpio.complex_cap = (mraa_pin_cap_complex_t){ 1, 0, 0, 1, 1 };
     b->pins[19].i2c.pinmap = 1;
     b->pins[19].i2c.mux_total = 3;

src/x86/intel_gt_tuchuck.c

@@ -0,0 +1,653 @@
+/*
+ * Author: Brendan Le Foll <brendan.le.foll@intel.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "common.h"
+#include "x86/intel_gt_tuchuck.h"
+
+#define PLATFORM_NAME "Intel GT Tuchuck"
+
+mraa_board_t*
+mraa_gt_tuchuck_board()
+{
+    mraa_board_t* b = (mraa_board_t*) calloc(1, sizeof(mraa_board_t));
+    if (b == NULL) {
+        return NULL;
+    }
+
+    b->platform_name = PLATFORM_NAME;
+    b->phy_pin_count = MRAA_INTEL_GT_TUCHUCK_PINCOUNT;
+    b->aio_count = 0;
+    b->adc_raw = 0;
+    b->adc_supported = 0;
+
+    b->pins = (mraa_pininfo_t*) malloc(sizeof(mraa_pininfo_t) * MRAA_INTEL_GT_TUCHUCK_PINCOUNT);
+    if (b->pins == NULL) {
+        goto error;
+    }
+
+    b->adv_func = (mraa_adv_func_t*) calloc(1, sizeof(mraa_adv_func_t));
+    if (b->adv_func == NULL) {
+        free(b->pins);
+        goto error;
+    }
+
+    b->pwm_default_period = 5000;
+    b->pwm_max_period = 218453;
+    b->pwm_min_period = 1;
+
+    b->i2c_bus_count = 3;
+    b->i2c_bus[0].bus_id = 0;
+    b->i2c_bus[0].sda = 11;
+    b->i2c_bus[0].scl = 13;
+
+    if (mraa_find_i2c_bus("designware", 5) != 5) {
+        b->i2c_bus[1].bus_id = 9;
+        b->i2c_bus[2].bus_id = 10;
+    } else {
+        b->i2c_bus[1].bus_id = 5;
+        b->i2c_bus[2].bus_id = 6;
+    }
+    b->i2c_bus[1].sda = 15;
+    b->i2c_bus[1].scl = 17;
+    b->i2c_bus[2].sda = 19;
+    b->i2c_bus[2].scl = 21;
+
+    b->def_i2c_bus = b->i2c_bus[0].bus_id;
+
+#if 0
+    b->spi_bus_count = 6;
+    b->def_spi_bus = 0;
+    b->spi_bus[0].bus_id = 32764;
+    b->spi_bus[0].slave_s = 1;
+    b->spi_bus[1].bus_id = 32764;
+    b->spi_bus[1].slave_s = 2;
+    b->spi_bus[2].bus_id = 32765;
+    b->spi_bus[2].slave_s = 0;
+    b->spi_bus[3].bus_id = 32765;
+    b->spi_bus[3].slave_s = 1;
+    b->spi_bus[4].bus_id = 32766;
+    b->spi_bus[4].slave_s = 0;
+    b->spi_bus[5].bus_id = 32766;
+    b->spi_bus[5].slave_s = 1;
+#endif
+
+    int pos = 0;
+
+    strncpy(b->pins[pos].name, "INVALID", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 0, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "GPIO", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 446;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPP1RX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 421;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "PMICRST", 8);
+    // disabled as this pin causes a reset
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 366;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPP1TX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 422;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "19.2mhz", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 356;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPP1FS0", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 417;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "UART0TX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 1 };
+    // not configured as GPIO
+    //b->pins[pos].gpio.pinmap = 462;
+    //b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPP1FS2", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 419;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "PWRGD", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    // not configured as GPI0 - does read work?
+    //b->pins[pos].gpio.pinmap = 365;
+    //b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPP1CLK", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 416;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    // pin 11
+    strncpy(b->pins[pos].name, "I2C0SDA", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].gpio.pinmap = 315;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].i2c.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S1SDI", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 381;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2C0SCL", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].gpio.pinmap = 316;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].i2c.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S1SDO", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 382;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2C1SDA", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].gpio.pinmap = 331;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].i2c.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S1WS", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 380;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2C1SCL", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].gpio.pinmap = 332;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    b->pins[pos].i2c.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S1CLK", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 379;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2C2SDA", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].gpio.pinmap = 333;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    b->pins[pos].i2c.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S1MCL", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 378;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2C2SCL", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].gpio.pinmap = 334;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].i2c.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "UART1TX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 1 };
+    //b->pins[pos].gpio.pinmap = 472;
+    //b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S4SDO", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    // doesn't work so disable
+    //b->pins[pos].gpio.pinmap = 396;
+    //b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "UART1RX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 1 };
+    //b->pins[pos].gpio.pinmap = 471;
+    //b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S4SDI", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    // doesnt work
+    //b->pins[pos].gpio.pinmap = 395;
+    //b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "PWM0", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 463;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].pwm.pinmap = 0;
+    b->pins[pos].pwm.parent_id = 0;
+    b->pins[pos].pwm.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S4BLK", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    // this pin has a voltage of 0.34V in 'low' mode - beware!
+    b->pins[pos].gpio.pinmap = 397;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "PWM1", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 464;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].pwm.pinmap = 1;
+    b->pins[pos].pwm.parent_id = 0;
+    b->pins[pos].pwm.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S4WS", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    // not working
+    //b->pins[pos].gpio.pinmap = 398;
+    //b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "PWM2", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 465;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].pwm.pinmap = 2;
+    b->pins[pos].pwm.parent_id = 0;
+    b->pins[pos].pwm.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S3SDO", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    //b->pins[pos].gpio.pinmap = 400;
+    //b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "PWM3", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 466;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].pwm.pinmap = 3;
+    b->pins[pos].pwm.parent_id = 0;
+    b->pins[pos].pwm.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S3SDI", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    //b->pins[pos].gpio.pinmap = 399;
+    //b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "1.8V", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2S4BLK", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 393;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "GND", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "GND", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "GND", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "GND", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "3.3V", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    // second header
+    strncpy(b->pins[pos].name, "GND", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "5V", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "GND", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "5V", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "GND", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "3.3V", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "GND", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "3.3V", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "GND", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "1.8V", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "GPIO", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 456;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "1.8V", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "PANEL", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 270;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "GND", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "PANEL", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 271;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "CAMERA", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "PANEL", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 272;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "CAMERA", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPP0FS0", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 411;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "CAMERA", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPP0FS1", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 412;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPI_DAT", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 1, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 385;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPP0FS2", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 411;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPICLKB", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 384;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPP0FS3", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 410;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPICLKA", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 1, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 383;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPP0TX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 414;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "UART0RX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[pos].gpio.pinmap = 467;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "SPP0RX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 415;
+    b->pins[pos].gpio.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "UART0RT", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[pos].gpio.pinmap = 469;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2C1SDA", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].gpio.pinmap = 317;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    b->pins[pos].i2c.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "UART0CT", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[pos].gpio.pinmap = 412;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2C1SCL", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].gpio.pinmap = 318;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    b->pins[pos].i2c.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "UART1TX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[pos].gpio.pinmap = 484;
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2C2SDA", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].gpio.pinmap = 319;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    b->pins[pos].i2c.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "UART1RX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[pos].gpio.pinmap = 483;
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "I2C1SCL", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 1, 0, 0 };
+    b->pins[pos].gpio.pinmap = 320;
+    b->pins[pos].gpio.mux_total = 0;
+    b->pins[pos].i2c.pinmap = 0;
+    b->pins[pos].i2c.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "UART1RT", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[pos].gpio.pinmap = 485;
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "RTC_CLK", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 367;
+    pos++;
+
+    strncpy(b->pins[pos].name, "UART1CT", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 1 };
+    b->pins[pos].gpio.pinmap = 486;
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
+    while (pos != 100) {
+        b->pins[pos].capabilities = (mraa_pincapabilities_t){ 0, 0, 0, 0, 0, 0, 0, 0 };
+        pos++;
+    }
+
+    strncpy(b->pins[pos].name, "LED100", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 337;
+    pos++;
+
+    strncpy(b->pins[pos].name, "LED101", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    // if BIOS is pre-L then this is 338
+    b->pins[pos].gpio.pinmap = 395;
+    pos++;
+
+    strncpy(b->pins[pos].name, "LED102", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 339;
+    pos++;
+
+    strncpy(b->pins[pos].name, "LED103", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 340;
+    pos++;
+
+    strncpy(b->pins[pos].name, "LEDWIFI", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 438;
+    pos++;
+
+    strncpy(b->pins[pos].name, "LEDBT", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
+    b->pins[pos].gpio.pinmap = 439;
+    pos++;
+
+    return b;
+
+error:
+    syslog(LOG_CRIT, "GT Tuchuck: Platform failed to initialise");
+    free(b);
+    return NULL;
+}

src/x86/intel_minnow_byt_compatible.c

@@ -45,7 +45,7 @@ mraa_set_pininfo(mraa_board_t* board, int mraa_index, char* name, mraa_pincapabi
         // adjust mraa_index for ARCH_NR_GPIOS value
         mraa_pininfo_t* pin_info = &board->pins[mraa_index];
         strncpy(pin_info->name, name, MAX_LENGTH);
-        pin_info->capabilites = caps;
+        pin_info->capabilities = caps;
         if (caps.gpio) {
             pin_info->gpio.pinmap = sysfs_pin | arch_nr_gpios_adjust;
             pin_info->gpio.mux_total = 0;

src/x86/intel_nuc5.c

@@ -58,63 +58,63 @@ mraa_intel_nuc5()
     }
 
     strncpy(b->pins[0].name, "1.8v", 8);
-    b->pins[0].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[0].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[1].name, "GND", 8);
-    b->pins[1].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[1].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[2].name, "HDMIcec", 8);
-    b->pins[2].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[2].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[3].name, "DMICclk", 8);
-    b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[4].name, "3.3v", 8);
-    b->pins[4].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[5].name, "DMICda", 8);
-    b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[6].name, "Key", 8);
-    b->pins[6].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[7].name, "SMB-A", 8);
-    b->pins[7].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[7].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[8].name, "5v", 8);
-    b->pins[8].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[8].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[9].name, "SCI", 8);
-    b->pins[9].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[9].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     strncpy(b->pins[10].name, "PWM0", 8);
-    b->pins[10].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[10].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     b->pins[10].pwm.pinmap = 0;
     b->pins[10].pwm.parent_id = 0;
     b->pins[10].pwm.mux_total = 0;
 
     strncpy(b->pins[11].name, "PWM1", 8);
-    b->pins[11].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[11].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     b->pins[11].pwm.pinmap = 0;
     b->pins[11].pwm.parent_id = 1;
     b->pins[11].pwm.mux_total = 0;
 
     strncpy(b->pins[12].name, "I2C0SCL", 8);
-    b->pins[12].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[12].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[12].i2c.pinmap = 1;
     b->pins[12].i2c.mux_total = 0;
 
     strncpy(b->pins[13].name, "I2C0SDA", 8);
-    b->pins[13].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[13].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[13].i2c.pinmap = 1;
     b->pins[13].i2c.mux_total = 0;
 
     strncpy(b->pins[14].name, "I2C1SCL", 8);
-    b->pins[14].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[14].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[14].i2c.pinmap = 1;
     b->pins[14].i2c.mux_total = 0;
 
     strncpy(b->pins[15].name, "I2C1SDA", 8);
-    b->pins[15].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[15].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[15].i2c.pinmap = 1;
     b->pins[15].i2c.mux_total = 0;
 
     strncpy(b->pins[16].name, "SMB_CLK", 8);
-    b->pins[16].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[16].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
     strncpy(b->pins[17].name, "SMB_SDA", 8);
-    b->pins[17].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
+    b->pins[17].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 0 };
 
     b->i2c_bus_count = 0;
     int i2c_num = -1;
@@ -126,8 +126,8 @@ mraa_intel_nuc5()
         }
         b->i2c_bus_count++;
         b->i2c_bus[i].bus_id = i2c_num;
-        b->i2c_bus[i].sda = 12 + i;
-        b->i2c_bus[i].scl = 13 + i;
+        b->i2c_bus[i].sda = 12 + (i*2);
+        b->i2c_bus[i].scl = 13 + (i*2);
     }
 
     if (b->i2c_bus_count > 0) {

src/x86/intel_sofia_3gr.c

@@ -56,42 +56,42 @@ mraa_intel_sofia_3gr()
     }
 
     strncpy(b->pins[0].name, "I2C1SCL", 8);
-    b->pins[0].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[0].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[0].i2c.pinmap = 1;
     b->pins[0].i2c.mux_total = 0;
 
     strncpy(b->pins[1].name, "I2C1SDA", 8);
-    b->pins[1].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[1].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[1].i2c.pinmap = 1;
     b->pins[1].i2c.mux_total = 0;
 
     strncpy(b->pins[2].name, "I2C2SCL", 8);
-    b->pins[2].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[2].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[2].i2c.pinmap = 1;
     b->pins[2].i2c.mux_total = 0;
 
     strncpy(b->pins[3].name, "I2C2SDA", 8);
-    b->pins[3].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[3].i2c.pinmap = 1;
     b->pins[3].i2c.mux_total = 0;
 
     strncpy(b->pins[4].name, "I2C3SCL", 8);
-    b->pins[4].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[4].i2c.pinmap = 1;
     b->pins[4].i2c.mux_total = 0;
 
     strncpy(b->pins[5].name, "I2C3SDA", 8);
-    b->pins[5].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[5].i2c.pinmap = 1;
     b->pins[5].i2c.mux_total = 0;
 
     strncpy(b->pins[6].name, "I2C4SCL", 8);
-    b->pins[6].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[6].i2c.pinmap = 1;
     b->pins[6].i2c.mux_total = 0;
 
     strncpy(b->pins[7].name, "I2C4SDA", 8);
-    b->pins[7].capabilites = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
+    b->pins[7].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 };
     b->pins[7].i2c.pinmap = 1;
     b->pins[7].i2c.mux_total = 0;
 

src/x86/up.c

@@ -42,7 +42,7 @@ set_pininfo(mraa_board_t* board, int mraa_index, char* name, mraa_pincapabilitie
     if (mraa_index < board->phy_pin_count) {
         mraa_pininfo_t* pin_info = &board->pins[mraa_index];
         strncpy(pin_info->name, name, MAX_LENGTH);
-        pin_info->capabilites = caps;
+        pin_info->capabilities = caps;
         if (caps.gpio) {
             pin_info->gpio.pinmap = sysfs_pin;
             pin_info->gpio.mux_total = 0;

src/x86/x86.c

@@ -37,6 +37,7 @@
 #include "x86/intel_sofia_3gr.h"
 #include "x86/intel_cherryhills.h"
 #include "x86/up.h"
+#include "x86/intel_gt_tuchuck.h"
 
 mraa_platform_t
 mraa_x86_platform()
@@ -86,6 +87,12 @@ mraa_x86_platform()
             } else if (strncasecmp(line, "UP-CHT01", 8) == 0) {
                 platform_type = MRAA_UP;
                 plat = mraa_up_board();
+            } else if (strncasecmp(line, "RVP", 3) == 0) {
+                platform_type = MRAA_INTEL_GT_TUCHUCK;
+                plat = mraa_gt_tuchuck_board();
+            } else if (strncasecmp(line, "SDS", 3) == 0) {
+                platform_type = MRAA_INTEL_GT_TUCHUCK;
+                plat = mraa_gt_tuchuck_board();
             } else {
                 syslog(LOG_ERR, "Platform not supported, not initialising");
                 platform_type = MRAA_UNKNOWN_PLATFORM;
@@ -126,6 +133,8 @@ mraa_x86_platform()
     plat = mraa_intel_cherryhills();
     #elif defined(xMRAA_UP)
     plat = mraa_up_board();
+    #elif defined(xMRAA_INTEL_GT_TUCHUCK)
+    plat = mraa_gt_tuchuck_board();
     #else
         #error "Not using a valid platform value from mraa_platform_t - cannot compile"
     #endif

tests/CMakeLists.txt

@@ -9,12 +9,21 @@ if (BUILDSWIGJAVA)
 endif()
 
 if (BUILDSWIGPYTHON)
-    add_test (NAME py_general COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/general_checks.py)
-    set_tests_properties(py_general PROPERTIES ENVIRONMENT "PYTHONPATH=${CMAKE_BINARY_DIR}/src/python/")
+    if (PYTHON2INTERP_FOUND)
+        set (PYTHON_DEFAULT_PYTHONPATH "${CMAKE_BINARY_DIR}/src/python/python2")
+    elseif (PYTHON3INTERP_FOUND)
+        set (PYTHON_DEFAULT_PYTHONPATH "${CMAKE_BINARY_DIR}/src/python/python3")
+    endif ()
+    if (MOCKPLAT)
+        add_subdirectory (mock)
+    else()
+        add_test (NAME py_general COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/general_checks.py)
+        set_tests_properties(py_general PROPERTIES ENVIRONMENT "PYTHONPATH=${PYTHON_DEFAULT_PYTHONPATH}")
 
-    add_test (NAME py_platform COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/platform_checks.py)
-    set_tests_properties(py_platform PROPERTIES ENVIRONMENT "PYTHONPATH=${CMAKE_BINARY_DIR}/src/python/")
+        add_test (NAME py_platform COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/platform_checks.py)
+        set_tests_properties(py_platform PROPERTIES ENVIRONMENT "PYTHONPATH=${PYTHON_DEFAULT_PYTHONPATH}")
 
-    add_test (NAME py_gpio COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/gpio_checks.py)
-    set_tests_properties(py_gpio PROPERTIES ENVIRONMENT "PYTHONPATH=${CMAKE_BINARY_DIR}/src/python/")
+        add_test (NAME py_gpio COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/gpio_checks.py)
+        set_tests_properties(py_gpio PROPERTIES ENVIRONMENT "PYTHONPATH=${PYTHON_DEFAULT_PYTHONPATH}")
+    endif()
 endif()

tests/mock/CMakeLists.txt

@@ -0,0 +1,45 @@
+# Mock platform tests
+add_test (NAME py_general COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/general_checks.py)
+add_test (NAME py_platform COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/platform_checks.py)
+add_test (NAME py_gpio_basic COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/gpio_checks_basic.py)
+add_test (NAME py_gpio_dir COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/gpio_checks_dir.py)
+add_test (NAME py_gpio_write_read COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/gpio_checks_write_read.py)
+add_test (NAME py_gpio_edge COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/gpio_checks_edge.py)
+add_test (NAME py_gpio_isr COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/gpio_checks_isr.py)
+add_test (NAME py_gpio_mode COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/gpio_checks_mode.py)
+
+add_test (NAME py_aio COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/aio_checks.py)
+
+add_test (NAME py_i2c_freq COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/i2c_checks_freq.py)
+add_test (NAME py_i2c_addr COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/i2c_checks_addr.py)
+add_test (NAME py_i2c_read COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/i2c_checks_read.py)
+add_test (NAME py_i2c_write COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/i2c_checks_write.py)
+add_test (NAME py_i2c_read_byte COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/i2c_checks_read_byte.py)
+add_test (NAME py_i2c_write_byte COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/i2c_checks_write_byte.py)
+add_test (NAME py_i2c_read_byte_data COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/i2c_checks_read_byte_data.py)
+add_test (NAME py_i2c_write_byte_data COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/i2c_checks_write_byte_data.py)
+add_test (NAME py_i2c_read_bytes_data COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/i2c_checks_read_bytes_data.py)
+add_test (NAME py_i2c_read_word_data COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/i2c_checks_read_word_data.py)
+add_test (NAME py_i2c_write_word_data COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/i2c_checks_write_word_data.py)
+
+set_tests_properties(py_general
+                     py_platform
+                     py_gpio_basic
+                     py_gpio_dir
+                     py_gpio_write_read
+                     py_gpio_edge
+                     py_gpio_isr
+                     py_gpio_mode
+                     py_aio
+                     py_i2c_freq
+                     py_i2c_addr
+                     py_i2c_read
+                     py_i2c_write
+                     py_i2c_read_byte
+                     py_i2c_write_byte
+                     py_i2c_read_byte_data
+                     py_i2c_write_byte_data
+                     py_i2c_read_bytes_data
+                     py_i2c_read_word_data
+                     py_i2c_write_word_data
+                     PROPERTIES ENVIRONMENT "PYTHONPATH=${PYTHON_DEFAULT_PYTHONPATH}")

tests/mock/aio_checks.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+
+# Author: Alex Tereschenko <alext.mkrs@gmail.com>
+# Copyright (c) 2016 Alex Tereschenko.
+#
+# 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.
+
+import mraa as m
+import unittest as u
+
+MRAA_AIO_TEST_PIN = 0
+PLATFORM_STD_ADC_RES_BITS = 10
+PLATFORM_MAX_ADC_RES_BITS = 12
+
+class AioChecks(u.TestCase):
+  def setUp(self):
+    self.pin = m.Aio(MRAA_AIO_TEST_PIN)
+
+  def tearDown(self):
+    del self.pin
+
+  def test_aio_get_bit(self):
+    self.assertEqual(self.pin.getBit(), PLATFORM_STD_ADC_RES_BITS, "Wrong ADC resolution reported")
+
+  def test_aio_set_bit(self):
+    self.pin.setBit(PLATFORM_MAX_ADC_RES_BITS)
+    self.assertEqual(self.pin.getBit(), PLATFORM_MAX_ADC_RES_BITS, "Wrong ADC resolution reported after setBit()")
+
+  def test_aio_read(self):
+    self.assertNotEqual(self.pin.read(), -1, "Error returned when reading ADC value")
+
+  def test_aio_read_float_std_res(self):
+    self.pin.setBit(PLATFORM_STD_ADC_RES_BITS)
+    self.assertNotEqual(self.pin.readFloat(), -1, "Error returned when reading float ADC value at standard resolution")
+
+  def test_aio_read_float_max_res(self):
+    self.pin.setBit(PLATFORM_MAX_ADC_RES_BITS)
+    self.assertNotEqual(self.pin.readFloat(), -1, "Error returned when reading float ADC value at maximum resolution")
+
+if __name__ == "__main__":
+  u.main()

tests/mock/general_checks.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+
+# Author: Costin Constantin <costin.c.constantin@intel.com>
+# Copyright (c) 2015 Intel Corporation.
+#
+# Contributors: Alex Tereschenko <alext.mkrs@gmail.com>
+#
+# 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.
+
+import mraa as m
+import unittest as u
+
+class GeneralChecks(u.TestCase):
+  def test_mraa_version(self):
+    version = m.getVersion()
+    print("Version is: " + version)
+    self.assertIsNotNone(version)
+    self.assertNotEqual(version, "", "MRAA version is an empty string")
+
+if __name__ == "__main__":
+  u.main()