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