src/iio/iio.c

   1 /*
   2  * Author: Brendan Le Foll <brendan.le.foll@intel.com>
   3  * Copyright (c) 2015 Intel Corporation.
   4  *
   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:
  12  *
  13  * The above copyright notice and this permission notice shall be
  14  * included in all copies or substantial portions of the Software.
  15  *
  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.
  23  */
  24
  25 #include "iio.h"
  26 #include "mraa_internal.h"
  27 #include "dirent.h"
  28 #include <string.h>
  29 #include <poll.h>
  30
  31 #define MAX_SIZE 128
  32 #define IIO_DEVICE "iio:device"
  33 #define IIO_SCAN_ELEM "scan_elements"
  34 #define IIO_SLASH_DEV "/dev/"IIO_DEVICE
  35 #define IIO_SYSFS_DEVICE "/sys/bus/iio/devices/"IIO_DEVICE
  36 #define IIO_EVENTS "events"
  37
  38 mraa_iio_context
  39 mraa_iio_init(int device)
  40 {
  41     if (device > plat_iio->iio_device_count) {
  42         return NULL;
  43     }
  44
  45     mraa_iio_get_channel_data(&plat_iio->iio_devices[device]);
  46     mraa_iio_get_event_data(&plat_iio->iio_devices[device]);
  47
  48     return &plat_iio->iio_devices[device];
  49 }
  50
  51 int
  52 mraa_iio_read_size(mraa_iio_context dev)
  53 {
  54     return dev->datasize;
  55 }
  56
  57 mraa_iio_channel*
  58 mraa_iio_get_channels(mraa_iio_context dev)
  59 {
  60     return dev->channels;
  61 }
  62
  63 int
  64 mraa_iio_get_channel_count(mraa_iio_context dev)
  65 {
  66     return dev->chan_num;
  67 }
  68
  69 mraa_result_t
  70 mraa_iio_get_channel_data(mraa_iio_context dev)
  71 {
  72     const struct dirent *ent;
  73     DIR* dir;
  74     int chan_num = 0;
  75     char buf[MAX_SIZE];
  76     char readbuf[32];
  77     int fd;
  78     int ret = 0;
  79     int padint = 0;
  80     int curr_bytes = 0;
  81     char shortbuf, signchar;
  82
  83     dev->datasize = 0;
  84
  85     memset(buf, 0, MAX_SIZE);
  86     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM, dev->num);
  87     dir = opendir(buf);
  88     if (dir != NULL) {
  89         while ((ent = readdir(dir)) != NULL) {
  90             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
  91                     chan_num++;
  92             }
  93         }
  94     }
  95     dev->chan_num = chan_num;
  96         //no need proceed if no channel found
  97         if (chan_num == 0)
  98                 return MRAA_SUCCESS;
  99     mraa_iio_channel* chan;
 100     dev->channels = calloc(chan_num, sizeof(mraa_iio_channel));
 101     seekdir(dir, 0);
 102     while ((ent = readdir(dir)) != NULL) {
 103         if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_index"), "_index") == 0) {
 104             snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM "/%s", dev->num, ent->d_name);
 105             fd = open(buf, O_RDONLY);
 106             if (fd > 0) {
 107                 if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 108                     break;
 109                 }
 110                 chan_num = ((int) strtol(readbuf, NULL, 10));
 111                 chan = &dev->channels[chan_num];
 112                 chan->index = chan_num;
 113                 close(fd);
 114
 115                 buf[(strlen(buf)-5)] = '\0';
 116                 char* str = strdup(buf);
 117                 // grab the type of the buffer
 118                 snprintf(buf, MAX_SIZE, "%stype", str);
 119                 fd = open(buf, O_RDONLY);
 120                 if (fd > 0) {
 121                     read(fd, readbuf, 31 * sizeof(char));
 122                     ret = sscanf(readbuf, "%ce:%c%u/%u>>%u", &shortbuf,
 123                                     &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;
 128                     } else {
 129                         chan->location = curr_bytes - curr_bytes%chan->bytes + chan->bytes;
 130                     }
 131                     curr_bytes = chan->location + chan->bytes;
 132                     // probably should be 5?
 133                     if (ret < 0) {
 134                         // cleanup
 135                         free(str);
 136                         close(fd);
 137                         return MRAA_IO_SETUP_FAILURE;
 138                     }
 139                     chan->signedd = (signchar == 's');
 140                     chan->lendian = (shortbuf == 'l');
 141                     if (chan->bits_used == 64) {
 142                         chan->mask = ~0;
 143                     } else {
 144                         chan->mask = (1 << chan->bits_used) - 1;
 145                     }
 146                     close(fd);
 147                 }
 148                 // grab the enable flag of channel
 149                 snprintf(buf, MAX_SIZE, "%sen", str);
 150                 fd = open(buf, O_RDONLY);
 151                 if (fd > 0) {
 152                     if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 153                         syslog(LOG_ERR, "iio: Failed to read a sensible value from sysfs");
 154                         return -1;
 155                     }
 156                     chan->enabled = (int) strtol(readbuf, NULL, 10);
 157                     //only calculate enable buffer size for trigger buffer extract data
 158                     if (chan->enabled) {
 159                         dev->datasize += chan->bytes;
 160                     }
 161                     close(fd);
 162                 }
 163                 // clean up str var
 164                 free(str);
 165             }
 166         }
 167     }
 168
 169     return MRAA_SUCCESS;
 170 }
 171
 172 const char*
 173 mraa_iio_get_device_name(mraa_iio_context dev)
 174 {
 175     return dev->name;
 176 }
 177
 178 int
 179 mraa_iio_get_device_num_by_name(const char* name)
 180 {
 181     int i;
 182
 183     if (plat_iio == NULL) {
 184         syslog(LOG_ERR, "iio: platform IIO structure is not initialized");
 185         return -1;
 186     }
 187
 188     if (name == NULL) {
 189         syslog(LOG_ERR, "iio: device name is NULL, unable to find its number");
 190         return -1;
 191     }
 192
 193     for (i = 0; i < plat_iio->iio_device_count; i++) {
 194         struct _iio* device;
 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) {
 198             return device->num;
 199         }
 200     }
 201
 202     return -1;
 203 }
 204
 205 mraa_result_t
 206 mraa_iio_read(mraa_iio_context dev, const char* attr_chan, float* data)
 207 {
 208     char buf[MAX_SIZE];
 209     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, attr_chan);
 210     int fd = open(buf, O_RDONLY);
 211     if (fd != -1) {
 212         int len = read(fd, &buf, MAX_SIZE);
 213         *data = strtol(buf, NULL, 10);
 214         return MRAA_SUCCESS;
 215     }
 216     return MRAA_ERROR_UNSPECIFIED;
 217 }
 218
 219 mraa_result_t
 220 mraa_iio_write(mraa_iio_context dev, const char* attr_chan, const char* data)
 221 {
 222     char buf[128];
 223     snprintf(buf, 128, IIO_SYSFS_DEVICE "%d/%s", dev->num, attr_chan);
 224     int fd = open(buf, O_WRONLY);
 225     if (fd != -1) {
 226         write(fd, data, (strlen(data)+1));
 227         return MRAA_SUCCESS;
 228     }
 229     return MRAA_ERROR_UNSPECIFIED;
 230 }
 231
 232 static mraa_result_t
 233 mraa_iio_wait_event(int fd, char* data, int *read_size)
 234 {
 235     struct pollfd pfd;
 236
 237     if (fd < 0) {
 238         return MRAA_ERROR_INVALID_RESOURCE;
 239     }
 240
 241     pfd.fd = fd;
 242     pfd.events = POLLIN;
 243
 244     // Wait for it forever or until pthread_cancel
 245     // poll is a cancelable point like sleep()
 246     int x = poll(&pfd, 1, -1);
 247
 248     memset(data, 0, 100);
 249     *read_size = read(fd, data, 100);
 250
 251     return MRAA_SUCCESS;
 252 }
 253
 254 static void*
 255 mraa_iio_trigger_handler(void* arg)
 256 {
 257     mraa_iio_context dev = (mraa_iio_context) arg;
 258     int i;
 259     char data[MAX_SIZE*100];
 260     int read_size;
 261
 262     for (;;) {
 263         if (mraa_iio_wait_event(dev->fp, &data[0], &read_size) == MRAA_SUCCESS) {
 264             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 265             //only can process if readsize >= enabled channel's datasize
 266             for (i=0; i<(read_size/dev->datasize); i++) {
 267                 dev->isr(&data);
 268             }
 269             pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 270         } else {
 271             // we must have got an error code so die nicely
 272             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 273             return NULL;
 274         }
 275     }
 276 }
 277
 278 mraa_result_t
 279 mraa_iio_trigger_buffer(mraa_iio_context dev, void (*fptr)(char* data), void* args)
 280 {
 281     char bu[MAX_SIZE];
 282     if (dev->thread_id != 0) {
 283         return MRAA_ERROR_NO_RESOURCES;
 284     }
 285
 286     sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
 287     dev->fp = open(bu, O_RDONLY | O_NONBLOCK);
 288     if (dev->fp == -1) {
 289         return MRAA_ERROR_INVALID_RESOURCE;
 290     }
 291
 292     dev->isr = fptr;
 293     pthread_create(&dev->thread_id, NULL, mraa_iio_trigger_handler, (void*) dev);
 294
 295     return MRAA_SUCCESS;
 296 }
 297
 298 mraa_result_t
 299 mraa_iio_get_event_data(mraa_iio_context dev)
 300 {
 301     const struct dirent *ent;
 302     DIR* dir;
 303     int event_num = 0;
 304     char buf[MAX_SIZE];
 305     char readbuf[32];
 306     int fd;
 307     int ret = 0;
 308     int padint = 0;
 309     int curr_bytes = 0;
 310     char shortbuf, signchar;
 311     memset(buf, 0, MAX_SIZE);
 312     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS, dev->num);
 313     dir = opendir(buf);
 314     if (dir != NULL) {
 315         while ((ent = readdir(dir)) != NULL) {
 316             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
 317                 event_num++;
 318             }
 319         }
 320         dev->event_num = event_num;
 321                 //no need proceed if no event found
 322                 if (event_num == 0)
 323                         return MRAA_SUCCESS;
 324         mraa_iio_event* event;
 325                 dev->events = calloc(event_num, sizeof(mraa_iio_event));
 326                 if ( dev->events == NULL)
 327                 {
 328                         closedir(dir);
 329                         return MRAA_ERROR_UNSPECIFIED;
 330                 }
 331                 rewinddir(dir);
 332                 event_num = 0;
 333                 while ((ent = readdir(dir)) != NULL)
 334                 {
 335             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
 336                                 event = &dev->events[event_num];
 337                 event->name = strdup(ent->d_name);
 338                                 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS "/%s", dev->num, ent->d_name);
 339                                 fd = open(buf, O_RDONLY);
 340                                 if (fd > 0) {
 341                                         if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 342                                                 break;
 343                                         }
 344                                         close(fd);
 345                                 }
 346                 event->enabled = ((int) strtol(readbuf, NULL, 10));
 347                                 //Todo, read other event info.
 348                                 event_num++;
 349             }
 350         }
 351                 closedir(dir);
 352     }
 353     return MRAA_SUCCESS;
 354 }
 355
 356 mraa_result_t
 357 mraa_iio_event_read(mraa_iio_context dev, const char* attribute, float* data)
 358 {
 359     char buf[MAX_SIZE];
 360     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS "/%s", dev->num, attribute);
 361     int fd = open(buf, O_RDONLY);
 362     if (fd != -1) {
 363         int len = read(fd, &buf, MAX_SIZE);
 364         *data = strtol(buf, NULL, 10);
 365         return MRAA_SUCCESS;
 366     }
 367     return MRAA_ERROR_UNSPECIFIED;
 368 }
 369
 370 mraa_result_t
 371 mraa_iio_event_write(mraa_iio_context dev, const char* attribute,  const char* data)
 372 {
 373         int len;
 374     char buf[MAX_SIZE];
 375     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS "/%s", dev->num, attribute);
 376     int fd = open(buf, O_WRONLY);
 377     if (fd != -1) {
 378                 int len = write(fd, data, ( strlen(data) +1 ));
 379         return MRAA_SUCCESS;
 380     }
 381     return MRAA_ERROR_UNSPECIFIED;
 382 }
 383
 384 static mraa_result_t
 385 mraa_iio_event_poll_nonblock(int fd, struct iio_event_data* data)
 386 {
 387     struct pollfd pfd;
 388
 389     if (fd < 0) {
 390         return MRAA_ERROR_INVALID_RESOURCE;
 391     }
 392
 393     pfd.fd = fd;
 394     pfd.events = POLLIN;
 395
 396     // Wait for it forever or until pthread_cancel
 397     // poll is a cancelable point like sleep()
 398     int x = poll(&pfd, 1, -1);
 399
 400     read(fd, data, sizeof(struct iio_event_data));
 401
 402     return MRAA_SUCCESS;
 403 }
 404
 405 mraa_result_t
 406 mraa_iio_event_poll(mraa_iio_context dev, struct iio_event_data* data)
 407 {
 408     char bu[MAX_SIZE];
 409     int ret;
 410         int event_fd;
 411         int fd;
 412
 413         sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
 414     fd = open(bu, 0);
 415         ret = ioctl(fd, IIO_GET_EVENT_FD_IOCTL, &event_fd);
 416         close(fd);
 417
 418         if (ret == -1 || event_fd == -1)
 419                 return MRAA_ERROR_UNSPECIFIED;
 420
 421         ret = read(event_fd, data, sizeof(struct iio_event_data));
 422
 423         close(event_fd);
 424     return MRAA_SUCCESS;
 425 }
 426
 427 static void*
 428 mraa_iio_event_handler(void* arg)
 429 {
 430         struct iio_event_data data;
 431     mraa_iio_context dev = (mraa_iio_context) arg;
 432
 433     for (;;) {
 434         if (mraa_iio_event_poll_nonblock(dev->fp_event, &data) == MRAA_SUCCESS) {
 435             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 436             dev->isr_event(&data);
 437             pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 438         } else {
 439             // we must have got an error code so die nicely
 440             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 441             return NULL;
 442         }
 443     }
 444 }
 445
 446 mraa_result_t
 447 mraa_iio_event_setup_callback(mraa_iio_context dev, void (*fptr)(struct iio_event_data* data), void* args)
 448 {
 449         int ret;
 450     char bu[MAX_SIZE];
 451     if (dev->thread_id != 0) {
 452         return MRAA_ERROR_NO_RESOURCES;
 453     }
 454
 455     sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
 456     dev->fp = open(bu, O_RDONLY | O_NONBLOCK);
 457     if (dev->fp == -1) {
 458         return MRAA_ERROR_INVALID_RESOURCE;
 459     }
 460         ret = ioctl(dev->fp, IIO_GET_EVENT_FD_IOCTL, &dev->fp_event);
 461         close(dev->fp);
 462
 463         if (ret == -1 || dev->fp_event == -1)
 464         {
 465                 return MRAA_ERROR_UNSPECIFIED;
 466         }
 467
 468     dev->isr_event = fptr;
 469     pthread_create(&dev->thread_id, NULL, mraa_iio_event_handler, (void*) dev);
 470
 471     return MRAA_SUCCESS;
 472 }
 473
 474 mraa_result_t
 475 mraa_iio_event_extract_event(struct iio_event_data* event, int* chan_type, int* modifier, int* type, int* direction, int* channel, int* channel2, int* different)
 476 {
 477         *chan_type = IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event->id);
 478         *modifier= IIO_EVENT_CODE_EXTRACT_MODIFIER(event->id);
 479         *type = IIO_EVENT_CODE_EXTRACT_TYPE(event->id);
 480         *direction = IIO_EVENT_CODE_EXTRACT_DIR(event->id);
 481         *channel = IIO_EVENT_CODE_EXTRACT_CHAN(event->id);
 482         *channel2 = IIO_EVENT_CODE_EXTRACT_CHAN2(event->id);
 483         *different = IIO_EVENT_CODE_EXTRACT_DIFF(event->id);
 484     return MRAA_SUCCESS;
 485 }
 486 #if 0
 487 // does stop make any sense on iio devices?
 488 mraa_result_t
 489 mraa_iio_stop(mraa_iio_context dev)
 490 {
 491     return MRAA_SUCCESS;
 492 }
 493 #endif
 494