/*
* Author: Thomas Ingleby <thomas.c.ingleby@intel.com>
* Author: Brendan Le Foll <brendan.le.foll@intel.com>
- * Copyright (c) 2014 Intel Corporation.
+ * Copyright (c) 2014, 2015 Intel Corporation.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "gpio.h"
+#include "mraa_internal.h"
#include <stdlib.h>
#include <fcntl.h>
#include <poll.h>
#include <pthread.h>
#include <signal.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
#define SYSFS_CLASS_GPIO "/sys/class/gpio"
#define MAX_SIZE 64
#define POLL_TIMEOUT
-static maa_result_t
-maa_gpio_get_valfp(maa_gpio_context *dev)
+static mraa_result_t
+mraa_gpio_get_valfp(mraa_gpio_context dev)
{
char bu[MAX_SIZE];
sprintf(bu, SYSFS_CLASS_GPIO "/gpio%d/value", dev->pin);
-
dev->value_fp = open(bu, O_RDWR);
if (dev->value_fp == -1) {
- return MAA_ERROR_INVALID_RESOURCE;
+ return MRAA_ERROR_INVALID_RESOURCE;
}
- return MAA_SUCCESS;
+ return MRAA_SUCCESS;
}
-maa_gpio_context*
-maa_gpio_init(int pin)
+static mraa_gpio_context
+mraa_gpio_init_internal(mraa_adv_func_t* func_table, int pin)
{
- int pinm = maa_check_gpio(pin);
- if (pinm < 0)
+ if (pin < 0)
+ return NULL;
+
+ mraa_result_t status = MRAA_SUCCESS;
+ char bu[MAX_SIZE];
+ int length;
+
+ mraa_gpio_context dev = (mraa_gpio_context) calloc(1, sizeof(struct _gpio));
+ if (dev == NULL) {
+ syslog(LOG_CRIT, "gpio: Failed to allocate memory for context");
return NULL;
+ }
- return maa_gpio_init_raw(pinm);
+ dev->advance_func = func_table;
+ dev->pin = pin;
+
+ if (IS_FUNC_DEFINED(dev, gpio_init_internal_replace)) {
+ status = dev->advance_func->gpio_init_internal_replace(pin);
+ if (status == MRAA_SUCCESS)
+ return dev;
+ else
+ goto init_internal_cleanup;
+ }
+
+ if (IS_FUNC_DEFINED(dev, gpio_init_pre)) {
+ status = dev->advance_func->gpio_init_pre(pin);
+ if (status != MRAA_SUCCESS)
+ goto init_internal_cleanup;
+ }
+
+ dev->value_fp = -1;
+ dev->isr_value_fp = -1;
+#ifndef HAVE_PTHREAD_CANCEL
+ dev->isr_control_pipe[0] = dev->isr_control_pipe[1] = -1;
+#endif
+ dev->isr_thread_terminating = 0;
+ dev->phy_pin = -1;
+
+ // then check to make sure the pin is exported.
+ char directory[MAX_SIZE];
+ snprintf(directory, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/", dev->pin);
+ struct stat dir;
+ if (stat(directory, &dir) == 0 && S_ISDIR(dir.st_mode)) {
+ dev->owner = 0; // Not Owner
+ } else {
+ int export = open(SYSFS_CLASS_GPIO "/export", O_WRONLY);
+ if (export == -1) {
+ syslog(LOG_ERR, "gpio: Failed to open export for writing");
+ status = MRAA_ERROR_NO_RESOURCES;
+ goto init_internal_cleanup;
+ }
+ length = snprintf(bu, sizeof(bu), "%d", dev->pin);
+ if (write(export, bu, length * sizeof(char)) == -1) {
+ syslog(LOG_ERR, "gpio: Failed to write %d to export", dev->pin);
+ close(export);
+ status = MRAA_ERROR_NO_RESOURCES;
+ goto init_internal_cleanup;
+ }
+ dev->owner = 1;
+ close(export);
+ }
+
+init_internal_cleanup:
+ if (status != MRAA_SUCCESS) {
+ if (dev != NULL)
+ free(dev);
+ return NULL;
+ }
+ return dev;
}
-maa_gpio_context*
-maa_gpio_init_raw(int pin)
+mraa_gpio_context
+mraa_gpio_init(int pin)
{
- if (pin < 0)
+ mraa_board_t* board = plat;
+ if (board == NULL) {
+ syslog(LOG_ERR, "gpio: platform not initialised");
return NULL;
+ }
- FILE *export_f;
- char bu[MAX_SIZE];
- int length;
+ if (mraa_is_sub_platform_id(pin)) {
+ syslog(LOG_NOTICE, "gpio: Using sub platform");
+ board = board->sub_platform;
+ if (board == NULL) {
+ syslog(LOG_ERR, "gpio: Sub platform Not Initialised");
+ return NULL;
+ }
+ pin = mraa_get_sub_platform_index(pin);
+ }
- maa_gpio_context* dev = (maa_gpio_context*) malloc(sizeof(maa_gpio_context));
- memset(dev, 0, sizeof(maa_gpio_context));
- dev->value_fp = -1;
- dev->pin = pin;
+ if (pin < 0 || pin > board->phy_pin_count) {
+ syslog(LOG_ERR, "gpio: pin %i beyond platform definition", pin);
+ return NULL;
+ }
+ if (board->pins[pin].capabilites.gpio != 1) {
+ syslog(LOG_ERR, "gpio: pin %i not capable of gpio", pin);
+ return NULL;
+ }
+ if (board->pins[pin].gpio.mux_total > 0) {
+ if (mraa_setup_mux_mapped(board->pins[pin].gpio) != MRAA_SUCCESS) {
+ syslog(LOG_ERR, "gpio: unable to setup muxes");
+ return NULL;
+ }
+ }
- if ((export_f = fopen(SYSFS_CLASS_GPIO "/export", "w")) == NULL) {
- fprintf(stderr, "Failed to open export for writing!\n");
+ mraa_gpio_context r = mraa_gpio_init_internal(board->adv_func, board->pins[pin].gpio.pinmap);
+ if (r == NULL) {
+ syslog(LOG_CRIT, "gpio: mraa_gpio_init_raw(%d) returned error", pin);
return NULL;
}
- length = snprintf(bu, sizeof(bu), "%d", dev->pin);
- fwrite(bu, sizeof(char), length, export_f);
+ r->phy_pin = pin;
- fclose(export_f);
- return dev;
+ if (IS_FUNC_DEFINED(r, gpio_init_post)) {
+ mraa_result_t ret = r->advance_func->gpio_init_post(r);
+ if (ret != MRAA_SUCCESS) {
+ free(r);
+ return NULL;
+ }
+ }
+ return r;
}
-static maa_result_t
-maa_gpio_wait_interrupt(int fd)
+mraa_gpio_context
+mraa_gpio_init_raw(int pin)
+{
+ return mraa_gpio_init_internal(plat == NULL ? NULL : plat->adv_func , pin);
+}
+
+
+static mraa_result_t
+mraa_gpio_wait_interrupt(int fd
+#ifndef HAVE_PTHREAD_CANCEL
+ , int control_fd
+#endif
+ )
{
unsigned char c;
- struct pollfd pfd;
+#ifdef HAVE_PTHREAD_CANCEL
+ struct pollfd pfd[1];
+#else
+ struct pollfd pfd[2];
+
+ if (control_fd < 0) {
+ return MRAA_ERROR_INVALID_RESOURCE;
+ }
+#endif
+
+ if (fd < 0) {
+ return MRAA_ERROR_INVALID_RESOURCE;
+ }
// setup poll on POLLPRI
- pfd.fd = fd;
- pfd.events = POLLPRI;
+ pfd[0].fd = fd;
+ pfd[0].events = POLLPRI;
- // do an initial read to clear interupt
- read (fd, &c, 1);
+ // do an initial read to clear interrupt
+ lseek(fd, 0, SEEK_SET);
+ read(fd, &c, 1);
- if (fd <= 0) {
- return MAA_ERROR_INVALID_RESOURCE;
- }
+#ifdef HAVE_PTHREAD_CANCEL
+ // Wait for it forever or until pthread_cancel
+ // poll is a cancelable point like sleep()
+ int x = poll(pfd, 1, -1);
+#else
+ // setup poll on the controling fd
+ pfd[1].fd = control_fd;
+ pfd[1].events = 0; // POLLHUP, POLLERR, and POLLNVAL
- // Wait for it forever
- int x = poll (&pfd, 1, -1);
+ // Wait for it forever or until control fd is closed
+ int x = poll(pfd, 2, -1);
+#endif
- // do a final read to clear interupt
- read (fd, &c, 1);
+ // do a final read to clear interrupt
+ read(fd, &c, 1);
- return MAA_SUCCESS;
+ return MRAA_SUCCESS;
}
static void*
-maa_gpio_interrupt_handler(void* arg)
+mraa_gpio_interrupt_handler(void* arg)
{
- maa_gpio_context* dev = (maa_gpio_context*) arg;
- maa_result_t ret;
+ mraa_gpio_context dev = (mraa_gpio_context) arg;
+ if (IS_FUNC_DEFINED(dev, gpio_interrupt_handler_replace))
+ return dev->advance_func->gpio_interrupt_handler_replace(dev);
+
+ mraa_result_t ret;
// open gpio value with open(3)
char bu[MAX_SIZE];
sprintf(bu, SYSFS_CLASS_GPIO "/gpio%d/value", dev->pin);
- dev->isr_value_fp = open(bu, O_RDONLY);
+ int fp = open(bu, O_RDONLY);
+ if (fp < 0) {
+ syslog(LOG_ERR, "gpio: failed to open gpio%d/value", dev->pin);
+ return NULL;
+ }
+
+#ifndef HAVE_PTHREAD_CANCEL
+ if (pipe(dev->isr_control_pipe)) {
+ syslog(LOG_ERR, "gpio: failed to create isr control pipe");
+ close(fp);
+ return NULL;
+ }
+#endif
+
+ dev->isr_value_fp = fp;
for (;;) {
- ret = maa_gpio_wait_interrupt(dev->isr_value_fp);
- if (ret == MAA_SUCCESS) {
+ ret = mraa_gpio_wait_interrupt(dev->isr_value_fp
+#ifndef HAVE_PTHREAD_CANCEL
+ , dev->isr_control_pipe[0]
+#endif
+ );
+ if (ret == MRAA_SUCCESS && !dev->isr_thread_terminating) {
+#ifdef HAVE_PTHREAD_CANCEL
+ pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+#endif
#ifdef SWIGPYTHON
// In order to call a python object (all python functions are objects) we
// need to aquire the GIL (Global Interpreter Lock). This may not always be
- // nessecary but especially if doing IO (like print()) python will segfault
+ // necessary but especially if doing IO (like print()) python will segfault
// if we do not hold a lock on the GIL
PyGILState_STATE gilstate = PyGILState_Ensure();
-
- PyEval_CallObject(dev->isr, NULL);
-
- PyGILState_Release (gilstate);
+ PyObject* arglist;
+ PyObject* ret;
+ arglist = Py_BuildValue("(O)", dev->isr_args);
+ if (arglist == NULL) {
+ syslog(LOG_ERR, "gpio: Py_BuildValue NULL");
+ } else {
+ ret = PyEval_CallObject((PyObject*) dev->isr, arglist);
+ if (ret == NULL) {
+ syslog(LOG_ERR, "gpio: PyEval_CallObject failed");
+ PyObject *pvalue, *ptype, *ptraceback;
+ PyObject *pvalue_pystr, *ptype_pystr, *ptraceback_pystr;
+ char *pvalue_cstr, *ptype_cstr, *ptraceback_cstr;
+ PyErr_Fetch(&pvalue, &ptype, &ptraceback);
+ pvalue_pystr = PyObject_Str(pvalue);
+ ptype_pystr = PyObject_Str(ptype);
+ ptraceback_pystr = PyObject_Str(ptraceback);
+// Python2
+#if PY_VERSION_HEX < 0x03000000
+ pvalue_cstr = PyString_AsString(pvalue_pystr);
+ ptype_cstr = PyString_AsString(ptype_pystr);
+ ptraceback_cstr = PyString_AsString(ptraceback_pystr);
+// Python 3 and up
+#elif PY_VERSION_HEX >= 0x03000000
+ // In Python 3 we need one extra conversion
+ PyObject *pvalue_ustr, *ptype_ustr, *ptraceback_ustr;
+ pvalue_ustr = PyUnicode_AsUTF8String(pvalue_pystr);
+ pvalue_cstr = PyBytes_AsString(pvalue_ustr);
+ ptype_ustr = PyUnicode_AsUTF8String(ptype_pystr);
+ ptype_cstr = PyBytes_AsString(ptype_ustr);
+ ptraceback_ustr = PyUnicode_AsUTF8String(ptraceback_pystr);
+ ptraceback_cstr = PyBytes_AsString(ptraceback_ustr);
+#endif // PY_VERSION_HEX
+ syslog(LOG_ERR, "gpio: the error was %s:%s:%s",
+ pvalue_cstr,
+ ptype_cstr,
+ ptraceback_cstr
+ );
+ Py_XDECREF(pvalue);
+ Py_XDECREF(ptype);
+ Py_XDECREF(ptraceback);
+ Py_XDECREF(pvalue_pystr);
+ Py_XDECREF(ptype_pystr);
+ Py_XDECREF(ptraceback_pystr);
+// Python 3 and up
+#if PY_VERSION_HEX >= 0x03000000
+ Py_XDECREF(pvalue_ustr);
+ Py_XDECREF(ptype_ustr);
+ Py_XDECREF(ptraceback_ustr);
+#endif // PY_VERSION_HEX
+ } else {
+ Py_DECREF(ret);
+ }
+ Py_DECREF(arglist);
+ }
+
+ PyGILState_Release(gilstate);
#else
- dev->isr();
+ dev->isr(dev->isr_args);
+#endif
+#ifdef HAVE_PTHREAD_CANCEL
+ pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
#endif
} else {
- // we must have got an error code so die nicely
+ // we must have got an error code or exit request so die nicely
+#ifdef HAVE_PTHREAD_CANCEL
+ pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+#endif
close(dev->isr_value_fp);
- return NULL;
+ dev->isr_value_fp = -1;
+ return NULL;
}
}
}
-maa_result_t
-maa_gpio_edge_mode(maa_gpio_context *dev, gpio_edge_t mode)
+mraa_result_t
+mraa_gpio_edge_mode(mraa_gpio_context dev, mraa_gpio_edge_t mode)
{
+ if (IS_FUNC_DEFINED(dev, gpio_edge_mode_replace))
+ return dev->advance_func->gpio_edge_mode_replace(dev, mode);
+
if (dev->value_fp != -1) {
- close(dev->value_fp);
- dev->value_fp = -1;
+ close(dev->value_fp);
+ dev->value_fp = -1;
}
char filepath[MAX_SIZE];
snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/edge", dev->pin);
- FILE *edge;
- if ((edge= fopen(filepath, "w")) == NULL) {
- fprintf(stderr, "Failed to open edge for writing!\n");
- return MAA_ERROR_INVALID_RESOURCE;
+ int edge = open(filepath, O_RDWR);
+ if (edge == -1) {
+ syslog(LOG_ERR, "gpio: Failed to open edge for writing");
+ return MRAA_ERROR_INVALID_RESOURCE;
}
char bu[MAX_SIZE];
int length;
- switch(mode) {
- case MAA_GPIO_EDGE_NONE:
+ switch (mode) {
+ case MRAA_GPIO_EDGE_NONE:
length = snprintf(bu, sizeof(bu), "none");
break;
- case MAA_GPIO_EDGE_BOTH:
+ case MRAA_GPIO_EDGE_BOTH:
length = snprintf(bu, sizeof(bu), "both");
break;
- case MAA_GPIO_EDGE_RISING:
+ case MRAA_GPIO_EDGE_RISING:
length = snprintf(bu, sizeof(bu), "rising");
break;
- case MAA_GPIO_EDGE_FALLING:
+ case MRAA_GPIO_EDGE_FALLING:
length = snprintf(bu, sizeof(bu), "falling");
break;
default:
- fclose(edge);
- return MAA_ERROR_FEATURE_NOT_IMPLEMENTED;
+ close(edge);
+ return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
+ }
+ if (write(edge, bu, length * sizeof(char)) == -1) {
+ syslog(LOG_ERR, "gpio: Failed to write to edge");
+ close(edge);
+ return MRAA_ERROR_INVALID_RESOURCE;
}
- fwrite(bu, sizeof(char), length, edge);
- fclose(edge);
- return MAA_SUCCESS;
+ close(edge);
+ return MRAA_SUCCESS;
}
-maa_result_t
-maa_gpio_isr(maa_gpio_context *dev, gpio_edge_t mode, void (*fptr)(void))
+mraa_result_t
+mraa_gpio_isr(mraa_gpio_context dev, mraa_gpio_edge_t mode, void (*fptr)(void*), void* args)
{
- maa_gpio_edge_mode(dev, mode);
+ // we only allow one isr per mraa_gpio_context
+ if (dev->thread_id != 0) {
+ return MRAA_ERROR_NO_RESOURCES;
+ }
+
+ if (MRAA_SUCCESS != mraa_gpio_edge_mode(dev, mode)) {
+ return MRAA_ERROR_UNSPECIFIED;
+ }
+
dev->isr = fptr;
- pthread_create (&dev->thread_id, NULL, maa_gpio_interrupt_handler, (void *) dev);
+ dev->isr_args = args;
+ pthread_create(&dev->thread_id, NULL, mraa_gpio_interrupt_handler, (void*) dev);
- return MAA_SUCCESS;
+ return MRAA_SUCCESS;
}
-maa_result_t
-maa_gpio_isr_exit(maa_gpio_context *dev)
+mraa_result_t
+mraa_gpio_isr_exit(mraa_gpio_context dev)
{
- maa_result_t ret = MAA_SUCCESS;
-
-#ifdef SWIGPYTHON
- // Dereference our Python call back function
- Py_DECREF(dev->isr);
-#endif
+ mraa_result_t ret = MRAA_SUCCESS;
- if (dev->thread_id == 0) {
+ // wasting our time, there is no isr to exit from
+ if (dev->thread_id == 0 && dev->isr_value_fp == -1) {
return ret;
}
+ // mark the beginning of the thread termination process for interested parties
+ dev->isr_thread_terminating = 1;
- if (pthread_kill(dev->thread_id, SIGTERM) != 0) {
- ret = MAA_ERROR_INVALID_HANDLE;
- }
- if (close(dev->isr_value_fp) != 0) {
- ret = MAA_ERROR_INVALID_PARAMETER;
+ // stop isr being useful
+ ret = mraa_gpio_edge_mode(dev, MRAA_GPIO_EDGE_NONE);
+
+ if ((dev->thread_id != 0)) {
+#ifdef HAVE_PTHREAD_CANCEL
+ if ((pthread_cancel(dev->thread_id) != 0) || (pthread_join(dev->thread_id, NULL) != 0)) {
+ ret = MRAA_ERROR_INVALID_HANDLE;
+ }
+#else
+ close(dev->isr_control_pipe[1]);
+ if (pthread_join(dev->thread_id, NULL) != 0)
+ ret = MRAA_ERROR_INVALID_HANDLE;
+
+ close(dev->isr_control_pipe[0]);
+ dev->isr_control_pipe[0] = dev->isr_control_pipe[1] = -1;
+#endif
}
- // this is only required if we had an isr setup
- if (ret == MAA_SUCCESS) {
- ret = maa_gpio_edge_mode(dev, MAA_GPIO_EDGE_NONE);
+ // close the filehandle in case it's still open
+ if (dev->isr_value_fp != -1) {
+ if (close(dev->isr_value_fp) != 0) {
+ ret = MRAA_ERROR_INVALID_PARAMETER;
+ }
}
+ // assume our thread will exit either way we just lost it's handle
+ dev->thread_id = 0;
+ dev->isr_value_fp = -1;
+ dev->isr_thread_terminating = 0;
return ret;
}
-maa_result_t
-maa_gpio_mode(maa_gpio_context *dev, gpio_mode_t mode)
+mraa_result_t
+mraa_gpio_mode(mraa_gpio_context dev, mraa_gpio_mode_t mode)
{
+ if (IS_FUNC_DEFINED(dev, gpio_mode_replace))
+ return dev->advance_func->gpio_mode_replace(dev, mode);
+
+ if (IS_FUNC_DEFINED(dev, gpio_mode_pre)) {
+ mraa_result_t pre_ret = (dev->advance_func->gpio_mode_pre(dev, mode));
+ if (pre_ret != MRAA_SUCCESS)
+ return pre_ret;
+ }
+
if (dev->value_fp != -1) {
- close(dev->value_fp);
- dev->value_fp = -1;
+ close(dev->value_fp);
+ dev->value_fp = -1;
}
char filepath[MAX_SIZE];
snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/drive", dev->pin);
- FILE *drive;
- if ((drive = fopen(filepath, "w")) == NULL) {
- fprintf(stderr, "Failed to open drive for writing!\n");
- return MAA_ERROR_INVALID_RESOURCE;
+ int drive = open(filepath, O_WRONLY);
+ if (drive == -1) {
+ syslog(LOG_ERR, "gpio: Failed to open drive for writing");
+ return MRAA_ERROR_INVALID_RESOURCE;
}
char bu[MAX_SIZE];
int length;
- switch(mode) {
- case MAA_GPIO_STRONG:
+ switch (mode) {
+ case MRAA_GPIO_STRONG:
length = snprintf(bu, sizeof(bu), "strong");
break;
- case MAA_GPIO_PULLUP:
+ case MRAA_GPIO_PULLUP:
length = snprintf(bu, sizeof(bu), "pullup");
break;
- case MAA_GPIO_PULLDOWN:
+ case MRAA_GPIO_PULLDOWN:
length = snprintf(bu, sizeof(bu), "pulldown");
break;
- case MAA_GPIO_HIZ:
+ case MRAA_GPIO_HIZ:
length = snprintf(bu, sizeof(bu), "hiz");
break;
default:
- fclose(drive);
- return MAA_ERROR_FEATURE_NOT_IMPLEMENTED;
+ close(drive);
+ return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
+ }
+ if (write(drive, bu, length * sizeof(char)) == -1) {
+ syslog(LOG_ERR, "gpio: Failed to write to drive mode");
+ close(drive);
+ return MRAA_ERROR_INVALID_RESOURCE;
}
- fwrite(bu, sizeof(char), length, drive);
- fclose(drive);
- return MAA_SUCCESS;
+ close(drive);
+ if (IS_FUNC_DEFINED(dev, gpio_mode_post))
+ return dev->advance_func->gpio_mode_post(dev, mode);
+ return MRAA_SUCCESS;
}
-maa_result_t
-maa_gpio_dir(maa_gpio_context *dev, gpio_dir_t dir)
+mraa_result_t
+mraa_gpio_dir(mraa_gpio_context dev, mraa_gpio_dir_t dir)
{
+ if (IS_FUNC_DEFINED(dev, gpio_dir_replace)) {
+ return dev->advance_func->gpio_dir_replace(dev, dir);
+ }
+
+ if (IS_FUNC_DEFINED(dev, gpio_dir_pre)) {
+ mraa_result_t pre_ret = (dev->advance_func->gpio_dir_pre(dev, dir));
+ if (pre_ret != MRAA_SUCCESS) {
+ return pre_ret;
+ }
+ }
+
if (dev == NULL) {
- return MAA_ERROR_INVALID_HANDLE;
+ return MRAA_ERROR_INVALID_HANDLE;
}
if (dev->value_fp != -1) {
- close(dev->value_fp);
- dev->value_fp = -1;
+ close(dev->value_fp);
+ dev->value_fp = -1;
}
char filepath[MAX_SIZE];
snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/direction", dev->pin);
- FILE *direction;
- if ((direction = fopen(filepath, "w")) == NULL) {
- fprintf(stderr, "Failed to open direction for writing!\n");
- return MAA_ERROR_INVALID_RESOURCE;
+ int direction = open(filepath, O_RDWR);
+
+ if (direction == -1) {
+ // Direction Failed to Open. If HIGH or LOW was passed will try and set
+ // If not fail as usual.
+ switch (dir) {
+ case MRAA_GPIO_OUT_HIGH:
+ return mraa_gpio_write(dev, 1);
+ case MRAA_GPIO_OUT_LOW:
+ return mraa_gpio_write(dev, 0);
+ default:
+ return MRAA_ERROR_INVALID_RESOURCE;
+ }
}
char bu[MAX_SIZE];
int length;
- switch(dir) {
- case MAA_GPIO_OUT:
+ switch (dir) {
+ case MRAA_GPIO_OUT:
length = snprintf(bu, sizeof(bu), "out");
break;
- case MAA_GPIO_IN:
+ case MRAA_GPIO_IN:
length = snprintf(bu, sizeof(bu), "in");
break;
+ case MRAA_GPIO_OUT_HIGH:
+ length = snprintf(bu, sizeof(bu), "high");
+ break;
+ case MRAA_GPIO_OUT_LOW:
+ length = snprintf(bu, sizeof(bu), "low");
+ break;
default:
- fclose(direction);
- return MAA_ERROR_FEATURE_NOT_IMPLEMENTED;
+ close(direction);
+ return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
+ }
+
+ if (write(direction, bu, length * sizeof(char)) == -1) {
+ close(direction);
+ return MRAA_ERROR_INVALID_RESOURCE;
}
- fwrite(bu, sizeof(char), length, direction);
- fclose(direction);
- return MAA_SUCCESS;
+ close(direction);
+ if (IS_FUNC_DEFINED(dev, gpio_dir_post))
+ return dev->advance_func->gpio_dir_post(dev, dir);
+ return MRAA_SUCCESS;
}
int
-maa_gpio_read(maa_gpio_context *dev)
+mraa_gpio_read(mraa_gpio_context dev)
{
+ if (dev == NULL)
+ return -1;
+
+ if (IS_FUNC_DEFINED(dev, gpio_read_replace))
+ return dev->advance_func->gpio_read_replace(dev);
+
+ if (dev->mmap_read != NULL)
+ return dev->mmap_read(dev);
+
if (dev->value_fp == -1) {
- if (maa_gpio_get_valfp(dev) != MAA_SUCCESS) {
- fprintf(stderr, "Failed to get value file pointer\n");
+ if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
+ syslog(LOG_ERR, "gpio: Failed to get value file pointer");
+ return -1;
}
- }
- else {
+ } else {
// if value_fp is new this is pointless
lseek(dev->value_fp, 0, SEEK_SET);
}
char bu[2];
- if (read(dev->value_fp, bu, 2*sizeof(char)) != 2) {
- fprintf(stderr, "Failed to read a sensible value from sysfs");
+ if (read(dev->value_fp, bu, 2 * sizeof(char)) != 2) {
+ syslog(LOG_ERR, "gpio: Failed to read a sensible value from sysfs");
+ return -1;
}
lseek(dev->value_fp, 0, SEEK_SET);
- int ret = strtol(bu, NULL, 10);
- return ret;
+ return (int) strtol(bu, NULL, 10);
}
-maa_result_t
-maa_gpio_write(maa_gpio_context *dev, int value)
+mraa_result_t
+mraa_gpio_write(mraa_gpio_context dev, int value)
{
+ if (dev == NULL)
+ return MRAA_ERROR_INVALID_HANDLE;
+
+ if (dev->mmap_write != NULL)
+ return dev->mmap_write(dev, value);
+
+ if (IS_FUNC_DEFINED(dev, gpio_write_pre)) {
+ mraa_result_t pre_ret = (dev->advance_func->gpio_write_pre(dev, value));
+ if (pre_ret != MRAA_SUCCESS)
+ return pre_ret;
+ }
+
+ if (IS_FUNC_DEFINED(dev, gpio_write_replace)) {
+ return dev->advance_func->gpio_write_replace(dev, value);
+ }
+
if (dev->value_fp == -1) {
- maa_gpio_get_valfp(dev);
+ if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
+ return MRAA_ERROR_INVALID_RESOURCE;
+ }
}
+
if (lseek(dev->value_fp, 0, SEEK_SET) == -1) {
- return MAA_ERROR_INVALID_RESOURCE;
+ return MRAA_ERROR_INVALID_RESOURCE;
}
char bu[MAX_SIZE];
int length = snprintf(bu, sizeof(bu), "%d", value);
- if (write(dev->value_fp, bu, length*sizeof(char)) == -1) {
- return MAA_ERROR_INVALID_HANDLE;
+ if (write(dev->value_fp, bu, length * sizeof(char)) == -1) {
+ return MRAA_ERROR_INVALID_HANDLE;
}
- return MAA_SUCCESS;
+ if (IS_FUNC_DEFINED(dev, gpio_write_post))
+ return dev->advance_func->gpio_write_post(dev, value);
+ return MRAA_SUCCESS;
}
-maa_result_t
-maa_gpio_unexport(maa_gpio_context *dev)
+static mraa_result_t
+mraa_gpio_unexport_force(mraa_gpio_context dev)
{
- FILE *unexport_f;
-
- if ((unexport_f = fopen(SYSFS_CLASS_GPIO "/unexport", "w")) == NULL) {
- fprintf(stderr, "Failed to open unexport for writing!\n");
- return MAA_ERROR_INVALID_RESOURCE;
+ int unexport = open(SYSFS_CLASS_GPIO "/unexport", O_WRONLY);
+ if (unexport == -1) {
+ syslog(LOG_ERR, "gpio: Failed to open unexport for writing");
+ return MRAA_ERROR_INVALID_RESOURCE;
}
char bu[MAX_SIZE];
int length = snprintf(bu, sizeof(bu), "%d", dev->pin);
- fwrite(bu, sizeof(char), length, unexport_f);
- fclose(unexport_f);
-
- maa_gpio_isr_exit(dev);
+ if (write(unexport, bu, length * sizeof(char)) == -1) {
+ syslog(LOG_ERR, "gpio: Failed to write to unexport");
+ close(unexport);
+ return MRAA_ERROR_INVALID_RESOURCE;
+ }
- return MAA_SUCCESS;
+ close(unexport);
+ mraa_gpio_isr_exit(dev);
+ return MRAA_SUCCESS;
+}
+static mraa_result_t
+mraa_gpio_unexport(mraa_gpio_context dev)
+{
+ if (dev->owner) {
+ return mraa_gpio_unexport_force(dev);
+ }
+ return MRAA_ERROR_INVALID_RESOURCE;
}
-maa_result_t
-maa_gpio_close(maa_gpio_context *dev)
+mraa_result_t
+mraa_gpio_close(mraa_gpio_context dev)
{
+ mraa_result_t result = MRAA_SUCCESS;
+
+ if (IS_FUNC_DEFINED(dev, gpio_close_pre)) {
+ result = dev->advance_func->gpio_close_pre(dev);
+ }
+
if (dev->value_fp != -1) {
close(dev->value_fp);
}
- maa_gpio_unexport(dev);
+ mraa_gpio_unexport(dev);
free(dev);
- return MAA_SUCCESS;
+ return result;
+}
+
+mraa_result_t
+mraa_gpio_owner(mraa_gpio_context dev, mraa_boolean_t own)
+{
+ if (dev == NULL) {
+ return MRAA_ERROR_INVALID_RESOURCE;
+ }
+ syslog(LOG_DEBUG, "gpio: Set owner to %d", (int) own);
+ dev->owner = own;
+ return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_gpio_use_mmaped(mraa_gpio_context dev, mraa_boolean_t mmap_en)
+{
+ if (IS_FUNC_DEFINED(dev, gpio_mmap_setup)) {
+ return dev->advance_func->gpio_mmap_setup(dev, mmap_en);
+ }
+
+ syslog(LOG_ERR, "gpio: mmap not implemented on this platform");
+ return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
+}
+
+int
+mraa_gpio_get_pin(mraa_gpio_context dev)
+{
+ if (dev == NULL) {
+ syslog(LOG_ERR, "gpio: context is invalid");
+ return -1;
+ }
+ return dev->phy_pin;
+}
+
+int
+mraa_gpio_get_pin_raw(mraa_gpio_context dev)
+{
+ if (dev == NULL) {
+ syslog(LOG_ERR, "gpio: context is invalid");
+ return -1;
+ }
+ return dev->pin;
}