2 * Author: Brendan Le Foll <brendan.le.foll@intel.com>
3 * Copyright (c) 2015 Intel Corporation.
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
13 * The above copyright notice and this permission notice shall be
14 * included in all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 #include "mraa_internal.h"
33 #define IIO_DEVICE "iio:device"
34 #define IIO_SCAN_ELEM "scan_elements"
35 #define IIO_SLASH_DEV "/dev/" IIO_DEVICE
36 #define IIO_SYSFS_DEVICE "/sys/bus/iio/devices/" IIO_DEVICE
37 #define IIO_EVENTS "events"
40 mraa_iio_init(int device)
42 if (device > plat_iio->iio_device_count) {
46 mraa_iio_get_channel_data(&plat_iio->iio_devices[device]);
47 mraa_iio_get_event_data(&plat_iio->iio_devices[device]);
49 return &plat_iio->iio_devices[device];
53 mraa_iio_read_size(mraa_iio_context dev)
59 mraa_iio_get_channels(mraa_iio_context dev)
65 mraa_iio_get_channel_count(mraa_iio_context dev)
71 mraa_iio_get_channel_data(mraa_iio_context dev)
73 const struct dirent* ent;
82 char shortbuf, signchar;
86 memset(buf, 0, MAX_SIZE);
87 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM, dev->num);
90 while ((ent = readdir(dir)) != NULL) {
91 if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
96 dev->chan_num = chan_num;
97 // no need proceed if no channel found
100 mraa_iio_channel* chan;
101 dev->channels = calloc(chan_num, sizeof(mraa_iio_channel));
103 while ((ent = readdir(dir)) != NULL) {
104 if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_index"), "_index") == 0) {
105 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM "/%s", dev->num, ent->d_name);
106 fd = open(buf, O_RDONLY);
108 if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
111 chan_num = ((int) strtol(readbuf, NULL, 10));
112 chan = &dev->channels[chan_num];
113 chan->index = chan_num;
116 buf[(strlen(buf) - 5)] = '\0';
117 char* str = strdup(buf);
118 // grab the type of the buffer
119 snprintf(buf, MAX_SIZE, "%stype", str);
120 fd = open(buf, O_RDONLY);
122 read(fd, readbuf, 31 * sizeof(char));
123 ret = sscanf(readbuf, "%ce:%c%u/%u>>%u", &shortbuf, &signchar, &chan->bits_used,
124 &padint, &chan->shift);
125 chan->bytes = padint / 8;
126 if (curr_bytes % chan->bytes == 0) {
127 chan->location = curr_bytes;
129 chan->location = curr_bytes - curr_bytes % chan->bytes + chan->bytes;
131 curr_bytes = chan->location + chan->bytes;
132 // probably should be 5?
137 return MRAA_IO_SETUP_FAILURE;
139 chan->signedd = (signchar == 's');
140 chan->lendian = (shortbuf == 'l');
141 if (chan->bits_used == 64) {
144 chan->mask = (1 << chan->bits_used) - 1;
148 // grab the enable flag of channel
149 snprintf(buf, MAX_SIZE, "%sen", str);
150 fd = open(buf, O_RDONLY);
152 if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
153 syslog(LOG_ERR, "iio: Failed to read a sensible value from sysfs");
156 chan->enabled = (int) strtol(readbuf, NULL, 10);
157 // only calculate enable buffer size for trigger buffer extract data
159 dev->datasize += chan->bytes;
173 mraa_iio_get_device_name(mraa_iio_context dev)
179 mraa_iio_get_device_num_by_name(const char* name)
183 if (plat_iio == NULL) {
184 syslog(LOG_ERR, "iio: platform IIO structure is not initialized");
189 syslog(LOG_ERR, "iio: device name is NULL, unable to find its number");
193 for (i = 0; i < plat_iio->iio_device_count; i++) {
195 device = &plat_iio->iio_devices[i];
196 // we want to check for exact match
197 if (strncmp(device->name, name, strlen(device->name) + 1) == 0) {
206 mraa_iio_read_float(mraa_iio_context dev, const char* filename, float* data)
209 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, filename);
210 FILE* fp = fopen(buf, "r");
212 fscanf(fp, "%f\n", data);
216 return MRAA_ERROR_UNSPECIFIED;
220 mraa_iio_read_integer(mraa_iio_context dev, const char* filename, int* data)
223 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, filename);
224 FILE* fp = fopen(buf, "r");
226 fscanf(fp, "%d\n", data);
230 return MRAA_ERROR_UNSPECIFIED;
234 mraa_iio_read_string(mraa_iio_context dev, const char* filename, char* data)
237 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, filename);
238 FILE* fp = fopen(buf, "r");
240 fscanf(fp, "%s\n", data);
244 return MRAA_ERROR_UNSPECIFIED;
248 mraa_iio_write_float(mraa_iio_context dev, const char* filename, const float data)
251 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, filename);
252 FILE* fp = fopen(buf, "w");
254 fprintf(fp, "%f", data);
258 return MRAA_ERROR_UNSPECIFIED;
262 mraa_iio_write_integer(mraa_iio_context dev, const char* filename, const int data)
265 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, filename);
266 FILE* fp = fopen(buf, "w");
268 fprintf(fp, "%d", data);
272 return MRAA_ERROR_UNSPECIFIED;
276 mraa_iio_write_string(mraa_iio_context dev, const char* filename, const char* data)
279 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, filename);
280 FILE* fp = fopen(buf, "w");
282 fprintf(fp, "%s", data);
286 return MRAA_ERROR_UNSPECIFIED;
290 mraa_iio_wait_event(int fd, char* data, int* read_size)
295 return MRAA_ERROR_INVALID_RESOURCE;
301 // Wait for it forever or until pthread_cancel
302 // poll is a cancelable point like sleep()
303 int x = poll(&pfd, 1, -1);
305 memset(data, 0, 100);
306 *read_size = read(fd, data, 100);
312 mraa_iio_trigger_handler(void* arg)
314 mraa_iio_context dev = (mraa_iio_context) arg;
316 char data[MAX_SIZE * 100];
320 if (mraa_iio_wait_event(dev->fp, &data[0], &read_size) == MRAA_SUCCESS) {
321 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
322 // only can process if readsize >= enabled channel's datasize
323 for (i = 0; i < (read_size / dev->datasize); i++) {
326 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
328 // we must have got an error code so die nicely
329 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
336 mraa_iio_trigger_buffer(mraa_iio_context dev, void (*fptr)(char* data), void* args)
339 if (dev->thread_id != 0) {
340 return MRAA_ERROR_NO_RESOURCES;
343 sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
344 dev->fp = open(bu, O_RDONLY | O_NONBLOCK);
346 return MRAA_ERROR_INVALID_RESOURCE;
350 pthread_create(&dev->thread_id, NULL, mraa_iio_trigger_handler, (void*) dev);
356 mraa_iio_get_event_data(mraa_iio_context dev)
358 const struct dirent* ent;
367 char shortbuf, signchar;
368 memset(buf, 0, MAX_SIZE);
369 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS, dev->num);
372 while ((ent = readdir(dir)) != NULL) {
373 if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
377 dev->event_num = event_num;
378 // no need proceed if no event found
381 mraa_iio_event* event;
382 dev->events = calloc(event_num, sizeof(mraa_iio_event));
383 if (dev->events == NULL) {
385 return MRAA_ERROR_UNSPECIFIED;
389 while ((ent = readdir(dir)) != NULL) {
390 if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
391 event = &dev->events[event_num];
392 event->name = strdup(ent->d_name);
393 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS "/%s", dev->num, ent->d_name);
394 fd = open(buf, O_RDONLY);
396 if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
401 event->enabled = ((int) strtol(readbuf, NULL, 10));
402 // Todo, read other event info.
412 mraa_iio_event_poll_nonblock(int fd, struct iio_event_data* data)
417 return MRAA_ERROR_INVALID_RESOURCE;
423 // Wait for it forever or until pthread_cancel
424 // poll is a cancelable point like sleep()
425 int x = poll(&pfd, 1, -1);
427 read(fd, data, sizeof(struct iio_event_data));
433 mraa_iio_event_poll(mraa_iio_context dev, struct iio_event_data* data)
440 sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
442 ret = ioctl(fd, IIO_GET_EVENT_FD_IOCTL, &event_fd);
445 if (ret == -1 || event_fd == -1)
446 return MRAA_ERROR_UNSPECIFIED;
448 ret = read(event_fd, data, sizeof(struct iio_event_data));
455 mraa_iio_event_handler(void* arg)
457 struct iio_event_data data;
458 mraa_iio_context dev = (mraa_iio_context) arg;
461 if (mraa_iio_event_poll_nonblock(dev->fp_event, &data) == MRAA_SUCCESS) {
462 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
463 dev->isr_event(&data);
464 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
466 // we must have got an error code so die nicely
467 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
474 mraa_iio_event_setup_callback(mraa_iio_context dev, void (*fptr)(struct iio_event_data* data), void* args)
478 if (dev->thread_id != 0) {
479 return MRAA_ERROR_NO_RESOURCES;
482 sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
483 dev->fp = open(bu, O_RDONLY | O_NONBLOCK);
485 return MRAA_ERROR_INVALID_RESOURCE;
487 ret = ioctl(dev->fp, IIO_GET_EVENT_FD_IOCTL, &dev->fp_event);
490 if (ret == -1 || dev->fp_event == -1) {
491 return MRAA_ERROR_UNSPECIFIED;
494 dev->isr_event = fptr;
495 pthread_create(&dev->thread_id, NULL, mraa_iio_event_handler, (void*) dev);
501 mraa_iio_event_extract_event(struct iio_event_data* event,
510 *chan_type = IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event->id);
511 *modifier = IIO_EVENT_CODE_EXTRACT_MODIFIER(event->id);
512 *type = IIO_EVENT_CODE_EXTRACT_TYPE(event->id);
513 *direction = IIO_EVENT_CODE_EXTRACT_DIR(event->id);
514 *channel = IIO_EVENT_CODE_EXTRACT_CHAN(event->id);
515 *channel2 = IIO_EVENT_CODE_EXTRACT_CHAN2(event->id);
516 *different = IIO_EVENT_CODE_EXTRACT_DIFF(event->id);
520 // does stop make any sense on iio devices?
522 mraa_iio_stop(mraa_iio_context dev)