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.
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;
55 static mraa_gpio_context
56 mraa_gpio_init_internal(mraa_adv_func_t* func_table, int pin)
61 mraa_result_t status = MRAA_SUCCESS;
65 mraa_gpio_context dev = (mraa_gpio_context) calloc(1, sizeof(struct _gpio));
67 syslog(LOG_CRIT, "gpio: Failed to allocate memory for context");
71 dev->advance_func = func_table;
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)
79 goto init_internal_cleanup;
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;
89 dev->isr_value_fp = -1;
90 dev->isr_thread_terminating = 0;
93 // then check to make sure the pin is exported.
94 char directory[MAX_SIZE];
95 snprintf(directory, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/", dev->pin);
97 if (stat(directory, &dir) == 0 && S_ISDIR(dir.st_mode)) {
98 dev->owner = 0; // Not Owner
100 int export = open(SYSFS_CLASS_GPIO "/export", O_WRONLY);
102 syslog(LOG_ERR, "gpio: Failed to open export for writing");
103 status = MRAA_ERROR_NO_RESOURCES;
104 goto init_internal_cleanup;
106 length = snprintf(bu, sizeof(bu), "%d", dev->pin);
107 if (write(export, bu, length * sizeof(char)) == -1) {
108 syslog(LOG_ERR, "gpio: Failed to write %d to export", dev->pin);
110 status = MRAA_ERROR_NO_RESOURCES;
111 goto init_internal_cleanup;
117 init_internal_cleanup:
118 if (status != MRAA_SUCCESS) {
127 mraa_gpio_init(int pin)
129 mraa_board_t* board = plat;
131 syslog(LOG_ERR, "gpio: platform not initialised");
135 if (mraa_is_sub_platform_id(pin)) {
136 syslog(LOG_NOTICE, "gpio: Using sub platform");
137 board = board->sub_platform;
139 syslog(LOG_ERR, "gpio: Sub platform Not Initialised");
142 pin = mraa_get_sub_platform_index(pin);
145 if (pin < 0 || pin > board->phy_pin_count) {
146 syslog(LOG_ERR, "gpio: pin %i beyond platform definition", pin);
149 if (board->pins[pin].capabilites.gpio != 1) {
150 syslog(LOG_ERR, "gpio: pin %i not capable of gpio", pin);
153 if (board->pins[pin].gpio.mux_total > 0) {
154 if (mraa_setup_mux_mapped(board->pins[pin].gpio) != MRAA_SUCCESS) {
155 syslog(LOG_ERR, "gpio: unable to setup muxes");
160 mraa_gpio_context r = mraa_gpio_init_internal(board->adv_func, board->pins[pin].gpio.pinmap);
162 syslog(LOG_CRIT, "gpio: mraa_gpio_init_raw(%d) returned error", pin);
167 if (IS_FUNC_DEFINED(r, gpio_init_post)) {
168 mraa_result_t ret = r->advance_func->gpio_init_post(r);
169 if (ret != MRAA_SUCCESS) {
178 mraa_gpio_init_raw(int pin)
180 return mraa_gpio_init_internal(plat == NULL ? NULL : plat->adv_func , pin);
185 mraa_gpio_wait_interrupt(int fd)
191 return MRAA_ERROR_INVALID_RESOURCE;
194 // setup poll on POLLPRI
196 pfd.events = POLLPRI;
198 // do an initial read to clear interrupt
199 lseek(fd, 0, SEEK_SET);
202 // Wait for it forever or until pthread_cancel
203 // poll is a cancelable point like sleep()
204 int x = poll(&pfd, 1, -1);
206 // do a final read to clear interrupt
213 mraa_gpio_interrupt_handler(void* arg)
215 mraa_gpio_context dev = (mraa_gpio_context) arg;
216 if (IS_FUNC_DEFINED(dev, gpio_interrupt_handler_replace))
217 return dev->advance_func->gpio_interrupt_handler_replace(dev);
221 // open gpio value with open(3)
223 sprintf(bu, SYSFS_CLASS_GPIO "/gpio%d/value", dev->pin);
224 int fp = open(bu, O_RDONLY);
226 syslog(LOG_ERR, "gpio: failed to open gpio%d/value", dev->pin);
229 dev->isr_value_fp = fp;
232 ret = mraa_gpio_wait_interrupt(dev->isr_value_fp);
233 if (ret == MRAA_SUCCESS && !dev->isr_thread_terminating) {
234 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
236 // In order to call a python object (all python functions are objects) we
237 // need to aquire the GIL (Global Interpreter Lock). This may not always be
238 // nessecary but especially if doing IO (like print()) python will segfault
239 // if we do not hold a lock on the GIL
240 PyGILState_STATE gilstate = PyGILState_Ensure();
243 arglist = Py_BuildValue("(i)", dev->isr_args);
244 if (arglist == NULL) {
245 syslog(LOG_ERR, "gpio: Py_BuildValue NULL");
247 ret = PyEval_CallObject((PyObject*) dev->isr, arglist);
249 syslog(LOG_ERR, "gpio: PyEval_CallObject failed");
256 PyGILState_Release(gilstate);
258 dev->isr(dev->isr_args);
260 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
262 // we must have got an error code or exit request so die nicely
263 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
264 close(dev->isr_value_fp);
265 dev->isr_value_fp = -1;
272 mraa_gpio_edge_mode(mraa_gpio_context dev, mraa_gpio_edge_t mode)
274 if (IS_FUNC_DEFINED(dev, gpio_edge_mode_replace))
275 return dev->advance_func->gpio_edge_mode_replace(dev, mode);
277 if (dev->value_fp != -1) {
278 close(dev->value_fp);
282 char filepath[MAX_SIZE];
283 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/edge", dev->pin);
285 int edge = open(filepath, O_RDWR);
287 syslog(LOG_ERR, "gpio: Failed to open edge for writing");
288 return MRAA_ERROR_INVALID_RESOURCE;
294 case MRAA_GPIO_EDGE_NONE:
295 length = snprintf(bu, sizeof(bu), "none");
297 case MRAA_GPIO_EDGE_BOTH:
298 length = snprintf(bu, sizeof(bu), "both");
300 case MRAA_GPIO_EDGE_RISING:
301 length = snprintf(bu, sizeof(bu), "rising");
303 case MRAA_GPIO_EDGE_FALLING:
304 length = snprintf(bu, sizeof(bu), "falling");
308 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
310 if (write(edge, bu, length * sizeof(char)) == -1) {
311 syslog(LOG_ERR, "gpio: Failed to write to edge");
313 return MRAA_ERROR_INVALID_RESOURCE;
321 mraa_gpio_isr(mraa_gpio_context dev, mraa_gpio_edge_t mode, void (*fptr)(void*), void* args)
323 // we only allow one isr per mraa_gpio_context
324 if (dev->thread_id != 0) {
325 return MRAA_ERROR_NO_RESOURCES;
328 if (MRAA_SUCCESS != mraa_gpio_edge_mode(dev, mode)) {
329 return MRAA_ERROR_UNSPECIFIED;
333 dev->isr_args = args;
334 pthread_create(&dev->thread_id, NULL, mraa_gpio_interrupt_handler, (void*) dev);
340 mraa_gpio_isr_exit(mraa_gpio_context dev)
342 mraa_result_t ret = MRAA_SUCCESS;
344 // wasting our time, there is no isr to exit from
345 if (dev->thread_id == 0 && dev->isr_value_fp == -1) {
348 // mark the beginning of the thread termination process for interested parties
349 dev->isr_thread_terminating = 1;
351 // stop isr being useful
352 ret = mraa_gpio_edge_mode(dev, MRAA_GPIO_EDGE_NONE);
354 if ((dev->thread_id != 0)) {
355 if ((pthread_cancel(dev->thread_id) != 0) || (pthread_join(dev->thread_id, NULL) != 0)) {
356 ret = MRAA_ERROR_INVALID_HANDLE;
360 // close the filehandle in case it's still open
361 if (dev->isr_value_fp != -1) {
362 if (close(dev->isr_value_fp) != 0) {
363 ret = MRAA_ERROR_INVALID_PARAMETER;
367 // assume our thread will exit either way we just lost it's handle
369 dev->isr_value_fp = -1;
370 dev->isr_thread_terminating = 0;
375 mraa_gpio_mode(mraa_gpio_context dev, mraa_gpio_mode_t mode)
377 if (IS_FUNC_DEFINED(dev, gpio_mode_replace))
378 return dev->advance_func->gpio_mode_replace(dev, mode);
380 if (IS_FUNC_DEFINED(dev, gpio_mode_pre)) {
381 mraa_result_t pre_ret = (dev->advance_func->gpio_mode_pre(dev, mode));
382 if (pre_ret != MRAA_SUCCESS)
386 if (dev->value_fp != -1) {
387 close(dev->value_fp);
391 char filepath[MAX_SIZE];
392 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/drive", dev->pin);
394 int drive = open(filepath, O_WRONLY);
396 syslog(LOG_ERR, "gpio: Failed to open drive for writing");
397 return MRAA_ERROR_INVALID_RESOURCE;
403 case MRAA_GPIO_STRONG:
404 length = snprintf(bu, sizeof(bu), "strong");
406 case MRAA_GPIO_PULLUP:
407 length = snprintf(bu, sizeof(bu), "pullup");
409 case MRAA_GPIO_PULLDOWN:
410 length = snprintf(bu, sizeof(bu), "pulldown");
413 length = snprintf(bu, sizeof(bu), "hiz");
417 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
419 if (write(drive, bu, length * sizeof(char)) == -1) {
420 syslog(LOG_ERR, "gpio: Failed to write to drive mode");
422 return MRAA_ERROR_INVALID_RESOURCE;
426 if (IS_FUNC_DEFINED(dev, gpio_mode_post))
427 return dev->advance_func->gpio_mode_post(dev, mode);
432 mraa_gpio_dir(mraa_gpio_context dev, mraa_gpio_dir_t dir)
434 if (IS_FUNC_DEFINED(dev, gpio_dir_replace)) {
435 return dev->advance_func->gpio_dir_replace(dev, dir);
438 if (IS_FUNC_DEFINED(dev, gpio_dir_pre)) {
439 mraa_result_t pre_ret = (dev->advance_func->gpio_dir_pre(dev, dir));
440 if (pre_ret != MRAA_SUCCESS) {
446 return MRAA_ERROR_INVALID_HANDLE;
448 if (dev->value_fp != -1) {
449 close(dev->value_fp);
452 char filepath[MAX_SIZE];
453 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/direction", dev->pin);
455 int direction = open(filepath, O_RDWR);
457 if (direction == -1) {
458 // Direction Failed to Open. If HIGH or LOW was passed will try and set
459 // If not fail as usual.
461 case MRAA_GPIO_OUT_HIGH:
462 return mraa_gpio_write(dev, 1);
463 case MRAA_GPIO_OUT_LOW:
464 return mraa_gpio_write(dev, 0);
466 return MRAA_ERROR_INVALID_RESOURCE;
474 length = snprintf(bu, sizeof(bu), "out");
477 length = snprintf(bu, sizeof(bu), "in");
479 case MRAA_GPIO_OUT_HIGH:
480 length = snprintf(bu, sizeof(bu), "high");
482 case MRAA_GPIO_OUT_LOW:
483 length = snprintf(bu, sizeof(bu), "low");
487 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
490 if (write(direction, bu, length * sizeof(char)) == -1) {
492 return MRAA_ERROR_INVALID_RESOURCE;
496 if (IS_FUNC_DEFINED(dev, gpio_dir_post))
497 return dev->advance_func->gpio_dir_post(dev, dir);
502 mraa_gpio_read(mraa_gpio_context dev)
507 if (IS_FUNC_DEFINED(dev, gpio_read_replace))
508 return dev->advance_func->gpio_read_replace(dev);
510 if (dev->mmap_read != NULL)
511 return dev->mmap_read(dev);
513 if (dev->value_fp == -1) {
514 if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
515 syslog(LOG_ERR, "gpio: Failed to get value file pointer");
519 // if value_fp is new this is pointless
520 lseek(dev->value_fp, 0, SEEK_SET);
523 if (read(dev->value_fp, bu, 2 * sizeof(char)) != 2) {
524 syslog(LOG_ERR, "gpio: Failed to read a sensible value from sysfs");
527 lseek(dev->value_fp, 0, SEEK_SET);
529 return (int) strtol(bu, NULL, 10);
533 mraa_gpio_write(mraa_gpio_context dev, int value)
536 return MRAA_ERROR_INVALID_HANDLE;
538 if (dev->mmap_write != NULL)
539 return dev->mmap_write(dev, value);
541 if (IS_FUNC_DEFINED(dev, gpio_write_pre)) {
542 mraa_result_t pre_ret = (dev->advance_func->gpio_write_pre(dev, value));
543 if (pre_ret != MRAA_SUCCESS)
547 if (dev->value_fp == -1) {
548 if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
549 return MRAA_ERROR_INVALID_RESOURCE;
553 if (lseek(dev->value_fp, 0, SEEK_SET) == -1) {
554 return MRAA_ERROR_INVALID_RESOURCE;
558 int length = snprintf(bu, sizeof(bu), "%d", value);
559 if (write(dev->value_fp, bu, length * sizeof(char)) == -1) {
560 return MRAA_ERROR_INVALID_HANDLE;
563 if (IS_FUNC_DEFINED(dev, gpio_write_post))
564 return dev->advance_func->gpio_write_post(dev, value);
569 mraa_gpio_unexport_force(mraa_gpio_context dev)
571 int unexport = open(SYSFS_CLASS_GPIO "/unexport", O_WRONLY);
572 if (unexport == -1) {
573 syslog(LOG_ERR, "gpio: Failed to open unexport for writing");
574 return MRAA_ERROR_INVALID_RESOURCE;
578 int length = snprintf(bu, sizeof(bu), "%d", dev->pin);
579 if (write(unexport, bu, length * sizeof(char)) == -1) {
580 syslog(LOG_ERR, "gpio: Failed to write to unexport");
582 return MRAA_ERROR_INVALID_RESOURCE;
586 mraa_gpio_isr_exit(dev);
590 mraa_gpio_unexport(mraa_gpio_context dev)
593 return mraa_gpio_unexport_force(dev);
595 return MRAA_ERROR_INVALID_RESOURCE;
599 mraa_gpio_close(mraa_gpio_context dev)
601 mraa_result_t result = MRAA_SUCCESS;
603 if (IS_FUNC_DEFINED(dev, gpio_close_pre)) {
604 result = dev->advance_func->gpio_close_pre(dev);
607 if (dev->value_fp != -1) {
608 close(dev->value_fp);
610 mraa_gpio_unexport(dev);
616 mraa_gpio_owner(mraa_gpio_context dev, mraa_boolean_t own)
619 return MRAA_ERROR_INVALID_RESOURCE;
621 syslog(LOG_DEBUG, "gpio: Set owner to %d", (int) own);
627 mraa_gpio_use_mmaped(mraa_gpio_context dev, mraa_boolean_t mmap_en)
629 if (IS_FUNC_DEFINED(dev, gpio_mmap_setup)) {
630 return dev->advance_func->gpio_mmap_setup(dev, mmap_en);
633 syslog(LOG_ERR, "gpio: mmap not implemented on this platform");
634 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
638 mraa_gpio_get_pin(mraa_gpio_context dev)
641 syslog(LOG_ERR, "gpio: context is invalid");
648 mraa_gpio_get_pin_raw(mraa_gpio_context dev)
651 syslog(LOG_ERR, "gpio: context is invalid");