1 /*
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.
5 *
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:
13 *
14 * The above copyright notice and this permission notice shall be
15 * included in all copies or substantial portions of the Software.
16 *
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.
24 */
25 #include "gpio.h"
26 #include "mraa_internal.h"
27
28 #include <stdlib.h>
29 #include <fcntl.h>
30 #include <string.h>
31 #include <unistd.h>
32 #include <poll.h>
33 #include <pthread.h>
34 #include <signal.h>
35 #include <sys/stat.h>
36 #include <sys/mman.h>
37
38 #define SYSFS_CLASS_GPIO "/sys/class/gpio"
39 #define MAX_SIZE 64
40 #define POLL_TIMEOUT
41
42 static mraa_result_t
mraa_gpio_get_valfp(mraa_gpio_context dev)43 mraa_gpio_get_valfp(mraa_gpio_context dev)
44 {
45 char bu[MAX_SIZE];
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;
50 }
51
52 return MRAA_SUCCESS;
53 }
54
55 static mraa_gpio_context
mraa_gpio_init_internal(mraa_adv_func_t * func_table,int pin)56 mraa_gpio_init_internal(mraa_adv_func_t* func_table, int pin)
57 {
58 if (pin < 0)
59 return NULL;
60
61 mraa_result_t status = MRAA_SUCCESS;
62 char bu[MAX_SIZE];
63 int length;
64
65 mraa_gpio_context dev = (mraa_gpio_context) calloc(1, sizeof(struct _gpio));
66 if (dev == NULL) {
67 syslog(LOG_CRIT, "gpio: Failed to allocate memory for context");
68 return NULL;
69 }
70
71 dev->advance_func = func_table;
72 dev->pin = pin;
73
74 if (IS_FUNC_DEFINED(dev, gpio_init_internal_replace)) {
75 status = dev->advance_func->gpio_init_internal_replace(dev, pin);
76 if (status == MRAA_SUCCESS)
77 return dev;
78 else
79 goto init_internal_cleanup;
80 }
81
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;
86 }
87
88 dev->value_fp = -1;
89 dev->isr_value_fp = -1;
90 #ifndef HAVE_PTHREAD_CANCEL
91 dev->isr_control_pipe[0] = dev->isr_control_pipe[1] = -1;
92 #endif
93 dev->isr_thread_terminating = 0;
94 dev->phy_pin = -1;
95
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);
99 struct stat dir;
100 if (stat(directory, &dir) == 0 && S_ISDIR(dir.st_mode)) {
101 dev->owner = 0; // Not Owner
102 } else {
103 int export = open(SYSFS_CLASS_GPIO "/export", O_WRONLY);
104 if (export == -1) {
105 syslog(LOG_ERR, "gpio: Failed to open export for writing");
106 status = MRAA_ERROR_NO_RESOURCES;
107 goto init_internal_cleanup;
108 }
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);
112 close(export);
113 status = MRAA_ERROR_NO_RESOURCES;
114 goto init_internal_cleanup;
115 }
116 dev->owner = 1;
117 close(export);
118 }
119
120 init_internal_cleanup:
121 if (status != MRAA_SUCCESS) {
122 if (dev != NULL)
123 free(dev);
124 return NULL;
125 }
126 return dev;
127 }
128
129 mraa_gpio_context
mraa_gpio_init(int pin)130 mraa_gpio_init(int pin)
131 {
132 mraa_board_t* board = plat;
133 if (board == NULL) {
134 syslog(LOG_ERR, "gpio: platform not initialised");
135 return NULL;
136 }
137
138 if (mraa_is_sub_platform_id(pin)) {
139 syslog(LOG_NOTICE, "gpio: Using sub platform");
140 board = board->sub_platform;
141 if (board == NULL) {
142 syslog(LOG_ERR, "gpio: Sub platform Not Initialised");
143 return NULL;
144 }
145 pin = mraa_get_sub_platform_index(pin);
146 }
147
148 if (pin < 0 || pin > board->phy_pin_count) {
149 syslog(LOG_ERR, "gpio: pin %i beyond platform definition", pin);
150 return NULL;
151 }
152 if (board->pins[pin].capabilites.gpio != 1) {
153 syslog(LOG_ERR, "gpio: pin %i not capable of gpio", pin);
154 return NULL;
155 }
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");
159 return NULL;
160 }
161 }
162
163 mraa_gpio_context r = mraa_gpio_init_internal(board->adv_func, board->pins[pin].gpio.pinmap);
164 if (r == NULL) {
165 syslog(LOG_CRIT, "gpio: mraa_gpio_init_raw(%d) returned error", pin);
166 return NULL;
167 }
168 if (r->phy_pin == -1)
169 r->phy_pin = pin;
170
171 if (IS_FUNC_DEFINED(r, gpio_init_post)) {
172 mraa_result_t ret = r->advance_func->gpio_init_post(r);
173 if (ret != MRAA_SUCCESS) {
174 free(r);
175 return NULL;
176 }
177 }
178 return r;
179 }
180
181 mraa_gpio_context
mraa_gpio_init_raw(int pin)182 mraa_gpio_init_raw(int pin)
183 {
184 return mraa_gpio_init_internal(plat == NULL ? NULL : plat->adv_func , pin);
185 }
186
187
188 static mraa_result_t
mraa_gpio_wait_interrupt(int fd,int control_fd)189 mraa_gpio_wait_interrupt(int fd
190 #ifndef HAVE_PTHREAD_CANCEL
191 , int control_fd
192 #endif
193 )
194 {
195 unsigned char c;
196 #ifdef HAVE_PTHREAD_CANCEL
197 struct pollfd pfd[1];
198 #else
199 struct pollfd pfd[2];
200
201 if (control_fd < 0) {
202 return MRAA_ERROR_INVALID_RESOURCE;
203 }
204 #endif
205
206 if (fd < 0) {
207 return MRAA_ERROR_INVALID_RESOURCE;
208 }
209
210 // setup poll on POLLPRI
211 pfd[0].fd = fd;
212 pfd[0].events = POLLPRI;
213
214 // do an initial read to clear interrupt
215 lseek(fd, 0, SEEK_SET);
216 read(fd, &c, 1);
217
218 #ifdef HAVE_PTHREAD_CANCEL
219 // Wait for it forever or until pthread_cancel
220 // poll is a cancelable point like sleep()
221 int x = poll(pfd, 1, -1);
222 #else
223 // setup poll on the controling fd
224 pfd[1].fd = control_fd;
225 pfd[1].events = 0; // POLLHUP, POLLERR, and POLLNVAL
226
227 // Wait for it forever or until control fd is closed
228 int x = poll(pfd, 2, -1);
229 #endif
230
231 // do a final read to clear interrupt
232 read(fd, &c, 1);
233
234 return MRAA_SUCCESS;
235 }
236
237 #if defined(SWIGJAVA) || defined(JAVACALLBACK)
238 pthread_key_t env_key;
239
240 extern JavaVM *globVM;
241 static pthread_once_t env_key_init = PTHREAD_ONCE_INIT;
242
243 jmethodID runGlobal;
244
make_env_key(void)245 static void make_env_key(void)
246 {
247
248 JNIEnv *jenv;
249 (*globVM)->GetEnv(globVM, (void **)&jenv, JNI_VERSION_1_8);
250
251 jclass rcls = (*jenv)->FindClass(jenv, "java/lang/Runnable");
252 jmethodID runm = (*jenv)->GetMethodID(jenv, rcls, "run", "()V");
253
254 runGlobal = (jmethodID)(*jenv)->NewGlobalRef(jenv, (jobject)runm);
255
256 pthread_key_create(&env_key, NULL);
257 }
258
mraa_java_isr_callback(void * data)259 void mraa_java_isr_callback(void* data)
260 {
261 JNIEnv *jenv = (JNIEnv *) pthread_getspecific(env_key);
262 (*jenv)->CallVoidMethod(jenv, (jobject)data, runGlobal);
263 }
264
265 #endif
266
267 static void*
mraa_gpio_interrupt_handler(void * arg)268 mraa_gpio_interrupt_handler(void* arg)
269 {
270 mraa_gpio_context dev = (mraa_gpio_context) arg;
271 if (IS_FUNC_DEFINED(dev, gpio_interrupt_handler_replace))
272 return dev->advance_func->gpio_interrupt_handler_replace(dev);
273
274 mraa_result_t ret;
275
276 // open gpio value with open(3)
277 char bu[MAX_SIZE];
278 sprintf(bu, SYSFS_CLASS_GPIO "/gpio%d/value", dev->pin);
279 int fp = open(bu, O_RDONLY);
280 if (fp < 0) {
281 syslog(LOG_ERR, "gpio: failed to open gpio%d/value", dev->pin);
282 return NULL;
283 }
284
285 #ifndef HAVE_PTHREAD_CANCEL
286 if (pipe(dev->isr_control_pipe)) {
287 syslog(LOG_ERR, "gpio: failed to create isr control pipe");
288 close(fp);
289 return NULL;
290 }
291 #endif
292
293 dev->isr_value_fp = fp;
294
295 #if defined(SWIGJAVA) || defined(JAVACALLBACK)
296 JNIEnv *jenv;
297 if(dev->isr == mraa_java_isr_callback) {
298 jint err = (*globVM)->AttachCurrentThreadAsDaemon(globVM, (void **)&jenv, NULL);
299
300 if (err != JNI_OK) {
301 close(dev->isr_value_fp);
302 dev->isr_value_fp = -1;
303 return NULL;
304 }
305
306 pthread_once(&env_key_init, make_env_key);
307 pthread_setspecific(env_key, jenv);
308 }
309 #endif
310
311 for (;;) {
312 ret = mraa_gpio_wait_interrupt(dev->isr_value_fp
313 #ifndef HAVE_PTHREAD_CANCEL
314 , dev->isr_control_pipe[0]
315 #endif
316 );
317 if (ret == MRAA_SUCCESS && !dev->isr_thread_terminating) {
318 #ifdef HAVE_PTHREAD_CANCEL
319 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
320 #endif
321 #ifdef SWIGPYTHON
322 // In order to call a python object (all python functions are objects) we
323 // need to aquire the GIL (Global Interpreter Lock). This may not always be
324 // necessary but especially if doing IO (like print()) python will segfault
325 // if we do not hold a lock on the GIL
326 PyGILState_STATE gilstate = PyGILState_Ensure();
327 PyObject* arglist;
328 PyObject* ret;
329 arglist = Py_BuildValue("(O)", dev->isr_args);
330 if (arglist == NULL) {
331 syslog(LOG_ERR, "gpio: Py_BuildValue NULL");
332 } else {
333 ret = PyEval_CallObject((PyObject*) dev->isr, arglist);
334 if (ret == NULL) {
335 syslog(LOG_ERR, "gpio: PyEval_CallObject failed");
336 PyObject *pvalue, *ptype, *ptraceback;
337 PyObject *pvalue_pystr, *ptype_pystr, *ptraceback_pystr;
338 char *pvalue_cstr, *ptype_cstr, *ptraceback_cstr;
339 PyErr_Fetch(&pvalue, &ptype, &ptraceback);
340 pvalue_pystr = PyObject_Str(pvalue);
341 ptype_pystr = PyObject_Str(ptype);
342 ptraceback_pystr = PyObject_Str(ptraceback);
343 // Python2
344 #if PY_VERSION_HEX < 0x03000000
345 pvalue_cstr = PyString_AsString(pvalue_pystr);
346 ptype_cstr = PyString_AsString(ptype_pystr);
347 ptraceback_cstr = PyString_AsString(ptraceback_pystr);
348 // Python 3 and up
349 #elif PY_VERSION_HEX >= 0x03000000
350 // In Python 3 we need one extra conversion
351 PyObject *pvalue_ustr, *ptype_ustr, *ptraceback_ustr;
352 pvalue_ustr = PyUnicode_AsUTF8String(pvalue_pystr);
353 pvalue_cstr = PyBytes_AsString(pvalue_ustr);
354 ptype_ustr = PyUnicode_AsUTF8String(ptype_pystr);
355 ptype_cstr = PyBytes_AsString(ptype_ustr);
356 ptraceback_ustr = PyUnicode_AsUTF8String(ptraceback_pystr);
357 ptraceback_cstr = PyBytes_AsString(ptraceback_ustr);
358 #endif // PY_VERSION_HEX
359 syslog(LOG_ERR, "gpio: the error was %s:%s:%s",
360 pvalue_cstr,
361 ptype_cstr,
362 ptraceback_cstr
363 );
364 Py_XDECREF(pvalue);
365 Py_XDECREF(ptype);
366 Py_XDECREF(ptraceback);
367 Py_XDECREF(pvalue_pystr);
368 Py_XDECREF(ptype_pystr);
369 Py_XDECREF(ptraceback_pystr);
370 // Python 3 and up
371 #if PY_VERSION_HEX >= 0x03000000
372 Py_XDECREF(pvalue_ustr);
373 Py_XDECREF(ptype_ustr);
374 Py_XDECREF(ptraceback_ustr);
375 #endif // PY_VERSION_HEX
376 } else {
377 Py_DECREF(ret);
378 }
379 Py_DECREF(arglist);
380 }
381
382 PyGILState_Release(gilstate);
383 #else
384 dev->isr(dev->isr_args);
385 #endif
386 #ifdef HAVE_PTHREAD_CANCEL
387 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
388 #endif
389 } else {
390 // we must have got an error code or exit request so die nicely
391 #ifdef HAVE_PTHREAD_CANCEL
392 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
393 #endif
394 close(dev->isr_value_fp);
395 dev->isr_value_fp = -1;
396 #if defined(SWIGJAVA) || defined(JAVACALLBACK)
397
398 if(dev->isr == mraa_java_isr_callback) {
399 (*jenv)->DeleteGlobalRef(jenv, (jobject)dev->isr_args);
400 (*globVM)->DetachCurrentThread(globVM);
401 }
402 #endif
403 return NULL;
404 }
405 }
406 }
407
408 mraa_result_t
mraa_gpio_edge_mode(mraa_gpio_context dev,mraa_gpio_edge_t mode)409 mraa_gpio_edge_mode(mraa_gpio_context dev, mraa_gpio_edge_t mode)
410 {
411 if (IS_FUNC_DEFINED(dev, gpio_edge_mode_replace))
412 return dev->advance_func->gpio_edge_mode_replace(dev, mode);
413
414 if (dev->value_fp != -1) {
415 close(dev->value_fp);
416 dev->value_fp = -1;
417 }
418
419 char filepath[MAX_SIZE];
420 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/edge", dev->pin);
421
422 int edge = open(filepath, O_RDWR);
423 if (edge == -1) {
424 syslog(LOG_ERR, "gpio: Failed to open edge for writing");
425 return MRAA_ERROR_INVALID_RESOURCE;
426 }
427
428 char bu[MAX_SIZE];
429 int length;
430 switch (mode) {
431 case MRAA_GPIO_EDGE_NONE:
432 length = snprintf(bu, sizeof(bu), "none");
433 break;
434 case MRAA_GPIO_EDGE_BOTH:
435 length = snprintf(bu, sizeof(bu), "both");
436 break;
437 case MRAA_GPIO_EDGE_RISING:
438 length = snprintf(bu, sizeof(bu), "rising");
439 break;
440 case MRAA_GPIO_EDGE_FALLING:
441 length = snprintf(bu, sizeof(bu), "falling");
442 break;
443 default:
444 close(edge);
445 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
446 }
447 if (write(edge, bu, length * sizeof(char)) == -1) {
448 syslog(LOG_ERR, "gpio: Failed to write to edge");
449 close(edge);
450 return MRAA_ERROR_INVALID_RESOURCE;
451 }
452
453 close(edge);
454 return MRAA_SUCCESS;
455 }
456
457 mraa_result_t
mraa_gpio_isr(mraa_gpio_context dev,mraa_gpio_edge_t mode,void (* fptr)(void *),void * args)458 mraa_gpio_isr(mraa_gpio_context dev, mraa_gpio_edge_t mode, void (*fptr)(void*), void* args)
459 {
460 // we only allow one isr per mraa_gpio_context
461 if (dev->thread_id != 0) {
462 return MRAA_ERROR_NO_RESOURCES;
463 }
464
465 if (MRAA_SUCCESS != mraa_gpio_edge_mode(dev, mode)) {
466 return MRAA_ERROR_UNSPECIFIED;
467 }
468
469 dev->isr = fptr;
470 #if defined(SWIGJAVA) || defined(JAVACALLBACK)
471 JNIEnv *jenv;
472 /* Most UPM sensors use the C API, the global ref must be created here. */
473 /* The reason for checking the callback function is internal callbacks. */
474 if (fptr == mraa_java_isr_callback) {
475 (*globVM)->GetEnv(globVM, (void **)&jenv, JNI_VERSION_1_8);
476 jobject grunnable = (*jenv)->NewGlobalRef(jenv, (jobject) args);
477 args = (void *) grunnable;
478 }
479 #endif
480 dev->isr_args = args;
481 pthread_create(&dev->thread_id, NULL, mraa_gpio_interrupt_handler, (void*) dev);
482
483 return MRAA_SUCCESS;
484 }
485
486 mraa_result_t
mraa_gpio_isr_exit(mraa_gpio_context dev)487 mraa_gpio_isr_exit(mraa_gpio_context dev)
488 {
489 mraa_result_t ret = MRAA_SUCCESS;
490
491 // wasting our time, there is no isr to exit from
492 if (dev->thread_id == 0 && dev->isr_value_fp == -1) {
493 return ret;
494 }
495 // mark the beginning of the thread termination process for interested parties
496 dev->isr_thread_terminating = 1;
497
498 // stop isr being useful
499 ret = mraa_gpio_edge_mode(dev, MRAA_GPIO_EDGE_NONE);
500
501 if ((dev->thread_id != 0)) {
502 #ifdef HAVE_PTHREAD_CANCEL
503 if ((pthread_cancel(dev->thread_id) != 0) || (pthread_join(dev->thread_id, NULL) != 0)) {
504 ret = MRAA_ERROR_INVALID_HANDLE;
505 }
506 #else
507 close(dev->isr_control_pipe[1]);
508 if (pthread_join(dev->thread_id, NULL) != 0)
509 ret = MRAA_ERROR_INVALID_HANDLE;
510
511 close(dev->isr_control_pipe[0]);
512 dev->isr_control_pipe[0] = dev->isr_control_pipe[1] = -1;
513 #endif
514 }
515
516 // close the filehandle in case it's still open
517 if (dev->isr_value_fp != -1) {
518 if (close(dev->isr_value_fp) != 0) {
519 ret = MRAA_ERROR_INVALID_PARAMETER;
520 }
521 }
522
523 // assume our thread will exit either way we just lost it's handle
524 dev->thread_id = 0;
525 dev->isr_value_fp = -1;
526 dev->isr_thread_terminating = 0;
527 return ret;
528 }
529
530 mraa_result_t
mraa_gpio_mode(mraa_gpio_context dev,mraa_gpio_mode_t mode)531 mraa_gpio_mode(mraa_gpio_context dev, mraa_gpio_mode_t mode)
532 {
533 if (IS_FUNC_DEFINED(dev, gpio_mode_replace))
534 return dev->advance_func->gpio_mode_replace(dev, mode);
535
536 if (IS_FUNC_DEFINED(dev, gpio_mode_pre)) {
537 mraa_result_t pre_ret = (dev->advance_func->gpio_mode_pre(dev, mode));
538 if (pre_ret != MRAA_SUCCESS)
539 return pre_ret;
540 }
541
542 if (dev->value_fp != -1) {
543 close(dev->value_fp);
544 dev->value_fp = -1;
545 }
546
547 char filepath[MAX_SIZE];
548 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/drive", dev->pin);
549
550 int drive = open(filepath, O_WRONLY);
551 if (drive == -1) {
552 syslog(LOG_ERR, "gpio: Failed to open drive for writing");
553 return MRAA_ERROR_INVALID_RESOURCE;
554 }
555
556 char bu[MAX_SIZE];
557 int length;
558 switch (mode) {
559 case MRAA_GPIO_STRONG:
560 length = snprintf(bu, sizeof(bu), "strong");
561 break;
562 case MRAA_GPIO_PULLUP:
563 length = snprintf(bu, sizeof(bu), "pullup");
564 break;
565 case MRAA_GPIO_PULLDOWN:
566 length = snprintf(bu, sizeof(bu), "pulldown");
567 break;
568 case MRAA_GPIO_HIZ:
569 length = snprintf(bu, sizeof(bu), "hiz");
570 break;
571 default:
572 close(drive);
573 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
574 }
575 if (write(drive, bu, length * sizeof(char)) == -1) {
576 syslog(LOG_ERR, "gpio: Failed to write to drive mode");
577 close(drive);
578 return MRAA_ERROR_INVALID_RESOURCE;
579 }
580
581 close(drive);
582 if (IS_FUNC_DEFINED(dev, gpio_mode_post))
583 return dev->advance_func->gpio_mode_post(dev, mode);
584 return MRAA_SUCCESS;
585 }
586
587 mraa_result_t
mraa_gpio_dir(mraa_gpio_context dev,mraa_gpio_dir_t dir)588 mraa_gpio_dir(mraa_gpio_context dev, mraa_gpio_dir_t dir)
589 {
590 if (IS_FUNC_DEFINED(dev, gpio_dir_replace)) {
591 return dev->advance_func->gpio_dir_replace(dev, dir);
592 }
593
594 if (IS_FUNC_DEFINED(dev, gpio_dir_pre)) {
595 mraa_result_t pre_ret = (dev->advance_func->gpio_dir_pre(dev, dir));
596 if (pre_ret != MRAA_SUCCESS) {
597 return pre_ret;
598 }
599 }
600
601 if (dev == NULL) {
602 return MRAA_ERROR_INVALID_HANDLE;
603 }
604 if (dev->value_fp != -1) {
605 close(dev->value_fp);
606 dev->value_fp = -1;
607 }
608 char filepath[MAX_SIZE];
609 snprintf(filepath, MAX_SIZE, SYSFS_CLASS_GPIO "/gpio%d/direction", dev->pin);
610
611 int direction = open(filepath, O_RDWR);
612
613 if (direction == -1) {
614 // Direction Failed to Open. If HIGH or LOW was passed will try and set
615 // If not fail as usual.
616 switch (dir) {
617 case MRAA_GPIO_OUT_HIGH:
618 return mraa_gpio_write(dev, 1);
619 case MRAA_GPIO_OUT_LOW:
620 return mraa_gpio_write(dev, 0);
621 default:
622 return MRAA_ERROR_INVALID_RESOURCE;
623 }
624 }
625
626 char bu[MAX_SIZE];
627 int length;
628 switch (dir) {
629 case MRAA_GPIO_OUT:
630 length = snprintf(bu, sizeof(bu), "out");
631 break;
632 case MRAA_GPIO_IN:
633 length = snprintf(bu, sizeof(bu), "in");
634 break;
635 case MRAA_GPIO_OUT_HIGH:
636 length = snprintf(bu, sizeof(bu), "high");
637 break;
638 case MRAA_GPIO_OUT_LOW:
639 length = snprintf(bu, sizeof(bu), "low");
640 break;
641 default:
642 close(direction);
643 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
644 }
645
646 if (write(direction, bu, length * sizeof(char)) == -1) {
647 close(direction);
648 return MRAA_ERROR_INVALID_RESOURCE;
649 }
650
651 close(direction);
652 if (IS_FUNC_DEFINED(dev, gpio_dir_post))
653 return dev->advance_func->gpio_dir_post(dev, dir);
654 return MRAA_SUCCESS;
655 }
656
657 int
mraa_gpio_read(mraa_gpio_context dev)658 mraa_gpio_read(mraa_gpio_context dev)
659 {
660 if (dev == NULL)
661 return -1;
662
663 if (IS_FUNC_DEFINED(dev, gpio_read_replace))
664 return dev->advance_func->gpio_read_replace(dev);
665
666 if (dev->mmap_read != NULL)
667 return dev->mmap_read(dev);
668
669 if (dev->value_fp == -1) {
670 if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
671 syslog(LOG_ERR, "gpio: Failed to get value file pointer");
672 return -1;
673 }
674 } else {
675 // if value_fp is new this is pointless
676 lseek(dev->value_fp, 0, SEEK_SET);
677 }
678 char bu[2];
679 if (read(dev->value_fp, bu, 2 * sizeof(char)) != 2) {
680 syslog(LOG_ERR, "gpio: Failed to read a sensible value from sysfs");
681 return -1;
682 }
683 lseek(dev->value_fp, 0, SEEK_SET);
684
685 return (int) strtol(bu, NULL, 10);
686 }
687
688 mraa_result_t
mraa_gpio_write(mraa_gpio_context dev,int value)689 mraa_gpio_write(mraa_gpio_context dev, int value)
690 {
691 if (dev == NULL)
692 return MRAA_ERROR_INVALID_HANDLE;
693
694 if (dev->mmap_write != NULL)
695 return dev->mmap_write(dev, value);
696
697 if (IS_FUNC_DEFINED(dev, gpio_write_pre)) {
698 mraa_result_t pre_ret = (dev->advance_func->gpio_write_pre(dev, value));
699 if (pre_ret != MRAA_SUCCESS)
700 return pre_ret;
701 }
702
703 if (IS_FUNC_DEFINED(dev, gpio_write_replace)) {
704 return dev->advance_func->gpio_write_replace(dev, value);
705 }
706
707 if (dev->value_fp == -1) {
708 if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
709 return MRAA_ERROR_INVALID_RESOURCE;
710 }
711 }
712
713 if (lseek(dev->value_fp, 0, SEEK_SET) == -1) {
714 return MRAA_ERROR_INVALID_RESOURCE;
715 }
716
717 char bu[MAX_SIZE];
718 int length = snprintf(bu, sizeof(bu), "%d", value);
719 if (write(dev->value_fp, bu, length * sizeof(char)) == -1) {
720 return MRAA_ERROR_INVALID_HANDLE;
721 }
722
723 if (IS_FUNC_DEFINED(dev, gpio_write_post))
724 return dev->advance_func->gpio_write_post(dev, value);
725 return MRAA_SUCCESS;
726 }
727
728 static mraa_result_t
mraa_gpio_unexport_force(mraa_gpio_context dev)729 mraa_gpio_unexport_force(mraa_gpio_context dev)
730 {
731 int unexport = open(SYSFS_CLASS_GPIO "/unexport", O_WRONLY);
732 if (unexport == -1) {
733 syslog(LOG_ERR, "gpio: Failed to open unexport for writing");
734 return MRAA_ERROR_INVALID_RESOURCE;
735 }
736
737 char bu[MAX_SIZE];
738 int length = snprintf(bu, sizeof(bu), "%d", dev->pin);
739 if (write(unexport, bu, length * sizeof(char)) == -1) {
740 syslog(LOG_ERR, "gpio: Failed to write to unexport");
741 close(unexport);
742 return MRAA_ERROR_INVALID_RESOURCE;
743 }
744
745 close(unexport);
746 mraa_gpio_isr_exit(dev);
747 return MRAA_SUCCESS;
748 }
749 static mraa_result_t
mraa_gpio_unexport(mraa_gpio_context dev)750 mraa_gpio_unexport(mraa_gpio_context dev)
751 {
752 if (dev->owner) {
753 return mraa_gpio_unexport_force(dev);
754 }
755 return MRAA_ERROR_INVALID_RESOURCE;
756 }
757
758 mraa_result_t
mraa_gpio_close(mraa_gpio_context dev)759 mraa_gpio_close(mraa_gpio_context dev)
760 {
761 mraa_result_t result = MRAA_SUCCESS;
762
763 if (IS_FUNC_DEFINED(dev, gpio_close_pre)) {
764 result = dev->advance_func->gpio_close_pre(dev);
765 }
766
767 if (dev->value_fp != -1) {
768 close(dev->value_fp);
769 }
770 mraa_gpio_unexport(dev);
771 free(dev);
772 return result;
773 }
774
775 mraa_result_t
mraa_gpio_owner(mraa_gpio_context dev,mraa_boolean_t own)776 mraa_gpio_owner(mraa_gpio_context dev, mraa_boolean_t own)
777 {
778 if (dev == NULL) {
779 return MRAA_ERROR_INVALID_RESOURCE;
780 }
781 syslog(LOG_DEBUG, "gpio: Set owner to %d", (int) own);
782 dev->owner = own;
783 return MRAA_SUCCESS;
784 }
785
786 mraa_result_t
mraa_gpio_use_mmaped(mraa_gpio_context dev,mraa_boolean_t mmap_en)787 mraa_gpio_use_mmaped(mraa_gpio_context dev, mraa_boolean_t mmap_en)
788 {
789 if (IS_FUNC_DEFINED(dev, gpio_mmap_setup)) {
790 return dev->advance_func->gpio_mmap_setup(dev, mmap_en);
791 }
792
793 syslog(LOG_ERR, "gpio: mmap not implemented on this platform");
794 return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
795 }
796
797 int
mraa_gpio_get_pin(mraa_gpio_context dev)798 mraa_gpio_get_pin(mraa_gpio_context dev)
799 {
800 if (dev == NULL) {
801 syslog(LOG_ERR, "gpio: context is invalid");
802 return -1;
803 }
804 return dev->phy_pin;
805 }
806
807 int
mraa_gpio_get_pin_raw(mraa_gpio_context dev)808 mraa_gpio_get_pin_raw(mraa_gpio_context dev)
809 {
810 if (dev == NULL) {
811 syslog(LOG_ERR, "gpio: context is invalid");
812 return -1;
813 }
814 return dev->pin;
815 }
816