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 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 mraa_gpio_context
  56 mraa_gpio_init(int pin)
  57 {
  58     int pinm = mraa_setup_gpio(pin);
  59     if (pinm < 0)
  60         return NULL;
  61
  62     mraa_gpio_context r = mraa_gpio_init_raw(pinm);
  63     r->phy_pin = pin;
  64
  65     if (advance_func->gpio_init_post != NULL) {
  66         mraa_result_t ret = advance_func->gpio_init_post(r);
  67         if (ret != MRAA_SUCCESS) {
  68             free(r);
  69             return NULL;
  70         }
  71     }
  72     return r;
  73 }
  74
  75 mraa_gpio_context
  76 mraa_gpio_init_raw(int pin)
  77 {
  78     if (advance_func->gpio_init_pre != NULL) {
  79         if (advance_func->gpio_init_pre(pin) != MRAA_SUCCESS)
  80             return NULL;
  81     }
  82
  83     if (pin < 0)
  84         return NULL;
  85
  86     char bu[MAX_SIZE];
  87     int length;
  88
  89     mraa_gpio_context dev = (mraa_gpio_context) malloc(sizeof(struct _gpio));
  90     if (dev == NULL) {
  91         syslog(LOG_CRIT, "gpio: Failed to allocate memory for context");
  92         return NULL;
  93     }
  94
  95     memset(dev, 0, sizeof(struct _gpio));
  96     dev->value_fp = -1;
  97     dev->isr_value_fp = -1;
  98     dev->pin = pin;
  99     dev->phy_pin = -1;
 100
 101     char directory[MAX_SIZE];
 102     snprintf(directory, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/", dev->pin);
 103     struct stat dir;
 104     if (stat(directory, &dir) == 0 && S_ISDIR(dir.st_mode)) {
 105         dev->owner = 0; // Not Owner
 106     } else {
 107         int export = open(SYSFS_CLASS_GPIO "/export", O_WRONLY);
 108         if (export == -1) {
 109             syslog(LOG_ERR, "gpio: Failed to open export for writing");
 110             free(dev);
 111             return NULL;
 112         }
 113         length = snprintf(bu, sizeof(bu), "%d", dev->pin);
 114         if (write(export, bu, length*sizeof(char)) == -1) {
 115             syslog(LOG_ERR, "gpio: Failed to write to export");
 116             close(export);
 117             return NULL;
 118         }
 119         dev->owner = 1;
 120         close(export);
 121     }
 122
 123     return dev;
 124 }
 125
 126 static mraa_result_t
 127 mraa_gpio_write_register(mraa_gpio_context dev,int value)
 128 {
 129     if (advance_func->gpio_mmaped_write_replace != NULL)
 130         return advance_func->gpio_mmaped_write_replace(dev,value);
 131     if (advance_func->gpio_mmaped_write_pre != NULL) {
 132         mraa_result_t pre_ret = (advance_func->gpio_mmaped_write_pre(dev,value));
 133         if(pre_ret != MRAA_SUCCESS)
 134             return pre_ret;
 135     }
 136     if (value == 1) {
 137         *((unsigned *)dev->reg) |= (1<<dev->reg_bit_pos);
 138         return MRAA_SUCCESS;
 139     }
 140     *((unsigned *)dev->reg) &= ~(1<<dev->reg_bit_pos);
 141
 142     if (advance_func->gpio_mmaped_write_post != NULL)
 143         return advance_func->gpio_mmaped_write_post(dev,value);
 144     return MRAA_SUCCESS;
 145 }
 146
 147 static mraa_result_t
 148 mraa_gpio_wait_interrupt(int fd)
 149 {
 150     unsigned char c;
 151     struct pollfd pfd;
 152
 153     // setup poll on POLLPRI
 154     pfd.fd = fd;
 155     pfd.events = POLLPRI;
 156
 157     // do an initial read to clear interupt
 158     read (fd, &c, 1);
 159
 160     if (fd <= 0) {
 161         return MRAA_ERROR_INVALID_RESOURCE;
 162     }
 163
 164     // Wait for it forever or until pthread_cancel
 165     // poll is a cancelable point like sleep()
 166     int x = poll (&pfd, 1, -1);
 167
 168     // do a final read to clear interupt
 169     read (fd, &c, 1);
 170
 171     return MRAA_SUCCESS;
 172 }
 173
 174 static void*
 175 mraa_gpio_interrupt_handler(void* arg)
 176 {
 177     mraa_gpio_context dev = (mraa_gpio_context) arg;
 178     mraa_result_t ret;
 179
 180     // open gpio value with open(3)
 181     char bu[MAX_SIZE];
 182     sprintf(bu, SYSFS_CLASS_GPIO "/gpio%d/value", dev->pin);
 183     dev->isr_value_fp = open(bu, O_RDONLY);
 184
 185     for (;;) {
 186         ret = mraa_gpio_wait_interrupt(dev->isr_value_fp);
 187         if (ret == MRAA_SUCCESS) {
 188             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 189 #ifdef SWIGPYTHON
 190             // In order to call a python object (all python functions are objects) we
 191             // need to aquire the GIL (Global Interpreter Lock). This may not always be
 192             // nessecary but especially if doing IO (like print()) python will segfault
 193             // if we do not hold a lock on the GIL
 194             PyGILState_STATE gilstate = PyGILState_Ensure();
 195             PyObject *arglist;
 196             PyObject *ret;
 197             arglist = Py_BuildValue("(i)", dev->isr_args);
 198             if (arglist == NULL) {
 199                 syslog(LOG_ERR, "gpio: Py_BuildValue NULL");
 200             } else {
 201                 ret = PyEval_CallObject((PyObject*)dev->isr, arglist);
 202                 if (ret == NULL) {
 203                     syslog(LOG_ERR, "gpio: PyEval_CallObject failed");
 204                 } else {
 205                     Py_DECREF(ret);
 206                 }
 207                 Py_DECREF(arglist);
 208             }
 209
 210             PyGILState_Release (gilstate);
 211 #else
 212             dev->isr(dev->isr_args);
 213 #endif
 214             pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 215         } else {
 216         // we must have got an error code so die nicely
 217             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 218             close(dev->isr_value_fp);
 219             dev->isr_value_fp = -1;
 220             return NULL;
 221         }
 222     }
 223 }
 224
 225 mraa_result_t
 226 mraa_gpio_edge_mode(mraa_gpio_context dev, gpio_edge_t mode)
 227 {
 228     if (dev->value_fp != -1) {
 229          close(dev->value_fp);
 230          dev->value_fp = -1;
 231     }
 232
 233     char filepath[MAX_SIZE];
 234     snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/edge", dev->pin);
 235
 236     int edge = open(filepath, O_RDWR);
 237     if (edge == -1) {
 238         syslog(LOG_ERR, "gpio: Failed to open edge for writing");
 239         return MRAA_ERROR_INVALID_RESOURCE;
 240     }
 241
 242     char bu[MAX_SIZE];
 243     int length;
 244     switch(mode) {
 245         case MRAA_GPIO_EDGE_NONE:
 246             length = snprintf(bu, sizeof(bu), "none");
 247             break;
 248         case MRAA_GPIO_EDGE_BOTH:
 249             length = snprintf(bu, sizeof(bu), "both");
 250             break;
 251         case MRAA_GPIO_EDGE_RISING:
 252             length = snprintf(bu, sizeof(bu), "rising");
 253             break;
 254         case MRAA_GPIO_EDGE_FALLING:
 255             length = snprintf(bu, sizeof(bu), "falling");
 256             break;
 257         default:
 258             close(edge);
 259             return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
 260     }
 261     if (write(edge, bu, length*sizeof(char)) == -1) {
 262         syslog(LOG_ERR, "gpio: Failed to write to edge");
 263         close(edge);
 264         return MRAA_ERROR_INVALID_RESOURCE;
 265     }
 266
 267     close(edge);
 268     return MRAA_SUCCESS;
 269 }
 270
 271 mraa_result_t
 272 mraa_gpio_isr(mraa_gpio_context dev, gpio_edge_t mode, void (*fptr)(void *), void * args)
 273 {
 274     // we only allow one isr per mraa_gpio_context
 275     if (dev->thread_id != 0) {
 276         return MRAA_ERROR_NO_RESOURCES;
 277     }
 278
 279     if (MRAA_SUCCESS != mraa_gpio_edge_mode(dev, mode)) {
 280         return MRAA_ERROR_UNSPECIFIED;
 281     }
 282
 283     dev->isr = fptr;
 284     dev->isr_args = args;
 285     pthread_create (&dev->thread_id, NULL, mraa_gpio_interrupt_handler, (void *) dev);
 286
 287     return MRAA_SUCCESS;
 288 }
 289
 290 mraa_result_t
 291 mraa_gpio_isr_exit(mraa_gpio_context dev)
 292 {
 293     mraa_result_t ret = MRAA_SUCCESS;
 294
 295     // wasting our time, there is no isr to exit from
 296     if (dev->thread_id == 0 && dev->isr_value_fp == -1) {
 297         return ret;
 298     }
 299
 300     // stop isr being useful
 301     ret = mraa_gpio_edge_mode(dev, MRAA_GPIO_EDGE_NONE);
 302
 303     if ((dev->thread_id != 0)) {
 304         if ((pthread_cancel(dev->thread_id) != 0) || (pthread_join(dev->thread_id, NULL) != 0)) {
 305             ret = MRAA_ERROR_INVALID_HANDLE;
 306         }
 307     }
 308
 309     // close the filehandle in case it's still open
 310     if (dev->isr_value_fp != -1) {
 311           if (close(dev->isr_value_fp) != 0) {
 312               ret = MRAA_ERROR_INVALID_PARAMETER;
 313           }
 314     }
 315
 316 #ifdef SWIGPYTHON
 317     // Dereference our Python call back function
 318     Py_DECREF(dev->isr);
 319 #endif
 320
 321     // assume our thread will exit either way we just lost it's handle
 322     dev->thread_id = 0;
 323     dev->isr_value_fp = -1;
 324     return ret;
 325 }
 326
 327 mraa_result_t
 328 mraa_gpio_mode(mraa_gpio_context dev, gpio_mode_t mode)
 329 {
 330     if (advance_func->gpio_mode_replace != NULL)
 331         return advance_func->gpio_mode_replace(dev,mode);
 332
 333     if (advance_func->gpio_mode_pre != NULL) {
 334         mraa_result_t pre_ret = (advance_func->gpio_mode_pre(dev,mode));
 335         if(pre_ret != MRAA_SUCCESS)
 336             return pre_ret;
 337     }
 338
 339     if (dev->value_fp != -1) {
 340          close(dev->value_fp);
 341          dev->value_fp = -1;
 342     }
 343
 344     char filepath[MAX_SIZE];
 345     snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/drive", dev->pin);
 346
 347     int drive = open(filepath, O_WRONLY);
 348     if (drive == -1) {
 349         syslog(LOG_ERR, "gpio: Failed to open drive for writing");
 350         return MRAA_ERROR_INVALID_RESOURCE;
 351     }
 352
 353     char bu[MAX_SIZE];
 354     int length;
 355     switch(mode) {
 356         case MRAA_GPIO_STRONG:
 357             length = snprintf(bu, sizeof(bu), "strong");
 358             break;
 359         case MRAA_GPIO_PULLUP:
 360             length = snprintf(bu, sizeof(bu), "pullup");
 361             break;
 362         case MRAA_GPIO_PULLDOWN:
 363             length = snprintf(bu, sizeof(bu), "pulldown");
 364             break;
 365         case MRAA_GPIO_HIZ:
 366             length = snprintf(bu, sizeof(bu), "hiz");
 367             break;
 368         default:
 369             close(drive);
 370             return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
 371     }
 372     if (write(drive, bu, length*sizeof(char)) == -1) {
 373         syslog(LOG_ERR, "gpio: Failed to write to drive mode");
 374         close(drive);
 375         return MRAA_ERROR_INVALID_RESOURCE;
 376
 377     }
 378
 379     close(drive);
 380     if (advance_func->gpio_mode_post != NULL)
 381         return advance_func->gpio_mode_post(dev,mode);
 382     return MRAA_SUCCESS;
 383 }
 384
 385 mraa_result_t
 386 mraa_gpio_dir(mraa_gpio_context dev, gpio_dir_t dir)
 387 {
 388     if (advance_func->gpio_dir_replace != NULL)
 389         return advance_func->gpio_dir_replace(dev,dir);
 390     if (advance_func->gpio_dir_pre != NULL) {
 391         mraa_result_t pre_ret = (advance_func->gpio_dir_pre(dev,dir));
 392         if(pre_ret != MRAA_SUCCESS)
 393             return pre_ret;
 394     }
 395
 396     if (dev == NULL) {
 397         return MRAA_ERROR_INVALID_HANDLE;
 398     }
 399     if (dev->value_fp != -1) {
 400          close(dev->value_fp);
 401          dev->value_fp = -1;
 402     }
 403     char filepath[MAX_SIZE];
 404     snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/direction", dev->pin);
 405
 406     int direction = open(filepath, O_RDWR);
 407
 408     if (direction == -1) {
 409         return MRAA_ERROR_INVALID_RESOURCE;
 410     }
 411
 412     char bu[MAX_SIZE];
 413     int length;
 414     switch(dir) {
 415         case MRAA_GPIO_OUT:
 416             length = snprintf(bu, sizeof(bu), "out");
 417             break;
 418         case MRAA_GPIO_IN:
 419             length = snprintf(bu, sizeof(bu), "in");
 420             break;
 421         default:
 422             close(direction);
 423             return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
 424     }
 425
 426     if (write(direction, bu, length*sizeof(char)) == -1) {
 427         close(direction);
 428         return MRAA_ERROR_INVALID_RESOURCE;
 429     }
 430
 431     close(direction);
 432     if (advance_func->gpio_dir_post != NULL)
 433         return advance_func->gpio_dir_post(dev,dir);
 434     return MRAA_SUCCESS;
 435 }
 436
 437 int
 438 mraa_gpio_read(mraa_gpio_context dev)
 439 {
 440     if (dev == NULL)
 441         return -1;
 442
 443     if (dev->value_fp == -1) {
 444         if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
 445              syslog(LOG_ERR, "gpio: Failed to get value file pointer");
 446         }
 447     }
 448     else {
 449         // if value_fp is new this is pointless
 450         lseek(dev->value_fp, 0, SEEK_SET);
 451     }
 452     char bu[2];
 453     if (read(dev->value_fp, bu, 2*sizeof(char)) != 2) {
 454         syslog(LOG_ERR, "gpio: Failed to read a sensible value from sysfs");
 455         return -1;
 456     }
 457     lseek(dev->value_fp, 0, SEEK_SET);
 458
 459     return strtol(bu, NULL, 10);
 460 }
 461
 462 mraa_result_t
 463 mraa_gpio_write(mraa_gpio_context dev, int value)
 464 {
 465     if (dev == NULL)
 466         return MRAA_ERROR_INVALID_HANDLE;
 467
 468     if (dev->mmap == 1)
 469         return mraa_gpio_write_register(dev,value);
 470
 471     if (advance_func->gpio_write_pre != NULL) {
 472         mraa_result_t pre_ret = (advance_func->gpio_write_pre(dev,value));
 473         if(pre_ret != MRAA_SUCCESS)
 474             return pre_ret;
 475     }
 476
 477     if (dev->value_fp == -1) {
 478         mraa_gpio_get_valfp(dev);
 479     }
 480     if (lseek(dev->value_fp, 0, SEEK_SET) == -1) {
 481         return MRAA_ERROR_INVALID_RESOURCE;
 482     }
 483
 484     char bu[MAX_SIZE];
 485     int length = snprintf(bu, sizeof(bu), "%d", value);
 486     if (write(dev->value_fp, bu, length*sizeof(char)) == -1) {
 487         return MRAA_ERROR_INVALID_HANDLE;
 488     }
 489
 490     if (advance_func->gpio_write_post != NULL)
 491         return advance_func->gpio_write_post(dev,value);
 492     return MRAA_SUCCESS;
 493 }
 494
 495 static mraa_result_t
 496 mraa_gpio_unexport_force(mraa_gpio_context dev)
 497 {
 498     int unexport = open(SYSFS_CLASS_GPIO "/unexport", O_WRONLY);
 499     if (unexport == -1) {
 500         syslog(LOG_ERR, "gpio: Failed to open unexport for writing");
 501         return MRAA_ERROR_INVALID_RESOURCE;
 502     }
 503
 504     char bu[MAX_SIZE];
 505     int length = snprintf(bu, sizeof(bu), "%d", dev->pin);
 506     if (write(unexport, bu, length*sizeof(char)) == -1) {
 507         syslog(LOG_ERR, "gpio: Failed to write to unexport");
 508         close(unexport);
 509         return MRAA_ERROR_INVALID_RESOURCE;
 510     }
 511
 512     close(unexport);
 513     mraa_gpio_isr_exit(dev);
 514     return MRAA_SUCCESS;
 515 }
 516 static mraa_result_t
 517 mraa_gpio_unexport(mraa_gpio_context dev)
 518 {
 519     if(dev->owner) {
 520         return mraa_gpio_unexport_force(dev);
 521     }
 522     return MRAA_ERROR_INVALID_RESOURCE;
 523 }
 524
 525 mraa_result_t
 526 mraa_gpio_close(mraa_gpio_context dev)
 527 {
 528     if (dev->value_fp != -1) {
 529         close(dev->value_fp);
 530     }
 531     mraa_gpio_unexport(dev);
 532     free(dev);
 533     return MRAA_SUCCESS;
 534 }
 535
 536 mraa_result_t
 537 mraa_gpio_owner(mraa_gpio_context dev, mraa_boolean_t own)
 538 {
 539     if (dev == NULL)
 540         return MRAA_ERROR_INVALID_RESOURCE;
 541     dev->owner = own;
 542     return MRAA_SUCCESS;
 543 }
 544
 545 mraa_result_t
 546 mraa_gpio_use_mmaped(mraa_gpio_context dev, mraa_boolean_t mmap_en)
 547 {
 548     if (dev ==  NULL) {
 549         return MRAA_ERROR_INVALID_RESOURCE;
 550     }
 551
 552     if (mraa_pin_mode_test(dev->phy_pin, MRAA_PIN_FAST_GPIO) == 0)
 553         return MRAA_ERROR_NO_RESOURCES;
 554
 555     mraa_mmap_pin_t *mmp = mraa_setup_mmap_gpio(dev->phy_pin);
 556     if (mmp == NULL)
 557         return MRAA_ERROR_INVALID_RESOURCE;
 558
 559     if (mmap_en == 1) {
 560         if (dev->mmap == 0) {
 561             close(dev->value_fp);
 562             int fd;
 563             fd = open(mmp->mem_dev, O_RDWR);
 564             if (fd < 1) {
 565                 syslog(LOG_ERR, "gpio: Unable to open memory device");
 566                 close(fd);
 567                 return MRAA_ERROR_INVALID_RESOURCE;
 568             }
 569             dev->reg_sz = mmp->mem_sz;
 570             dev->reg = mmap(NULL, dev->reg_sz, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 571             dev->reg_bit_pos = mmp->bit_pos;
 572             dev->mmap = 1;
 573             close(fd);
 574             return MRAA_SUCCESS;
 575         }
 576         return MRAA_ERROR_INVALID_PARAMETER;
 577     }
 578
 579     if (mmap_en == 0) {
 580         if (dev ->mmap == 1) {
 581             munmap(dev->reg, dev->reg_sz);
 582             dev->mmap = 0;
 583         }
 584         return MRAA_ERROR_INVALID_PARAMETER;
 585     }
 586
 587     return MRAA_SUCCESS;
 588 }