src/gpio/gpio.c

   1 /*
   2  * Author: Thomas Ingleby <thomas.c.ingleby@intel.com>
   3  * Author: Brendan Le Foll <brendan.le.foll@intel.com>
   4  * Copyright (c) 2014, 2015 Intel Corporation.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sublicense, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be
  15  * included in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25 #include "gpio.h"
  26 #include "mraa_internal.h"
  27
  28 #include <stdlib.h>
  29 #include <fcntl.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32 #include <poll.h>
  33 #include <pthread.h>
  34 #include <signal.h>
  35 #include <sys/stat.h>
  36 #include <sys/mman.h>
  37
  38 #define SYSFS_CLASS_GPIO "/sys/class/gpio"
  39 #define MAX_SIZE 64
  40 #define POLL_TIMEOUT
  41
  42 static mraa_result_t
  43 mraa_gpio_get_valfp(mraa_gpio_context dev)
  44 {
  45     char bu[MAX_SIZE];
  46     sprintf(bu, SYSFS_CLASS_GPIO "/gpio%d/value", dev->pin);
  47     dev->value_fp = open(bu, O_RDWR);
  48     if (dev->value_fp == -1) {
  49         return MRAA_ERROR_INVALID_RESOURCE;
  50     }
  51
  52     return MRAA_SUCCESS;
  53 }
  54
  55 static mraa_gpio_context
  56 mraa_gpio_init_internal(mraa_adv_func_t* func_table, int pin)
  57 {
  58     if (pin < 0)
  59         return NULL;
  60
  61     mraa_result_t status = MRAA_SUCCESS;
  62     char bu[MAX_SIZE];
  63     int length;
  64
  65     mraa_gpio_context dev = (mraa_gpio_context) calloc(1, sizeof(struct _gpio));
  66     if (dev == NULL) {
  67         syslog(LOG_CRIT, "gpio: Failed to allocate memory for context");
  68         return NULL;
  69     }
  70
  71     dev->advance_func = func_table;
  72     dev->pin = pin;
  73
  74     if (IS_FUNC_DEFINED(dev, gpio_init_internal_replace)) {
  75         status = dev->advance_func->gpio_init_internal_replace(pin);
  76         if (status == MRAA_SUCCESS)
  77             return dev;
  78         else
  79             goto init_internal_cleanup;
  80     }
  81
  82     if (IS_FUNC_DEFINED(dev, gpio_init_pre)) {
  83         status = dev->advance_func->gpio_init_pre(pin);
  84         if (status != MRAA_SUCCESS)
  85             goto init_internal_cleanup;
  86     }
  87
  88     dev->value_fp = -1;
  89     dev->isr_value_fp = -1;
  90 #ifndef HAVE_PTHREAD_CANCEL
  91     dev->isr_control_pipe[0] = dev->isr_control_pipe[1] = -1;
  92 #endif
  93     dev->isr_thread_terminating = 0;
  94     dev->phy_pin = -1;
  95
  96     // then check to make sure the pin is exported.
  97     char directory[MAX_SIZE];
  98     snprintf(directory, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/", dev->pin);
  99     struct stat dir;
 100     if (stat(directory, &dir) == 0 && S_ISDIR(dir.st_mode)) {
 101         dev->owner = 0; // Not Owner
 102     } else {
 103         int export = open(SYSFS_CLASS_GPIO "/export", O_WRONLY);
 104         if (export == -1) {
 105             syslog(LOG_ERR, "gpio: Failed to open export for writing");
 106             status = MRAA_ERROR_NO_RESOURCES;
 107             goto init_internal_cleanup;
 108         }
 109         length = snprintf(bu, sizeof(bu), "%d", dev->pin);
 110         if (write(export, bu, length * sizeof(char)) == -1) {
 111             syslog(LOG_ERR, "gpio: Failed to write %d to export", dev->pin);
 112             close(export);
 113             status = MRAA_ERROR_NO_RESOURCES;
 114             goto init_internal_cleanup;
 115         }
 116         dev->owner = 1;
 117         close(export);
 118     }
 119
 120 init_internal_cleanup:
 121     if (status != MRAA_SUCCESS) {
 122         if (dev != NULL)
 123             free(dev);
 124         return NULL;
 125     }
 126     return dev;
 127 }
 128
 129 mraa_gpio_context
 130 mraa_gpio_init(int pin)
 131 {
 132     mraa_board_t* board = plat;
 133     if (board == NULL) {
 134         syslog(LOG_ERR, "gpio: platform not initialised");
 135         return NULL;
 136     }
 137
 138     if (mraa_is_sub_platform_id(pin)) {
 139         syslog(LOG_NOTICE, "gpio: Using sub platform");
 140         board = board->sub_platform;
 141         if (board == NULL) {
 142             syslog(LOG_ERR, "gpio: Sub platform Not Initialised");
 143             return NULL;
 144         }
 145         pin = mraa_get_sub_platform_index(pin);
 146     }
 147
 148     if (pin < 0 || pin > board->phy_pin_count) {
 149         syslog(LOG_ERR, "gpio: pin %i beyond platform definition", pin);
 150         return NULL;
 151     }
 152     if (board->pins[pin].capabilites.gpio != 1) {
 153         syslog(LOG_ERR, "gpio: pin %i not capable of gpio", pin);
 154         return NULL;
 155     }
 156     if (board->pins[pin].gpio.mux_total > 0) {
 157         if (mraa_setup_mux_mapped(board->pins[pin].gpio) != MRAA_SUCCESS) {
 158             syslog(LOG_ERR, "gpio: unable to setup muxes");
 159             return NULL;
 160         }
 161     }
 162
 163     mraa_gpio_context r = mraa_gpio_init_internal(board->adv_func, board->pins[pin].gpio.pinmap);
 164     if (r == NULL) {
 165         syslog(LOG_CRIT, "gpio: mraa_gpio_init_raw(%d) returned error", pin);
 166         return NULL;
 167     }
 168     r->phy_pin = pin;
 169
 170     if (IS_FUNC_DEFINED(r, gpio_init_post)) {
 171         mraa_result_t ret = r->advance_func->gpio_init_post(r);
 172         if (ret != MRAA_SUCCESS) {
 173             free(r);
 174             return NULL;
 175         }
 176     }
 177     return r;
 178 }
 179
 180 mraa_gpio_context
 181 mraa_gpio_init_raw(int pin)
 182 {
 183     return mraa_gpio_init_internal(plat == NULL ? NULL : plat->adv_func , pin);
 184 }
 185
 186
 187 static mraa_result_t
 188 mraa_gpio_wait_interrupt(int fd
 189 #ifndef HAVE_PTHREAD_CANCEL
 190         , int control_fd
 191 #endif
 192         )
 193 {
 194     unsigned char c;
 195 #ifdef HAVE_PTHREAD_CANCEL
 196     struct pollfd pfd[1];
 197 #else
 198     struct pollfd pfd[2];
 199
 200     if (control_fd < 0) {
 201         return MRAA_ERROR_INVALID_RESOURCE;
 202     }
 203 #endif
 204
 205     if (fd < 0) {
 206         return MRAA_ERROR_INVALID_RESOURCE;
 207     }
 208
 209     // setup poll on POLLPRI
 210     pfd[0].fd = fd;
 211     pfd[0].events = POLLPRI;
 212
 213     // do an initial read to clear interrupt
 214     lseek(fd, 0, SEEK_SET);
 215     read(fd, &c, 1);
 216
 217 #ifdef HAVE_PTHREAD_CANCEL
 218     // Wait for it forever or until pthread_cancel
 219     // poll is a cancelable point like sleep()
 220     int x = poll(pfd, 1, -1);
 221 #else
 222     // setup poll on the controling fd
 223     pfd[1].fd = control_fd;
 224     pfd[1].events = 0; //  POLLHUP, POLLERR, and POLLNVAL
 225
 226     // Wait for it forever or until control fd is closed
 227     int x = poll(pfd, 2, -1);
 228 #endif
 229
 230     // do a final read to clear interrupt
 231     read(fd, &c, 1);
 232
 233     return MRAA_SUCCESS;
 234 }
 235
 236 static void*
 237 mraa_gpio_interrupt_handler(void* arg)
 238 {
 239     mraa_gpio_context dev = (mraa_gpio_context) arg;
 240     if (IS_FUNC_DEFINED(dev, gpio_interrupt_handler_replace))
 241         return dev->advance_func->gpio_interrupt_handler_replace(dev);
 242
 243     mraa_result_t ret;
 244
 245     // open gpio value with open(3)
 246     char bu[MAX_SIZE];
 247     sprintf(bu, SYSFS_CLASS_GPIO "/gpio%d/value", dev->pin);
 248     int fp = open(bu, O_RDONLY);
 249     if (fp < 0) {
 250         syslog(LOG_ERR, "gpio: failed to open gpio%d/value", dev->pin);
 251         return NULL;
 252     }
 253
 254 #ifndef HAVE_PTHREAD_CANCEL
 255     if (pipe(dev->isr_control_pipe)) {
 256         syslog(LOG_ERR, "gpio: failed to create isr control pipe");
 257         close(fp);
 258         return NULL;
 259     }
 260 #endif
 261
 262     dev->isr_value_fp = fp;
 263
 264     for (;;) {
 265         ret = mraa_gpio_wait_interrupt(dev->isr_value_fp
 266 #ifndef HAVE_PTHREAD_CANCEL
 267                 , dev->isr_control_pipe[0]
 268 #endif
 269                 );
 270         if (ret == MRAA_SUCCESS && !dev->isr_thread_terminating) {
 271 #ifdef HAVE_PTHREAD_CANCEL
 272             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 273 #endif
 274 #ifdef SWIGPYTHON
 275             // In order to call a python object (all python functions are objects) we
 276             // need to aquire the GIL (Global Interpreter Lock). This may not always be
 277             // necessary but especially if doing IO (like print()) python will segfault
 278             // if we do not hold a lock on the GIL
 279             PyGILState_STATE gilstate = PyGILState_Ensure();
 280             PyObject* arglist;
 281             PyObject* ret;
 282             arglist = Py_BuildValue("(O)", dev->isr_args);
 283             if (arglist == NULL) {
 284                 syslog(LOG_ERR, "gpio: Py_BuildValue NULL");
 285             } else {
 286                 ret = PyEval_CallObject((PyObject*) dev->isr, arglist);
 287                 if (ret == NULL) {
 288                     syslog(LOG_ERR, "gpio: PyEval_CallObject failed");
 289                     PyObject *pvalue, *ptype, *ptraceback;
 290                     PyObject *pvalue_pystr, *ptype_pystr, *ptraceback_pystr;
 291                     char *pvalue_cstr, *ptype_cstr, *ptraceback_cstr;
 292                     PyErr_Fetch(&pvalue, &ptype, &ptraceback);
 293                     pvalue_pystr = PyObject_Str(pvalue);
 294                     ptype_pystr = PyObject_Str(ptype);
 295                     ptraceback_pystr = PyObject_Str(ptraceback);
 296 // Python2
 297 #if PY_VERSION_HEX < 0x03000000
 298                     pvalue_cstr = PyString_AsString(pvalue_pystr);
 299                     ptype_cstr = PyString_AsString(ptype_pystr);
 300                     ptraceback_cstr = PyString_AsString(ptraceback_pystr);
 301 // Python 3 and up
 302 #elif PY_VERSION_HEX >= 0x03000000
 303                     // In Python 3 we need one extra conversion
 304                     PyObject *pvalue_ustr, *ptype_ustr, *ptraceback_ustr;
 305                     pvalue_ustr = PyUnicode_AsUTF8String(pvalue_pystr);
 306                     pvalue_cstr = PyBytes_AsString(pvalue_ustr);
 307                     ptype_ustr = PyUnicode_AsUTF8String(ptype_pystr);
 308                     ptype_cstr = PyBytes_AsString(ptype_ustr);
 309                     ptraceback_ustr = PyUnicode_AsUTF8String(ptraceback_pystr);
 310                     ptraceback_cstr = PyBytes_AsString(ptraceback_ustr);
 311 #endif // PY_VERSION_HEX
 312                     syslog(LOG_ERR, "gpio: the error was %s:%s:%s",
 313                            pvalue_cstr,
 314                            ptype_cstr,
 315                            ptraceback_cstr
 316                     );
 317                     Py_XDECREF(pvalue);
 318                     Py_XDECREF(ptype);
 319                     Py_XDECREF(ptraceback);
 320                     Py_XDECREF(pvalue_pystr);
 321                     Py_XDECREF(ptype_pystr);
 322                     Py_XDECREF(ptraceback_pystr);
 323 // Python 3 and up
 324 #if PY_VERSION_HEX >= 0x03000000
 325                     Py_XDECREF(pvalue_ustr);
 326                     Py_XDECREF(ptype_ustr);
 327                     Py_XDECREF(ptraceback_ustr);
 328 #endif // PY_VERSION_HEX
 329                 } else {
 330                     Py_DECREF(ret);
 331                 }
 332                 Py_DECREF(arglist);
 333             }
 334
 335             PyGILState_Release(gilstate);
 336 #else
 337             dev->isr(dev->isr_args);
 338 #endif
 339 #ifdef HAVE_PTHREAD_CANCEL
 340             pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 341 #endif
 342         } else {
 343             // we must have got an error code or exit request so die nicely
 344 #ifdef HAVE_PTHREAD_CANCEL
 345             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 346 #endif
 347             close(dev->isr_value_fp);
 348             dev->isr_value_fp = -1;
 349             return NULL;
 350         }
 351     }
 352 }
 353
 354 mraa_result_t
 355 mraa_gpio_edge_mode(mraa_gpio_context dev, mraa_gpio_edge_t mode)
 356 {
 357     if (IS_FUNC_DEFINED(dev, gpio_edge_mode_replace))
 358         return dev->advance_func->gpio_edge_mode_replace(dev, mode);
 359
 360     if (dev->value_fp != -1) {
 361         close(dev->value_fp);
 362         dev->value_fp = -1;
 363     }
 364
 365     char filepath[MAX_SIZE];
 366     snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/edge", dev->pin);
 367
 368     int edge = open(filepath, O_RDWR);
 369     if (edge == -1) {
 370         syslog(LOG_ERR, "gpio: Failed to open edge for writing");
 371         return MRAA_ERROR_INVALID_RESOURCE;
 372     }
 373
 374     char bu[MAX_SIZE];
 375     int length;
 376     switch (mode) {
 377         case MRAA_GPIO_EDGE_NONE:
 378             length = snprintf(bu, sizeof(bu), "none");
 379             break;
 380         case MRAA_GPIO_EDGE_BOTH:
 381             length = snprintf(bu, sizeof(bu), "both");
 382             break;
 383         case MRAA_GPIO_EDGE_RISING:
 384             length = snprintf(bu, sizeof(bu), "rising");
 385             break;
 386         case MRAA_GPIO_EDGE_FALLING:
 387             length = snprintf(bu, sizeof(bu), "falling");
 388             break;
 389         default:
 390             close(edge);
 391             return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
 392     }
 393     if (write(edge, bu, length * sizeof(char)) == -1) {
 394         syslog(LOG_ERR, "gpio: Failed to write to edge");
 395         close(edge);
 396         return MRAA_ERROR_INVALID_RESOURCE;
 397     }
 398
 399     close(edge);
 400     return MRAA_SUCCESS;
 401 }
 402
 403 mraa_result_t
 404 mraa_gpio_isr(mraa_gpio_context dev, mraa_gpio_edge_t mode, void (*fptr)(void*), void* args)
 405 {
 406     // we only allow one isr per mraa_gpio_context
 407     if (dev->thread_id != 0) {
 408         return MRAA_ERROR_NO_RESOURCES;
 409     }
 410
 411     if (MRAA_SUCCESS != mraa_gpio_edge_mode(dev, mode)) {
 412         return MRAA_ERROR_UNSPECIFIED;
 413     }
 414
 415     dev->isr = fptr;
 416     dev->isr_args = args;
 417     pthread_create(&dev->thread_id, NULL, mraa_gpio_interrupt_handler, (void*) dev);
 418
 419     return MRAA_SUCCESS;
 420 }
 421
 422 mraa_result_t
 423 mraa_gpio_isr_exit(mraa_gpio_context dev)
 424 {
 425     mraa_result_t ret = MRAA_SUCCESS;
 426
 427     // wasting our time, there is no isr to exit from
 428     if (dev->thread_id == 0 && dev->isr_value_fp == -1) {
 429         return ret;
 430     }
 431     // mark the beginning of the thread termination process for interested parties
 432     dev->isr_thread_terminating = 1;
 433
 434     // stop isr being useful
 435     ret = mraa_gpio_edge_mode(dev, MRAA_GPIO_EDGE_NONE);
 436
 437     if ((dev->thread_id != 0)) {
 438 #ifdef HAVE_PTHREAD_CANCEL
 439         if ((pthread_cancel(dev->thread_id) != 0) || (pthread_join(dev->thread_id, NULL) != 0)) {
 440             ret = MRAA_ERROR_INVALID_HANDLE;
 441         }
 442 #else
 443         close(dev->isr_control_pipe[1]);
 444         if (pthread_join(dev->thread_id, NULL) != 0)
 445             ret = MRAA_ERROR_INVALID_HANDLE;
 446
 447         close(dev->isr_control_pipe[0]);
 448         dev->isr_control_pipe[0] =  dev->isr_control_pipe[1] = -1;
 449 #endif
 450     }
 451
 452     // close the filehandle in case it's still open
 453     if (dev->isr_value_fp != -1) {
 454         if (close(dev->isr_value_fp) != 0) {
 455             ret = MRAA_ERROR_INVALID_PARAMETER;
 456         }
 457     }
 458
 459     // assume our thread will exit either way we just lost it's handle
 460     dev->thread_id = 0;
 461     dev->isr_value_fp = -1;
 462     dev->isr_thread_terminating = 0;
 463     return ret;
 464 }
 465
 466 mraa_result_t
 467 mraa_gpio_mode(mraa_gpio_context dev, mraa_gpio_mode_t mode)
 468 {
 469     if (IS_FUNC_DEFINED(dev, gpio_mode_replace))
 470         return dev->advance_func->gpio_mode_replace(dev, mode);
 471
 472     if (IS_FUNC_DEFINED(dev, gpio_mode_pre)) {
 473         mraa_result_t pre_ret = (dev->advance_func->gpio_mode_pre(dev, mode));
 474         if (pre_ret != MRAA_SUCCESS)
 475             return pre_ret;
 476     }
 477
 478     if (dev->value_fp != -1) {
 479         close(dev->value_fp);
 480         dev->value_fp = -1;
 481     }
 482
 483     char filepath[MAX_SIZE];
 484     snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/drive", dev->pin);
 485
 486     int drive = open(filepath, O_WRONLY);
 487     if (drive == -1) {
 488         syslog(LOG_ERR, "gpio: Failed to open drive for writing");
 489         return MRAA_ERROR_INVALID_RESOURCE;
 490     }
 491
 492     char bu[MAX_SIZE];
 493     int length;
 494     switch (mode) {
 495         case MRAA_GPIO_STRONG:
 496             length = snprintf(bu, sizeof(bu), "strong");
 497             break;
 498         case MRAA_GPIO_PULLUP:
 499             length = snprintf(bu, sizeof(bu), "pullup");
 500             break;
 501         case MRAA_GPIO_PULLDOWN:
 502             length = snprintf(bu, sizeof(bu), "pulldown");
 503             break;
 504         case MRAA_GPIO_HIZ:
 505             length = snprintf(bu, sizeof(bu), "hiz");
 506             break;
 507         default:
 508             close(drive);
 509             return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
 510     }
 511     if (write(drive, bu, length * sizeof(char)) == -1) {
 512         syslog(LOG_ERR, "gpio: Failed to write to drive mode");
 513         close(drive);
 514         return MRAA_ERROR_INVALID_RESOURCE;
 515     }
 516
 517     close(drive);
 518     if (IS_FUNC_DEFINED(dev, gpio_mode_post))
 519         return dev->advance_func->gpio_mode_post(dev, mode);
 520     return MRAA_SUCCESS;
 521 }
 522
 523 mraa_result_t
 524 mraa_gpio_dir(mraa_gpio_context dev, mraa_gpio_dir_t dir)
 525 {
 526     if (IS_FUNC_DEFINED(dev, gpio_dir_replace)) {
 527         return dev->advance_func->gpio_dir_replace(dev, dir);
 528     }
 529
 530     if (IS_FUNC_DEFINED(dev, gpio_dir_pre)) {
 531         mraa_result_t pre_ret = (dev->advance_func->gpio_dir_pre(dev, dir));
 532         if (pre_ret != MRAA_SUCCESS) {
 533             return pre_ret;
 534         }
 535     }
 536
 537     if (dev == NULL) {
 538         return MRAA_ERROR_INVALID_HANDLE;
 539     }
 540     if (dev->value_fp != -1) {
 541         close(dev->value_fp);
 542         dev->value_fp = -1;
 543     }
 544     char filepath[MAX_SIZE];
 545     snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/direction", dev->pin);
 546
 547     int direction = open(filepath, O_RDWR);
 548
 549     if (direction == -1) {
 550         // Direction Failed to Open. If HIGH or LOW was passed will try and set
 551         // If not fail as usual.
 552         switch (dir) {
 553             case MRAA_GPIO_OUT_HIGH:
 554                 return mraa_gpio_write(dev, 1);
 555             case MRAA_GPIO_OUT_LOW:
 556                 return mraa_gpio_write(dev, 0);
 557             default:
 558                 return MRAA_ERROR_INVALID_RESOURCE;
 559         }
 560     }
 561
 562     char bu[MAX_SIZE];
 563     int length;
 564     switch (dir) {
 565         case MRAA_GPIO_OUT:
 566             length = snprintf(bu, sizeof(bu), "out");
 567             break;
 568         case MRAA_GPIO_IN:
 569             length = snprintf(bu, sizeof(bu), "in");
 570             break;
 571         case MRAA_GPIO_OUT_HIGH:
 572             length = snprintf(bu, sizeof(bu), "high");
 573             break;
 574         case MRAA_GPIO_OUT_LOW:
 575             length = snprintf(bu, sizeof(bu), "low");
 576             break;
 577         default:
 578             close(direction);
 579             return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
 580     }
 581
 582     if (write(direction, bu, length * sizeof(char)) == -1) {
 583         close(direction);
 584         return MRAA_ERROR_INVALID_RESOURCE;
 585     }
 586
 587     close(direction);
 588     if (IS_FUNC_DEFINED(dev, gpio_dir_post))
 589         return dev->advance_func->gpio_dir_post(dev, dir);
 590     return MRAA_SUCCESS;
 591 }
 592
 593 int
 594 mraa_gpio_read(mraa_gpio_context dev)
 595 {
 596     if (dev == NULL)
 597         return -1;
 598
 599     if (IS_FUNC_DEFINED(dev, gpio_read_replace))
 600         return dev->advance_func->gpio_read_replace(dev);
 601
 602     if (dev->mmap_read != NULL)
 603         return dev->mmap_read(dev);
 604
 605     if (dev->value_fp == -1) {
 606         if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
 607             syslog(LOG_ERR, "gpio: Failed to get value file pointer");
 608             return -1;
 609         }
 610     } else {
 611         // if value_fp is new this is pointless
 612         lseek(dev->value_fp, 0, SEEK_SET);
 613     }
 614     char bu[2];
 615     if (read(dev->value_fp, bu, 2 * sizeof(char)) != 2) {
 616         syslog(LOG_ERR, "gpio: Failed to read a sensible value from sysfs");
 617         return -1;
 618     }
 619     lseek(dev->value_fp, 0, SEEK_SET);
 620
 621     return (int) strtol(bu, NULL, 10);
 622 }
 623
 624 mraa_result_t
 625 mraa_gpio_write(mraa_gpio_context dev, int value)
 626 {
 627     if (dev == NULL)
 628         return MRAA_ERROR_INVALID_HANDLE;
 629
 630     if (dev->mmap_write != NULL)
 631         return dev->mmap_write(dev, value);
 632
 633     if (IS_FUNC_DEFINED(dev, gpio_write_pre)) {
 634         mraa_result_t pre_ret = (dev->advance_func->gpio_write_pre(dev, value));
 635         if (pre_ret != MRAA_SUCCESS)
 636             return pre_ret;
 637     }
 638
 639     if (IS_FUNC_DEFINED(dev, gpio_write_replace)) {
 640         return dev->advance_func->gpio_write_replace(dev, value);
 641     }
 642
 643     if (dev->value_fp == -1) {
 644         if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
 645             return MRAA_ERROR_INVALID_RESOURCE;
 646         }
 647     }
 648
 649     if (lseek(dev->value_fp, 0, SEEK_SET) == -1) {
 650         return MRAA_ERROR_INVALID_RESOURCE;
 651     }
 652
 653     char bu[MAX_SIZE];
 654     int length = snprintf(bu, sizeof(bu), "%d", value);
 655     if (write(dev->value_fp, bu, length * sizeof(char)) == -1) {
 656         return MRAA_ERROR_INVALID_HANDLE;
 657     }
 658
 659     if (IS_FUNC_DEFINED(dev, gpio_write_post))
 660         return dev->advance_func->gpio_write_post(dev, value);
 661     return MRAA_SUCCESS;
 662 }
 663
 664 static mraa_result_t
 665 mraa_gpio_unexport_force(mraa_gpio_context dev)
 666 {
 667     int unexport = open(SYSFS_CLASS_GPIO "/unexport", O_WRONLY);
 668     if (unexport == -1) {
 669         syslog(LOG_ERR, "gpio: Failed to open unexport for writing");
 670         return MRAA_ERROR_INVALID_RESOURCE;
 671     }
 672
 673     char bu[MAX_SIZE];
 674     int length = snprintf(bu, sizeof(bu), "%d", dev->pin);
 675     if (write(unexport, bu, length * sizeof(char)) == -1) {
 676         syslog(LOG_ERR, "gpio: Failed to write to unexport");
 677         close(unexport);
 678         return MRAA_ERROR_INVALID_RESOURCE;
 679     }
 680
 681     close(unexport);
 682     mraa_gpio_isr_exit(dev);
 683     return MRAA_SUCCESS;
 684 }
 685 static mraa_result_t
 686 mraa_gpio_unexport(mraa_gpio_context dev)
 687 {
 688     if (dev->owner) {
 689         return mraa_gpio_unexport_force(dev);
 690     }
 691     return MRAA_ERROR_INVALID_RESOURCE;
 692 }
 693
 694 mraa_result_t
 695 mraa_gpio_close(mraa_gpio_context dev)
 696 {
 697     mraa_result_t result = MRAA_SUCCESS;
 698
 699     if (IS_FUNC_DEFINED(dev, gpio_close_pre)) {
 700         result = dev->advance_func->gpio_close_pre(dev);
 701     }
 702
 703     if (dev->value_fp != -1) {
 704         close(dev->value_fp);
 705     }
 706     mraa_gpio_unexport(dev);
 707     free(dev);
 708     return result;
 709 }
 710
 711 mraa_result_t
 712 mraa_gpio_owner(mraa_gpio_context dev, mraa_boolean_t own)
 713 {
 714     if (dev == NULL) {
 715         return MRAA_ERROR_INVALID_RESOURCE;
 716     }
 717     syslog(LOG_DEBUG, "gpio: Set owner to %d", (int) own);
 718     dev->owner = own;
 719     return MRAA_SUCCESS;
 720 }
 721
 722 mraa_result_t
 723 mraa_gpio_use_mmaped(mraa_gpio_context dev, mraa_boolean_t mmap_en)
 724 {
 725     if (IS_FUNC_DEFINED(dev, gpio_mmap_setup)) {
 726         return dev->advance_func->gpio_mmap_setup(dev, mmap_en);
 727     }
 728
 729     syslog(LOG_ERR, "gpio: mmap not implemented on this platform");
 730     return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
 731 }
 732
 733 int
 734 mraa_gpio_get_pin(mraa_gpio_context dev)
 735 {
 736     if (dev == NULL) {
 737         syslog(LOG_ERR, "gpio: context is invalid");
 738         return -1;
 739     }
 740     return dev->phy_pin;
 741 }
 742
 743 int
 744 mraa_gpio_get_pin_raw(mraa_gpio_context dev)
 745 {
 746     if (dev == NULL) {
 747         syslog(LOG_ERR, "gpio: context is invalid");
 748         return -1;
 749     }
 750     return dev->pin;
 751 }