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"
42 static mraa_adv_func* advance;
45 mraa_gpio_get_valfp(mraa_gpio_context dev)
48 sprintf(bu, SYSFS_CLASS_GPIO "/gpio%d/value", dev->pin);
49 dev->value_fp = open(bu, O_RDWR);
50 if (dev->value_fp == -1) {
51 return MRAA_ERROR_INVALID_RESOURCE;
58 mraa_gpio_init(int pin)
60 int pinm = mraa_setup_gpio(pin);
64 mraa_gpio_context r = mraa_gpio_init_raw(pinm);
70 mraa_gpio_init_raw(int pin)
72 advance = mraa_get_advance();
73 if (advance->defined.gpio_init_pre) {
74 if((advance->gpio_init_pre(pin)) != 0) {
75 printf("MRAA: Error in pre hook\n");
85 mraa_gpio_context dev = (mraa_gpio_context) malloc(sizeof(struct _gpio));
86 memset(dev, 0, sizeof(struct _gpio));
88 dev->isr_value_fp = -1;
92 char directory[MAX_SIZE];
93 snprintf(directory, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/", dev->pin);
95 if (stat(directory, &dir) == 0 && S_ISDIR(dir.st_mode)) {
96 //fprintf(stderr, "GPIO Pin already exporting, continuing.\n");
97 dev->owner = 0; // Not Owner
99 int export = open(SYSFS_CLASS_GPIO "/export", O_WRONLY);
101 fprintf(stderr, "Failed to open export for writing!\n");
104 length = snprintf(bu, sizeof(bu), "%d", dev->pin);
105 if (write(export, bu, length*sizeof(char)) == -1) {
106 fprintf(stderr, "Failed to write to export\n");
114 if (advance->defined.gpio_init_post)
115 advance->gpio_init_post(dev);
120 mraa_gpio_write_register(mraa_gpio_context dev,int value)
122 if (advance->defined.gpio_mmaped_write_replace)
123 return advance->gpio_mmaped_write_replace(dev,value);
124 if (advance->defined.gpio_mmaped_write_pre) {
125 mraa_result_t pre_ret = (advance->gpio_mmaped_write_pre(dev,value));
126 if(pre_ret != MRAA_SUCCESS)
130 *((unsigned *)dev->reg) |= (1<<dev->reg_bit_pos);
133 *((unsigned *)dev->reg) &= ~(1<<dev->reg_bit_pos);
135 if (advance->defined.gpio_mmaped_write_post)
136 return advance->gpio_mmaped_write_post(dev,value);
141 mraa_gpio_wait_interrupt(int fd)
146 // setup poll on POLLPRI
148 pfd.events = POLLPRI;
150 // do an initial read to clear interupt
154 return MRAA_ERROR_INVALID_RESOURCE;
157 // Wait for it forever or until pthread_cancel
158 // poll is a cancelable point like sleep()
159 int x = poll (&pfd, 1, -1);
161 // do a final read to clear interupt
168 mraa_gpio_interrupt_handler(void* arg)
170 mraa_gpio_context dev = (mraa_gpio_context) arg;
173 // open gpio value with open(3)
175 sprintf(bu, SYSFS_CLASS_GPIO "/gpio%d/value", dev->pin);
176 dev->isr_value_fp = open(bu, O_RDONLY);
179 ret = mraa_gpio_wait_interrupt(dev->isr_value_fp);
180 if (ret == MRAA_SUCCESS) {
181 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
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();
190 arglist = Py_BuildValue("(i)", dev->isr_args);
191 if (arglist == NULL) {
192 fprintf(stdout, "Py_BuildValue NULL\n");
194 ret = PyEval_CallObject((PyObject*)dev->isr, arglist);
196 fprintf(stdout, "PyEval_CallObject failed\n");
203 PyGILState_Release (gilstate);
205 dev->isr(dev->isr_args);
207 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
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;
219 mraa_gpio_edge_mode(mraa_gpio_context dev, gpio_edge_t mode)
221 if (dev->value_fp != -1) {
222 close(dev->value_fp);
226 char filepath[MAX_SIZE];
227 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/edge", dev->pin);
229 int edge = open(filepath, O_RDWR);
231 fprintf(stderr, "Failed to open edge for writing!\n");
232 return MRAA_ERROR_INVALID_RESOURCE;
238 case MRAA_GPIO_EDGE_NONE:
239 length = snprintf(bu, sizeof(bu), "none");
241 case MRAA_GPIO_EDGE_BOTH:
242 length = snprintf(bu, sizeof(bu), "both");
244 case MRAA_GPIO_EDGE_RISING:
245 length = snprintf(bu, sizeof(bu), "rising");
247 case MRAA_GPIO_EDGE_FALLING:
248 length = snprintf(bu, sizeof(bu), "falling");
252 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
254 if (write(edge, bu, length*sizeof(char)) == -1) {
255 fprintf(stderr, "Failed to write to edge\n");
257 return MRAA_ERROR_INVALID_RESOURCE;
265 mraa_gpio_isr(mraa_gpio_context dev, gpio_edge_t mode, void (*fptr)(void *), void * args)
267 // we only allow one isr per mraa_gpio_context
268 if (dev->thread_id != 0) {
269 return MRAA_ERROR_NO_RESOURCES;
272 if (MRAA_SUCCESS != mraa_gpio_edge_mode(dev, mode)) {
273 return MRAA_ERROR_UNSPECIFIED;
277 dev->isr_args = args;
278 pthread_create (&dev->thread_id, NULL, mraa_gpio_interrupt_handler, (void *) dev);
284 mraa_gpio_isr_exit(mraa_gpio_context dev)
286 mraa_result_t ret = MRAA_SUCCESS;
288 // wasting our time, there is no isr to exit from
289 if (dev->thread_id == 0 && dev->isr_value_fp == -1) {
293 // stop isr being useful
294 ret = mraa_gpio_edge_mode(dev, MRAA_GPIO_EDGE_NONE);
296 if ((dev->thread_id != 0) &&
297 (pthread_cancel(dev->thread_id) != 0)) {
298 ret = MRAA_ERROR_INVALID_HANDLE;
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;
309 // Dereference our Python call back function
313 // assume our thread will exit either way we just lost it's handle
315 dev->isr_value_fp = -1;
321 mraa_gpio_mode(mraa_gpio_context dev, gpio_mode_t mode)
323 if (advance->defined.gpio_mode_replace)
324 return advance->gpio_mode_replace(dev,mode);
326 if (advance->defined.gpio_mode_pre) {
327 mraa_result_t pre_ret = (advance->gpio_mode_pre(dev,mode));
328 if(pre_ret != MRAA_SUCCESS)
332 if (dev->value_fp != -1) {
333 close(dev->value_fp);
337 char filepath[MAX_SIZE];
338 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/drive", dev->pin);
340 int drive = open(filepath, O_WRONLY);
342 fprintf(stderr, "Failed to open drive for writing!\n");
343 return MRAA_ERROR_INVALID_RESOURCE;
349 case MRAA_GPIO_STRONG:
350 length = snprintf(bu, sizeof(bu), "strong");
352 case MRAA_GPIO_PULLUP:
353 length = snprintf(bu, sizeof(bu), "pullup");
355 case MRAA_GPIO_PULLDOWN:
356 length = snprintf(bu, sizeof(bu), "pulldown");
359 length = snprintf(bu, sizeof(bu), "hiz");
363 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
365 if (write(drive, bu, length*sizeof(char)) == -1) {
366 fprintf(stderr, "Failed to write to drive mode!\n");
368 return MRAA_ERROR_INVALID_RESOURCE;
373 if (advance->defined.gpio_mode_post)
374 return advance->gpio_mode_post(dev,mode);
379 mraa_gpio_dir(mraa_gpio_context dev, gpio_dir_t dir)
381 if (advance->defined.gpio_dir_replace)
382 return advance->gpio_dir_replace(dev,dir);
383 if (advance->defined.gpio_dir_pre) {
384 mraa_result_t pre_ret = (advance->gpio_dir_pre(dev,dir));
385 if(pre_ret != MRAA_SUCCESS)
389 return MRAA_ERROR_INVALID_HANDLE;
391 if (dev->value_fp != -1) {
392 close(dev->value_fp);
395 char filepath[MAX_SIZE];
396 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/direction", dev->pin);
398 int direction = open(filepath, O_RDWR);
400 if (direction == -1) {
401 return MRAA_ERROR_INVALID_RESOURCE;
409 length = snprintf(bu, sizeof(bu), "out");
413 length = snprintf(bu, sizeof(bu), "in");
417 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
420 if (dev->phy_pin >= 0) {
421 mraa_result_t swap_res = mraa_swap_complex_gpio(dev->phy_pin, out_switch);
422 if (swap_res != MRAA_SUCCESS)
426 if (write(direction, bu, length*sizeof(char)) == -1) {
428 return MRAA_ERROR_INVALID_RESOURCE;
432 if (advance->defined.gpio_dir_post)
433 return advance->gpio_dir_post(dev,dir);
438 mraa_gpio_read(mraa_gpio_context dev)
440 if (dev->value_fp == -1) {
441 if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
442 fprintf(stderr, "Failed to get value file pointer\n");
446 // if value_fp is new this is pointless
447 lseek(dev->value_fp, 0, SEEK_SET);
450 if (read(dev->value_fp, bu, 2*sizeof(char)) != 2) {
451 fprintf(stderr, "Failed to read a sensible value from sysfs");
453 lseek(dev->value_fp, 0, SEEK_SET);
454 int ret = strtol(bu, NULL, 10);
460 mraa_gpio_write(mraa_gpio_context dev, int value)
463 return mraa_gpio_write_register(dev,value);
465 if (advance->defined.gpio_write_pre) {
466 mraa_result_t pre_ret = (advance->gpio_write_pre(dev,value));
467 if(pre_ret != MRAA_SUCCESS)
471 if (dev->value_fp == -1) {
472 mraa_gpio_get_valfp(dev);
474 if (lseek(dev->value_fp, 0, SEEK_SET) == -1) {
475 return MRAA_ERROR_INVALID_RESOURCE;
479 int length = snprintf(bu, sizeof(bu), "%d", value);
480 if (write(dev->value_fp, bu, length*sizeof(char)) == -1) {
481 return MRAA_ERROR_INVALID_HANDLE;
484 if (advance->defined.gpio_write_post)
485 return advance->gpio_write_post(dev,value);
490 mraa_gpio_unexport_force(mraa_gpio_context dev)
492 int unexport = open(SYSFS_CLASS_GPIO "/unexport", O_WRONLY);
493 if (unexport == -1) {
494 fprintf(stderr, "Failed to open unexport for writing!\n");
495 return MRAA_ERROR_INVALID_RESOURCE;
499 int length = snprintf(bu, sizeof(bu), "%d", dev->pin);
500 if (write(unexport, bu, length*sizeof(char)) == -1) {
501 fprintf(stderr, "Failed to write to unexport\n");
503 return MRAA_ERROR_INVALID_RESOURCE;
507 mraa_gpio_isr_exit(dev);
511 mraa_gpio_unexport(mraa_gpio_context dev)
514 return mraa_gpio_unexport_force(dev);
516 return MRAA_ERROR_INVALID_RESOURCE;
520 mraa_gpio_close(mraa_gpio_context dev)
522 if (dev->value_fp != -1) {
523 close(dev->value_fp);
525 mraa_gpio_unexport(dev);
531 mraa_gpio_owner(mraa_gpio_context dev, mraa_boolean_t own)
534 return MRAA_ERROR_INVALID_RESOURCE;
540 mraa_gpio_use_mmaped(mraa_gpio_context dev, mraa_boolean_t mmap_en)
543 return MRAA_ERROR_INVALID_RESOURCE;
546 if (mraa_pin_mode_test(dev->phy_pin, MRAA_PIN_FAST_GPIO) == 0)
547 return MRAA_ERROR_NO_RESOURCES;
549 mraa_mmap_pin_t *mmp = mraa_setup_mmap_gpio(dev->phy_pin);
551 return MRAA_ERROR_INVALID_RESOURCE;
554 if (dev->mmap == 0) {
555 close(dev->value_fp);
557 fd = open(mmp->mem_dev, O_RDWR);
559 fprintf(stderr, "Unable to open memory device\n");
560 return MRAA_ERROR_INVALID_RESOURCE;
562 dev->reg_sz = mmp->mem_sz;
563 dev->reg = mmap(NULL, dev->reg_sz, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
564 dev->reg_bit_pos = mmp->bit_pos;
568 return MRAA_ERROR_INVALID_PARAMETER;
572 if (dev ->mmap == 1) {
573 munmap(dev->reg, dev->reg_sz);
576 return MRAA_ERROR_INVALID_PARAMETER;