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.
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:
14 * The above copyright notice and this permission notice shall be
15 * included in all copies or substantial portions of the Software.
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.
26 #include "mraa_internal.h"
38 #define SYSFS_CLASS_GPIO "/sys/class/gpio"
43 mraa_gpio_get_valfp(mraa_gpio_context dev)
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;
56 mraa_gpio_init(int pin)
59 syslog(LOG_ERR, "gpio: platform not initialised");
62 if (pin < 0 || pin > plat->phy_pin_count) {
63 syslog(LOG_ERR, "gpio: pin %i beyond platform definition", pin);
66 if (plat->pins[pin].capabilites.gpio != 1) {
67 syslog(LOG_ERR, "gpio: pin %i not capable of gpio", pin);
70 if (plat->pins[pin].gpio.mux_total > 0) {
71 if (mraa_setup_mux_mapped(plat->pins[pin].gpio) != MRAA_SUCCESS) {
72 syslog(LOG_ERR, "gpio: unable to setup muxes");
77 mraa_gpio_context r = mraa_gpio_init_raw(plat->pins[pin].gpio.pinmap);
79 syslog(LOG_CRIT, "gpio: mraa_gpio_init_raw(%d) returned error", pin);
84 if (advance_func->gpio_init_post != NULL) {
85 mraa_result_t ret = advance_func->gpio_init_post(r);
86 if (ret != MRAA_SUCCESS) {
95 mraa_gpio_init_raw(int pin)
97 if (advance_func->gpio_init_pre != NULL) {
98 if (advance_func->gpio_init_pre(pin) != MRAA_SUCCESS)
108 mraa_gpio_context dev = (mraa_gpio_context) malloc(sizeof(struct _gpio));
110 syslog(LOG_CRIT, "gpio: Failed to allocate memory for context");
114 memset(dev, 0, sizeof(struct _gpio));
116 dev->isr_value_fp = -1;
120 // then check to make sure the pin is exported.
121 char directory[MAX_SIZE];
122 snprintf(directory, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/", dev->pin);
124 if (stat(directory, &dir) == 0 && S_ISDIR(dir.st_mode)) {
125 dev->owner = 0; // Not Owner
127 int export = open(SYSFS_CLASS_GPIO "/export", O_WRONLY);
129 syslog(LOG_ERR, "gpio: Failed to open export for writing");
133 length = snprintf(bu, sizeof(bu), "%d", dev->pin);
134 if (write(export, bu, length*sizeof(char)) == -1) {
135 syslog(LOG_ERR, "gpio: Failed to write %d to export", dev->pin);
149 mraa_gpio_wait_interrupt(int fd)
155 return MRAA_ERROR_INVALID_RESOURCE;
158 // setup poll on POLLPRI
160 pfd.events = POLLPRI;
162 // do an initial read to clear interrupt
163 lseek (fd, 0, SEEK_SET);
166 // Wait for it forever or until pthread_cancel
167 // poll is a cancelable point like sleep()
168 int x = poll (&pfd, 1, -1);
170 // do a final read to clear interrupt
177 mraa_gpio_interrupt_handler(void* arg)
179 mraa_gpio_context dev = (mraa_gpio_context) arg;
182 // open gpio value with open(3)
184 sprintf(bu, SYSFS_CLASS_GPIO "/gpio%d/value", dev->pin);
185 int fp = open(bu, O_RDONLY);
187 syslog(LOG_ERR, "gpio: failed to open gpio%d/value", dev->pin);
190 dev->isr_value_fp = fp;
193 ret = mraa_gpio_wait_interrupt(dev->isr_value_fp);
194 if (ret == MRAA_SUCCESS) {
195 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
197 // In order to call a python object (all python functions are objects) we
198 // need to aquire the GIL (Global Interpreter Lock). This may not always be
199 // nessecary but especially if doing IO (like print()) python will segfault
200 // if we do not hold a lock on the GIL
201 PyGILState_STATE gilstate = PyGILState_Ensure();
204 arglist = Py_BuildValue("(i)", dev->isr_args);
205 if (arglist == NULL) {
206 syslog(LOG_ERR, "gpio: Py_BuildValue NULL");
208 ret = PyEval_CallObject((PyObject*)dev->isr, arglist);
210 syslog(LOG_ERR, "gpio: PyEval_CallObject failed");
217 PyGILState_Release (gilstate);
219 dev->isr(dev->isr_args);
221 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
223 // we must have got an error code so die nicely
224 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
225 close(dev->isr_value_fp);
226 dev->isr_value_fp = -1;
233 mraa_gpio_edge_mode(mraa_gpio_context dev, gpio_edge_t mode)
235 if (dev->value_fp != -1) {
236 close(dev->value_fp);
240 char filepath[MAX_SIZE];
241 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/edge", dev->pin);
243 int edge = open(filepath, O_RDWR);
245 syslog(LOG_ERR, "gpio: Failed to open edge for writing");
246 return MRAA_ERROR_INVALID_RESOURCE;
252 case MRAA_GPIO_EDGE_NONE:
253 length = snprintf(bu, sizeof(bu), "none");
255 case MRAA_GPIO_EDGE_BOTH:
256 length = snprintf(bu, sizeof(bu), "both");
258 case MRAA_GPIO_EDGE_RISING:
259 length = snprintf(bu, sizeof(bu), "rising");
261 case MRAA_GPIO_EDGE_FALLING:
262 length = snprintf(bu, sizeof(bu), "falling");
266 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
268 if (write(edge, bu, length*sizeof(char)) == -1) {
269 syslog(LOG_ERR, "gpio: Failed to write to edge");
271 return MRAA_ERROR_INVALID_RESOURCE;
279 mraa_gpio_isr(mraa_gpio_context dev, gpio_edge_t mode, void (*fptr)(void *), void * args)
281 // we only allow one isr per mraa_gpio_context
282 if (dev->thread_id != 0) {
283 return MRAA_ERROR_NO_RESOURCES;
286 if (MRAA_SUCCESS != mraa_gpio_edge_mode(dev, mode)) {
287 return MRAA_ERROR_UNSPECIFIED;
291 dev->isr_args = args;
292 pthread_create (&dev->thread_id, NULL, mraa_gpio_interrupt_handler, (void *) dev);
298 mraa_gpio_isr_exit(mraa_gpio_context dev)
300 mraa_result_t ret = MRAA_SUCCESS;
302 // wasting our time, there is no isr to exit from
303 if (dev->thread_id == 0 && dev->isr_value_fp == -1) {
307 // stop isr being useful
308 ret = mraa_gpio_edge_mode(dev, MRAA_GPIO_EDGE_NONE);
310 if ((dev->thread_id != 0)) {
311 if ((pthread_cancel(dev->thread_id) != 0) || (pthread_join(dev->thread_id, NULL) != 0)) {
312 ret = MRAA_ERROR_INVALID_HANDLE;
316 // close the filehandle in case it's still open
317 if (dev->isr_value_fp != -1) {
318 if (close(dev->isr_value_fp) != 0) {
319 ret = MRAA_ERROR_INVALID_PARAMETER;
324 // Dereference our Python call back function
328 // assume our thread will exit either way we just lost it's handle
330 dev->isr_value_fp = -1;
335 mraa_gpio_mode(mraa_gpio_context dev, gpio_mode_t mode)
337 if (advance_func->gpio_mode_replace != NULL)
338 return advance_func->gpio_mode_replace(dev,mode);
340 if (advance_func->gpio_mode_pre != NULL) {
341 mraa_result_t pre_ret = (advance_func->gpio_mode_pre(dev,mode));
342 if(pre_ret != MRAA_SUCCESS)
346 if (dev->value_fp != -1) {
347 close(dev->value_fp);
351 char filepath[MAX_SIZE];
352 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/drive", dev->pin);
354 int drive = open(filepath, O_WRONLY);
356 syslog(LOG_ERR, "gpio: Failed to open drive for writing");
357 return MRAA_ERROR_INVALID_RESOURCE;
363 case MRAA_GPIO_STRONG:
364 length = snprintf(bu, sizeof(bu), "strong");
366 case MRAA_GPIO_PULLUP:
367 length = snprintf(bu, sizeof(bu), "pullup");
369 case MRAA_GPIO_PULLDOWN:
370 length = snprintf(bu, sizeof(bu), "pulldown");
373 length = snprintf(bu, sizeof(bu), "hiz");
377 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
379 if (write(drive, bu, length*sizeof(char)) == -1) {
380 syslog(LOG_ERR, "gpio: Failed to write to drive mode");
382 return MRAA_ERROR_INVALID_RESOURCE;
387 if (advance_func->gpio_mode_post != NULL)
388 return advance_func->gpio_mode_post(dev,mode);
393 mraa_gpio_dir(mraa_gpio_context dev, gpio_dir_t dir)
395 if (advance_func->gpio_dir_replace != NULL) {
396 return advance_func->gpio_dir_replace(dev,dir);
398 if (advance_func->gpio_dir_pre != NULL) {
399 mraa_result_t pre_ret = (advance_func->gpio_dir_pre(dev,dir));
400 if (pre_ret != MRAA_SUCCESS) {
406 return MRAA_ERROR_INVALID_HANDLE;
408 if (dev->value_fp != -1) {
409 close(dev->value_fp);
412 char filepath[MAX_SIZE];
413 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/direction", dev->pin);
415 int direction = open(filepath, O_RDWR);
417 if (direction == -1) {
418 // Direction Failed to Open. If HIGH or LOW was passed will try and set
419 // If not fail as usual.
421 case MRAA_GPIO_OUT_HIGH:
422 return mraa_gpio_write(dev, 1);
423 case MRAA_GPIO_OUT_LOW:
424 return mraa_gpio_write(dev, 0);
426 return MRAA_ERROR_INVALID_RESOURCE;
434 length = snprintf(bu, sizeof(bu), "out");
437 length = snprintf(bu, sizeof(bu), "in");
439 case MRAA_GPIO_OUT_HIGH:
440 length = snprintf(bu, sizeof(bu), "high");
442 case MRAA_GPIO_OUT_LOW:
443 length = snprintf(bu, sizeof(bu), "low");
447 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
450 if (write(direction, bu, length*sizeof(char)) == -1) {
452 return MRAA_ERROR_INVALID_RESOURCE;
456 if (advance_func->gpio_dir_post != NULL)
457 return advance_func->gpio_dir_post(dev,dir);
462 mraa_gpio_read(mraa_gpio_context dev)
467 if (dev->mmap_read != NULL)
468 return dev->mmap_read(dev);
470 if (dev->value_fp == -1) {
471 if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
472 syslog(LOG_ERR, "gpio: Failed to get value file pointer");
477 // if value_fp is new this is pointless
478 lseek(dev->value_fp, 0, SEEK_SET);
481 if (read(dev->value_fp, bu, 2*sizeof(char)) != 2) {
482 syslog(LOG_ERR, "gpio: Failed to read a sensible value from sysfs");
485 lseek(dev->value_fp, 0, SEEK_SET);
487 return (int) strtol(bu, NULL, 10);
491 mraa_gpio_write(mraa_gpio_context dev, int value)
494 return MRAA_ERROR_INVALID_HANDLE;
496 if (dev->mmap_write != NULL)
497 return dev->mmap_write(dev,value);
499 if (advance_func->gpio_write_pre != NULL) {
500 mraa_result_t pre_ret = (advance_func->gpio_write_pre(dev,value));
501 if(pre_ret != MRAA_SUCCESS)
505 if (dev->value_fp == -1) {
506 if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
507 return MRAA_ERROR_INVALID_RESOURCE;
511 if (lseek(dev->value_fp, 0, SEEK_SET) == -1) {
512 return MRAA_ERROR_INVALID_RESOURCE;
516 int length = snprintf(bu, sizeof(bu), "%d", value);
517 if (write(dev->value_fp, bu, length*sizeof(char)) == -1) {
518 return MRAA_ERROR_INVALID_HANDLE;
521 if (advance_func->gpio_write_post != NULL)
522 return advance_func->gpio_write_post(dev,value);
527 mraa_gpio_unexport_force(mraa_gpio_context dev)
529 int unexport = open(SYSFS_CLASS_GPIO "/unexport", O_WRONLY);
530 if (unexport == -1) {
531 syslog(LOG_ERR, "gpio: Failed to open unexport for writing");
532 return MRAA_ERROR_INVALID_RESOURCE;
536 int length = snprintf(bu, sizeof(bu), "%d", dev->pin);
537 if (write(unexport, bu, length*sizeof(char)) == -1) {
538 syslog(LOG_ERR, "gpio: Failed to write to unexport");
540 return MRAA_ERROR_INVALID_RESOURCE;
544 mraa_gpio_isr_exit(dev);
548 mraa_gpio_unexport(mraa_gpio_context dev)
551 return mraa_gpio_unexport_force(dev);
553 return MRAA_ERROR_INVALID_RESOURCE;
557 mraa_gpio_close(mraa_gpio_context dev)
559 mraa_result_t result = MRAA_SUCCESS;
561 if (advance_func->gpio_close_pre != NULL) {
562 result = advance_func->gpio_close_pre(dev);
565 if (dev->value_fp != -1) {
566 close(dev->value_fp);
568 mraa_gpio_unexport(dev);
574 mraa_gpio_owner(mraa_gpio_context dev, mraa_boolean_t own)
577 return MRAA_ERROR_INVALID_RESOURCE;
579 syslog(LOG_DEBUG, "gpio: Set owner to %d", (int) own);
585 mraa_gpio_use_mmaped(mraa_gpio_context dev, mraa_boolean_t mmap_en)
587 if (advance_func->gpio_mmap_setup != NULL) {
588 return advance_func->gpio_mmap_setup(dev,mmap_en);
591 syslog(LOG_ERR, "gpio: mmap not implemented on this platform");
592 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
596 mraa_gpio_get_pin(mraa_gpio_context dev)
599 syslog(LOG_ERR, "gpio: context is invalid");
605 mraa_gpio_get_pin_raw(mraa_gpio_context dev)
608 syslog(LOG_ERR, "gpio: context is invalid");