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