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 #ifndef HAVE_PTHREAD_CANCEL
91 dev->isr_control_pipe[0] = dev->isr_control_pipe[1] = -1;
93 dev->isr_thread_terminating = 0;
96 // then check to make sure the pin is exported.
97 char directory[MAX_SIZE];
98 snprintf(directory, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/", dev->pin);
100 if (stat(directory, &dir) == 0 && S_ISDIR(dir.st_mode)) {
101 dev->owner = 0; // Not Owner
103 int export = open(SYSFS_CLASS_GPIO "/export", O_WRONLY);
105 syslog(LOG_ERR, "gpio: Failed to open export for writing");
106 status = MRAA_ERROR_NO_RESOURCES;
107 goto init_internal_cleanup;
109 length = snprintf(bu, sizeof(bu), "%d", dev->pin);
110 if (write(export, bu, length * sizeof(char)) == -1) {
111 syslog(LOG_ERR, "gpio: Failed to write %d to export", dev->pin);
113 status = MRAA_ERROR_NO_RESOURCES;
114 goto init_internal_cleanup;
120 init_internal_cleanup:
121 if (status != MRAA_SUCCESS) {
130 mraa_gpio_init(int pin)
132 mraa_board_t* board = plat;
134 syslog(LOG_ERR, "gpio: platform not initialised");
138 if (mraa_is_sub_platform_id(pin)) {
139 syslog(LOG_NOTICE, "gpio: Using sub platform");
140 board = board->sub_platform;
142 syslog(LOG_ERR, "gpio: Sub platform Not Initialised");
145 pin = mraa_get_sub_platform_index(pin);
148 if (pin < 0 || pin > board->phy_pin_count) {
149 syslog(LOG_ERR, "gpio: pin %i beyond platform definition", pin);
152 if (board->pins[pin].capabilites.gpio != 1) {
153 syslog(LOG_ERR, "gpio: pin %i not capable of gpio", pin);
156 if (board->pins[pin].gpio.mux_total > 0) {
157 if (mraa_setup_mux_mapped(board->pins[pin].gpio) != MRAA_SUCCESS) {
158 syslog(LOG_ERR, "gpio: unable to setup muxes");
163 mraa_gpio_context r = mraa_gpio_init_internal(board->adv_func, board->pins[pin].gpio.pinmap);
165 syslog(LOG_CRIT, "gpio: mraa_gpio_init_raw(%d) returned error", pin);
170 if (IS_FUNC_DEFINED(r, gpio_init_post)) {
171 mraa_result_t ret = r->advance_func->gpio_init_post(r);
172 if (ret != MRAA_SUCCESS) {
181 mraa_gpio_init_raw(int pin)
183 return mraa_gpio_init_internal(plat == NULL ? NULL : plat->adv_func , pin);
188 mraa_gpio_wait_interrupt(int fd
189 #ifndef HAVE_PTHREAD_CANCEL
195 #ifdef HAVE_PTHREAD_CANCEL
196 struct pollfd pfd[1];
198 struct pollfd pfd[2];
200 if (control_fd < 0) {
201 return MRAA_ERROR_INVALID_RESOURCE;
206 return MRAA_ERROR_INVALID_RESOURCE;
209 // setup poll on POLLPRI
211 pfd[0].events = POLLPRI;
213 // do an initial read to clear interrupt
214 lseek(fd, 0, SEEK_SET);
217 #ifdef HAVE_PTHREAD_CANCEL
218 // Wait for it forever or until pthread_cancel
219 // poll is a cancelable point like sleep()
220 int x = poll(pfd, 1, -1);
222 // setup poll on the controling fd
223 pfd[1].fd = control_fd;
224 pfd[1].events = 0; // POLLHUP, POLLERR, and POLLNVAL
226 // Wait for it forever or until control fd is closed
227 int x = poll(pfd, 2, -1);
230 // do a final read to clear interrupt
237 mraa_gpio_interrupt_handler(void* arg)
239 mraa_gpio_context dev = (mraa_gpio_context) arg;
240 if (IS_FUNC_DEFINED(dev, gpio_interrupt_handler_replace))
241 return dev->advance_func->gpio_interrupt_handler_replace(dev);
245 // open gpio value with open(3)
247 sprintf(bu, SYSFS_CLASS_GPIO "/gpio%d/value", dev->pin);
248 int fp = open(bu, O_RDONLY);
250 syslog(LOG_ERR, "gpio: failed to open gpio%d/value", dev->pin);
254 #ifndef HAVE_PTHREAD_CANCEL
255 if (pipe(dev->isr_control_pipe)) {
256 syslog(LOG_ERR, "gpio: failed to create isr control pipe");
262 dev->isr_value_fp = fp;
265 ret = mraa_gpio_wait_interrupt(dev->isr_value_fp
266 #ifndef HAVE_PTHREAD_CANCEL
267 , dev->isr_control_pipe[0]
270 if (ret == MRAA_SUCCESS && !dev->isr_thread_terminating) {
271 #ifdef HAVE_PTHREAD_CANCEL
272 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
275 // In order to call a python object (all python functions are objects) we
276 // need to aquire the GIL (Global Interpreter Lock). This may not always be
277 // necessary but especially if doing IO (like print()) python will segfault
278 // if we do not hold a lock on the GIL
279 PyGILState_STATE gilstate = PyGILState_Ensure();
282 arglist = Py_BuildValue("(O)", dev->isr_args);
283 if (arglist == NULL) {
284 syslog(LOG_ERR, "gpio: Py_BuildValue NULL");
286 ret = PyEval_CallObject((PyObject*) dev->isr, arglist);
288 syslog(LOG_ERR, "gpio: PyEval_CallObject failed");
289 PyObject *pvalue, *ptype, *ptraceback;
290 PyObject *pvalue_pystr, *ptype_pystr, *ptraceback_pystr;
291 char *pvalue_cstr, *ptype_cstr, *ptraceback_cstr;
292 PyErr_Fetch(&pvalue, &ptype, &ptraceback);
293 pvalue_pystr = PyObject_Str(pvalue);
294 ptype_pystr = PyObject_Str(ptype);
295 ptraceback_pystr = PyObject_Str(ptraceback);
297 #if PY_VERSION_HEX < 0x03000000
298 pvalue_cstr = PyString_AsString(pvalue_pystr);
299 ptype_cstr = PyString_AsString(ptype_pystr);
300 ptraceback_cstr = PyString_AsString(ptraceback_pystr);
302 #elif PY_VERSION_HEX >= 0x03000000
303 // In Python 3 we need one extra conversion
304 PyObject *pvalue_ustr, *ptype_ustr, *ptraceback_ustr;
305 pvalue_ustr = PyUnicode_AsUTF8String(pvalue_pystr);
306 pvalue_cstr = PyBytes_AsString(pvalue_ustr);
307 ptype_ustr = PyUnicode_AsUTF8String(ptype_pystr);
308 ptype_cstr = PyBytes_AsString(ptype_ustr);
309 ptraceback_ustr = PyUnicode_AsUTF8String(ptraceback_pystr);
310 ptraceback_cstr = PyBytes_AsString(ptraceback_ustr);
311 #endif // PY_VERSION_HEX
312 syslog(LOG_ERR, "gpio: the error was %s:%s:%s",
319 Py_XDECREF(ptraceback);
320 Py_XDECREF(pvalue_pystr);
321 Py_XDECREF(ptype_pystr);
322 Py_XDECREF(ptraceback_pystr);
324 #if PY_VERSION_HEX >= 0x03000000
325 Py_XDECREF(pvalue_ustr);
326 Py_XDECREF(ptype_ustr);
327 Py_XDECREF(ptraceback_ustr);
328 #endif // PY_VERSION_HEX
335 PyGILState_Release(gilstate);
337 dev->isr(dev->isr_args);
339 #ifdef HAVE_PTHREAD_CANCEL
340 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
343 // we must have got an error code or exit request so die nicely
344 #ifdef HAVE_PTHREAD_CANCEL
345 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
347 close(dev->isr_value_fp);
348 dev->isr_value_fp = -1;
355 mraa_gpio_edge_mode(mraa_gpio_context dev, mraa_gpio_edge_t mode)
357 if (IS_FUNC_DEFINED(dev, gpio_edge_mode_replace))
358 return dev->advance_func->gpio_edge_mode_replace(dev, mode);
360 if (dev->value_fp != -1) {
361 close(dev->value_fp);
365 char filepath[MAX_SIZE];
366 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/edge", dev->pin);
368 int edge = open(filepath, O_RDWR);
370 syslog(LOG_ERR, "gpio: Failed to open edge for writing");
371 return MRAA_ERROR_INVALID_RESOURCE;
377 case MRAA_GPIO_EDGE_NONE:
378 length = snprintf(bu, sizeof(bu), "none");
380 case MRAA_GPIO_EDGE_BOTH:
381 length = snprintf(bu, sizeof(bu), "both");
383 case MRAA_GPIO_EDGE_RISING:
384 length = snprintf(bu, sizeof(bu), "rising");
386 case MRAA_GPIO_EDGE_FALLING:
387 length = snprintf(bu, sizeof(bu), "falling");
391 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
393 if (write(edge, bu, length * sizeof(char)) == -1) {
394 syslog(LOG_ERR, "gpio: Failed to write to edge");
396 return MRAA_ERROR_INVALID_RESOURCE;
404 mraa_gpio_isr(mraa_gpio_context dev, mraa_gpio_edge_t mode, void (*fptr)(void*), void* args)
406 // we only allow one isr per mraa_gpio_context
407 if (dev->thread_id != 0) {
408 return MRAA_ERROR_NO_RESOURCES;
411 if (MRAA_SUCCESS != mraa_gpio_edge_mode(dev, mode)) {
412 return MRAA_ERROR_UNSPECIFIED;
416 dev->isr_args = args;
417 pthread_create(&dev->thread_id, NULL, mraa_gpio_interrupt_handler, (void*) dev);
423 mraa_gpio_isr_exit(mraa_gpio_context dev)
425 mraa_result_t ret = MRAA_SUCCESS;
427 // wasting our time, there is no isr to exit from
428 if (dev->thread_id == 0 && dev->isr_value_fp == -1) {
431 // mark the beginning of the thread termination process for interested parties
432 dev->isr_thread_terminating = 1;
434 // stop isr being useful
435 ret = mraa_gpio_edge_mode(dev, MRAA_GPIO_EDGE_NONE);
437 if ((dev->thread_id != 0)) {
438 #ifdef HAVE_PTHREAD_CANCEL
439 if ((pthread_cancel(dev->thread_id) != 0) || (pthread_join(dev->thread_id, NULL) != 0)) {
440 ret = MRAA_ERROR_INVALID_HANDLE;
443 close(dev->isr_control_pipe[1]);
444 if (pthread_join(dev->thread_id, NULL) != 0)
445 ret = MRAA_ERROR_INVALID_HANDLE;
447 close(dev->isr_control_pipe[0]);
448 dev->isr_control_pipe[0] = dev->isr_control_pipe[1] = -1;
452 // close the filehandle in case it's still open
453 if (dev->isr_value_fp != -1) {
454 if (close(dev->isr_value_fp) != 0) {
455 ret = MRAA_ERROR_INVALID_PARAMETER;
459 // assume our thread will exit either way we just lost it's handle
461 dev->isr_value_fp = -1;
462 dev->isr_thread_terminating = 0;
467 mraa_gpio_mode(mraa_gpio_context dev, mraa_gpio_mode_t mode)
469 if (IS_FUNC_DEFINED(dev, gpio_mode_replace))
470 return dev->advance_func->gpio_mode_replace(dev, mode);
472 if (IS_FUNC_DEFINED(dev, gpio_mode_pre)) {
473 mraa_result_t pre_ret = (dev->advance_func->gpio_mode_pre(dev, mode));
474 if (pre_ret != MRAA_SUCCESS)
478 if (dev->value_fp != -1) {
479 close(dev->value_fp);
483 char filepath[MAX_SIZE];
484 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/drive", dev->pin);
486 int drive = open(filepath, O_WRONLY);
488 syslog(LOG_ERR, "gpio: Failed to open drive for writing");
489 return MRAA_ERROR_INVALID_RESOURCE;
495 case MRAA_GPIO_STRONG:
496 length = snprintf(bu, sizeof(bu), "strong");
498 case MRAA_GPIO_PULLUP:
499 length = snprintf(bu, sizeof(bu), "pullup");
501 case MRAA_GPIO_PULLDOWN:
502 length = snprintf(bu, sizeof(bu), "pulldown");
505 length = snprintf(bu, sizeof(bu), "hiz");
509 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
511 if (write(drive, bu, length * sizeof(char)) == -1) {
512 syslog(LOG_ERR, "gpio: Failed to write to drive mode");
514 return MRAA_ERROR_INVALID_RESOURCE;
518 if (IS_FUNC_DEFINED(dev, gpio_mode_post))
519 return dev->advance_func->gpio_mode_post(dev, mode);
524 mraa_gpio_dir(mraa_gpio_context dev, mraa_gpio_dir_t dir)
526 if (IS_FUNC_DEFINED(dev, gpio_dir_replace)) {
527 return dev->advance_func->gpio_dir_replace(dev, dir);
530 if (IS_FUNC_DEFINED(dev, gpio_dir_pre)) {
531 mraa_result_t pre_ret = (dev->advance_func->gpio_dir_pre(dev, dir));
532 if (pre_ret != MRAA_SUCCESS) {
538 return MRAA_ERROR_INVALID_HANDLE;
540 if (dev->value_fp != -1) {
541 close(dev->value_fp);
544 char filepath[MAX_SIZE];
545 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/direction", dev->pin);
547 int direction = open(filepath, O_RDWR);
549 if (direction == -1) {
550 // Direction Failed to Open. If HIGH or LOW was passed will try and set
551 // If not fail as usual.
553 case MRAA_GPIO_OUT_HIGH:
554 return mraa_gpio_write(dev, 1);
555 case MRAA_GPIO_OUT_LOW:
556 return mraa_gpio_write(dev, 0);
558 return MRAA_ERROR_INVALID_RESOURCE;
566 length = snprintf(bu, sizeof(bu), "out");
569 length = snprintf(bu, sizeof(bu), "in");
571 case MRAA_GPIO_OUT_HIGH:
572 length = snprintf(bu, sizeof(bu), "high");
574 case MRAA_GPIO_OUT_LOW:
575 length = snprintf(bu, sizeof(bu), "low");
579 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
582 if (write(direction, bu, length * sizeof(char)) == -1) {
584 return MRAA_ERROR_INVALID_RESOURCE;
588 if (IS_FUNC_DEFINED(dev, gpio_dir_post))
589 return dev->advance_func->gpio_dir_post(dev, dir);
594 mraa_gpio_read(mraa_gpio_context dev)
599 if (IS_FUNC_DEFINED(dev, gpio_read_replace))
600 return dev->advance_func->gpio_read_replace(dev);
602 if (dev->mmap_read != NULL)
603 return dev->mmap_read(dev);
605 if (dev->value_fp == -1) {
606 if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
607 syslog(LOG_ERR, "gpio: Failed to get value file pointer");
611 // if value_fp is new this is pointless
612 lseek(dev->value_fp, 0, SEEK_SET);
615 if (read(dev->value_fp, bu, 2 * sizeof(char)) != 2) {
616 syslog(LOG_ERR, "gpio: Failed to read a sensible value from sysfs");
619 lseek(dev->value_fp, 0, SEEK_SET);
621 return (int) strtol(bu, NULL, 10);
625 mraa_gpio_write(mraa_gpio_context dev, int value)
628 return MRAA_ERROR_INVALID_HANDLE;
630 if (dev->mmap_write != NULL)
631 return dev->mmap_write(dev, value);
633 if (IS_FUNC_DEFINED(dev, gpio_write_pre)) {
634 mraa_result_t pre_ret = (dev->advance_func->gpio_write_pre(dev, value));
635 if (pre_ret != MRAA_SUCCESS)
639 if (IS_FUNC_DEFINED(dev, gpio_write_replace)) {
640 return dev->advance_func->gpio_write_replace(dev, value);
643 if (dev->value_fp == -1) {
644 if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
645 return MRAA_ERROR_INVALID_RESOURCE;
649 if (lseek(dev->value_fp, 0, SEEK_SET) == -1) {
650 return MRAA_ERROR_INVALID_RESOURCE;
654 int length = snprintf(bu, sizeof(bu), "%d", value);
655 if (write(dev->value_fp, bu, length * sizeof(char)) == -1) {
656 return MRAA_ERROR_INVALID_HANDLE;
659 if (IS_FUNC_DEFINED(dev, gpio_write_post))
660 return dev->advance_func->gpio_write_post(dev, value);
665 mraa_gpio_unexport_force(mraa_gpio_context dev)
667 int unexport = open(SYSFS_CLASS_GPIO "/unexport", O_WRONLY);
668 if (unexport == -1) {
669 syslog(LOG_ERR, "gpio: Failed to open unexport for writing");
670 return MRAA_ERROR_INVALID_RESOURCE;
674 int length = snprintf(bu, sizeof(bu), "%d", dev->pin);
675 if (write(unexport, bu, length * sizeof(char)) == -1) {
676 syslog(LOG_ERR, "gpio: Failed to write to unexport");
678 return MRAA_ERROR_INVALID_RESOURCE;
682 mraa_gpio_isr_exit(dev);
686 mraa_gpio_unexport(mraa_gpio_context dev)
689 return mraa_gpio_unexport_force(dev);
691 return MRAA_ERROR_INVALID_RESOURCE;
695 mraa_gpio_close(mraa_gpio_context dev)
697 mraa_result_t result = MRAA_SUCCESS;
699 if (IS_FUNC_DEFINED(dev, gpio_close_pre)) {
700 result = dev->advance_func->gpio_close_pre(dev);
703 if (dev->value_fp != -1) {
704 close(dev->value_fp);
706 mraa_gpio_unexport(dev);
712 mraa_gpio_owner(mraa_gpio_context dev, mraa_boolean_t own)
715 return MRAA_ERROR_INVALID_RESOURCE;
717 syslog(LOG_DEBUG, "gpio: Set owner to %d", (int) own);
723 mraa_gpio_use_mmaped(mraa_gpio_context dev, mraa_boolean_t mmap_en)
725 if (IS_FUNC_DEFINED(dev, gpio_mmap_setup)) {
726 return dev->advance_func->gpio_mmap_setup(dev, mmap_en);
729 syslog(LOG_ERR, "gpio: mmap not implemented on this platform");
730 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
734 mraa_gpio_get_pin(mraa_gpio_context dev)
737 syslog(LOG_ERR, "gpio: context is invalid");
744 mraa_gpio_get_pin_raw(mraa_gpio_context dev)
747 syslog(LOG_ERR, "gpio: context is invalid");