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 #include <sys/ioctl.h>
  31 #include <sys/stat.h>
  32
  33 #define MAX_SIZE 128
  34 #define IIO_DEVICE "iio:device"
  35 #define IIO_SCAN_ELEM "scan_elements"
  36 #define IIO_MOUNTING_MATRIX "mounting_matrix"
  37 #define IIO_SLASH_DEV "/dev/" IIO_DEVICE
  38 #define IIO_SYSFS_DEVICE "/sys/bus/iio/devices/" IIO_DEVICE
  39 #define IIO_EVENTS "events"
  40 #define IIO_CONFIGFS_TRIGGER "/sys/kernel/config/iio/triggers/"
  41
  42 mraa_iio_context
  43 mraa_iio_init(int device)
  44 {
  45     if (plat_iio->iio_device_count == 0 || device >= plat_iio->iio_device_count) {
  46         return NULL;
  47     }
  48
  49     mraa_iio_get_channel_data(&plat_iio->iio_devices[device]);
  50     mraa_iio_get_event_data(&plat_iio->iio_devices[device]);
  51
  52     return &plat_iio->iio_devices[device];
  53 }
  54
  55 int
  56 mraa_iio_read_size(mraa_iio_context dev)
  57 {
  58     return dev->datasize;
  59 }
  60
  61 mraa_iio_channel*
  62 mraa_iio_get_channels(mraa_iio_context dev)
  63 {
  64     return dev->channels;
  65 }
  66
  67 int
  68 mraa_iio_get_channel_count(mraa_iio_context dev)
  69 {
  70     return dev->chan_num;
  71 }
  72
  73 mraa_result_t
  74 mraa_iio_get_channel_data(mraa_iio_context dev)
  75 {
  76     const struct dirent* ent;
  77     DIR* dir;
  78     int chan_num = 0;
  79     char buf[MAX_SIZE];
  80     char readbuf[32];
  81     int fd;
  82     int ret = 0;
  83     int padint = 0;
  84     int curr_bytes = 0;
  85     char shortbuf, signchar;
  86
  87     dev->datasize = 0;
  88
  89     memset(buf, 0, MAX_SIZE);
  90     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM, dev->num);
  91     dir = opendir(buf);
  92     if (dir != NULL) {
  93         while ((ent = readdir(dir)) != NULL) {
  94             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
  95                 chan_num++;
  96             }
  97         }
  98     }
  99     dev->chan_num = chan_num;
 100     // no need proceed if no channel found
 101     if (chan_num == 0)
 102         return MRAA_SUCCESS;
 103     mraa_iio_channel* chan;
 104     dev->channels = calloc(chan_num, sizeof(mraa_iio_channel));
 105     seekdir(dir, 0);
 106     while ((ent = readdir(dir)) != NULL) {
 107         if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_index"), "_index") == 0) {
 108             snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM "/%s", dev->num, ent->d_name);
 109             fd = open(buf, O_RDONLY);
 110             if (fd > 0) {
 111                 if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 112                     break;
 113                 }
 114                 chan_num = ((int) strtol(readbuf, NULL, 10));
 115                 chan = &dev->channels[chan_num];
 116                 chan->index = chan_num;
 117                 close(fd);
 118
 119                 buf[(strlen(buf) - 5)] = '\0';
 120                 char* str = strdup(buf);
 121                 // grab the type of the buffer
 122                 snprintf(buf, MAX_SIZE, "%stype", str);
 123                 fd = open(buf, O_RDONLY);
 124                 if (fd > 0) {
 125                     read(fd, readbuf, 31 * sizeof(char));
 126                     ret = sscanf(readbuf, "%ce:%c%u/%u>>%u", &shortbuf, &signchar, &chan->bits_used,
 127                                  &padint, &chan->shift);
 128                     chan->bytes = padint / 8;
 129                     if (curr_bytes % chan->bytes == 0) {
 130                         chan->location = curr_bytes;
 131                     } else {
 132                         chan->location = curr_bytes - curr_bytes % chan->bytes + chan->bytes;
 133                     }
 134                     curr_bytes = chan->location + chan->bytes;
 135                     // probably should be 5?
 136                     if (ret < 0) {
 137                         // cleanup
 138                         free(str);
 139                         close(fd);
 140                         return MRAA_IO_SETUP_FAILURE;
 141                     }
 142                     chan->signedd = (signchar == 's');
 143                     chan->lendian = (shortbuf == 'l');
 144                     if (chan->bits_used == 64) {
 145                         chan->mask = ~0;
 146                     } else {
 147                         chan->mask = (1 << chan->bits_used) - 1;
 148                     }
 149                     close(fd);
 150                 }
 151                 // grab the enable flag of channel
 152                 snprintf(buf, MAX_SIZE, "%sen", str);
 153                 fd = open(buf, O_RDONLY);
 154                 if (fd > 0) {
 155                     if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 156                         syslog(LOG_ERR, "iio: Failed to read a sensible value from sysfs");
 157                         return -1;
 158                     }
 159                     chan->enabled = (int) strtol(readbuf, NULL, 10);
 160                     // only calculate enable buffer size for trigger buffer extract data
 161                     if (chan->enabled) {
 162                         dev->datasize += chan->bytes;
 163                     }
 164                     close(fd);
 165                 }
 166                 // clean up str var
 167                 free(str);
 168             }
 169         }
 170     }
 171
 172     return MRAA_SUCCESS;
 173 }
 174
 175 const char*
 176 mraa_iio_get_device_name(mraa_iio_context dev)
 177 {
 178     return dev->name;
 179 }
 180
 181 int
 182 mraa_iio_get_device_num_by_name(const char* name)
 183 {
 184     int i;
 185
 186     if (plat_iio == NULL) {
 187         syslog(LOG_ERR, "iio: platform IIO structure is not initialized");
 188         return -1;
 189     }
 190
 191     if (name == NULL) {
 192         syslog(LOG_ERR, "iio: device name is NULL, unable to find its number");
 193         return -1;
 194     }
 195
 196     for (i = 0; i < plat_iio->iio_device_count; i++) {
 197         struct _iio* device;
 198         device = &plat_iio->iio_devices[i];
 199         // we want to check for exact match
 200         if (strncmp(device->name, name, strlen(device->name) + 1) == 0) {
 201             return device->num;
 202         }
 203     }
 204
 205     return -1;
 206 }
 207
 208 mraa_result_t
 209 mraa_iio_read_float(mraa_iio_context dev, const char* attr_name, float* data)
 210 {
 211     char buf[MAX_SIZE];
 212     mraa_result_t result = mraa_iio_read_string(dev, attr_name, buf);
 213     if (result != MRAA_SUCCESS)
 214         return result;
 215     int status = sscanf(buf, "%f", data);
 216     result = status == 1 ? MRAA_SUCCESS : MRAA_ERROR_UNSPECIFIED;
 217     return result;
 218 }
 219
 220
 221 mraa_result_t
 222 mraa_iio_read_integer(mraa_iio_context dev, const char* attr_name, int* data)
 223 {
 224     char buf[MAX_SIZE];
 225     mraa_result_t result = mraa_iio_read_string(dev, attr_name, buf);
 226     if (result != MRAA_SUCCESS)
 227         return result;
 228     int status = sscanf(buf, "%d", data);
 229     result = status == 1 ? MRAA_SUCCESS : MRAA_ERROR_UNSPECIFIED;
 230     return result;
 231 }
 232
 233 mraa_result_t
 234 mraa_iio_read_string(mraa_iio_context dev, const char* attr_name, char* data)
 235 {
 236     char buf[MAX_SIZE];
 237     mraa_result_t result = MRAA_ERROR_UNSPECIFIED;
 238     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, attr_name);
 239     int fd = open(buf, O_RDONLY);
 240     if (fd != -1) {
 241         ssize_t len = read(fd, data, MAX_SIZE);
 242         if (len > 0)
 243             result = MRAA_SUCCESS;
 244         close(fd);
 245     }
 246     return result;
 247
 248 }
 249
 250 mraa_result_t
 251 mraa_iio_write_float(mraa_iio_context dev, const char* attr_name, const float data)
 252 {
 253     char buf[MAX_SIZE];
 254     snprintf(buf, MAX_SIZE, "%f", data);
 255     return mraa_iio_write_string(dev, attr_name, buf);
 256 }
 257
 258 mraa_result_t
 259 mraa_iio_write_integer(mraa_iio_context dev, const char* attr_name, const int data)
 260 {
 261     char buf[MAX_SIZE];
 262     snprintf(buf, MAX_SIZE, "%d", data);
 263     return mraa_iio_write_string(dev, attr_name, buf);
 264 }
 265
 266 mraa_result_t
 267 mraa_iio_write_string(mraa_iio_context dev, const char* attr_name, const char* data)
 268 {
 269     char buf[MAX_SIZE];
 270     mraa_result_t result = MRAA_ERROR_UNSPECIFIED;
 271     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, attr_name);
 272     int fd = open(buf, O_WRONLY);
 273     if (fd != -1) {
 274         size_t len = strlen(data);
 275         ssize_t status = write(fd, data, len);
 276         if (status == len)
 277              result = MRAA_SUCCESS;
 278         close(fd);
 279     }
 280     return result;
 281 }
 282
 283 static mraa_result_t
 284 mraa_iio_wait_event(int fd, char* data, int* read_size)
 285 {
 286     struct pollfd pfd;
 287
 288     if (fd < 0) {
 289         return MRAA_ERROR_INVALID_RESOURCE;
 290     }
 291
 292     pfd.fd = fd;
 293     pfd.events = POLLIN;
 294
 295     // Wait for it forever or until pthread_cancel
 296     // poll is a cancelable point like sleep()
 297     int x = poll(&pfd, 1, -1);
 298
 299     memset(data, 0, 100);
 300     *read_size = read(fd, data, 100);
 301
 302     return MRAA_SUCCESS;
 303 }
 304
 305 static void*
 306 mraa_iio_trigger_handler(void* arg)
 307 {
 308     mraa_iio_context dev = (mraa_iio_context) arg;
 309     int i;
 310     char data[MAX_SIZE * 100];
 311     int read_size;
 312
 313     for (;;) {
 314         if (mraa_iio_wait_event(dev->fp, &data[0], &read_size) == MRAA_SUCCESS) {
 315             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 316             // only can process if readsize >= enabled channel's datasize
 317             for (i = 0; i < (read_size / dev->datasize); i++) {
 318                 dev->isr((void*)&data);
 319             }
 320             pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 321         } else {
 322             // we must have got an error code so die nicely
 323             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 324             return NULL;
 325         }
 326     }
 327 }
 328
 329 mraa_result_t
 330 mraa_iio_trigger_buffer(mraa_iio_context dev, void (*fptr)(char* data), void* args)
 331 {
 332     char bu[MAX_SIZE];
 333     if (dev->thread_id != 0) {
 334         return MRAA_ERROR_NO_RESOURCES;
 335     }
 336
 337     sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
 338     dev->fp = open(bu, O_RDONLY | O_NONBLOCK);
 339     if (dev->fp == -1) {
 340         return MRAA_ERROR_INVALID_RESOURCE;
 341     }
 342
 343     dev->isr = fptr;
 344     pthread_create(&dev->thread_id, NULL, mraa_iio_trigger_handler, (void*) dev);
 345
 346     return MRAA_SUCCESS;
 347 }
 348
 349 mraa_result_t
 350 mraa_iio_get_event_data(mraa_iio_context dev)
 351 {
 352     const struct dirent* ent;
 353     DIR* dir;
 354     int event_num = 0;
 355     char buf[MAX_SIZE];
 356     char readbuf[32];
 357     int fd;
 358     int ret = 0;
 359     int padint = 0;
 360     int curr_bytes = 0;
 361     char shortbuf, signchar;
 362     memset(buf, 0, MAX_SIZE);
 363     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS, dev->num);
 364     dir = opendir(buf);
 365     if (dir != NULL) {
 366         while ((ent = readdir(dir)) != NULL) {
 367             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
 368                 event_num++;
 369             }
 370         }
 371         dev->event_num = event_num;
 372         // no need proceed if no event found
 373         if (event_num == 0)
 374             return MRAA_SUCCESS;
 375         mraa_iio_event* event;
 376         dev->events = calloc(event_num, sizeof(mraa_iio_event));
 377         if (dev->events == NULL) {
 378             closedir(dir);
 379             return MRAA_ERROR_UNSPECIFIED;
 380         }
 381         rewinddir(dir);
 382         event_num = 0;
 383         while ((ent = readdir(dir)) != NULL) {
 384             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
 385                 event = &dev->events[event_num];
 386                 event->name = strdup(ent->d_name);
 387                 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS "/%s", dev->num, ent->d_name);
 388                 fd = open(buf, O_RDONLY);
 389                 if (fd > 0) {
 390                     if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 391                         break;
 392                     }
 393                     close(fd);
 394                 }
 395                 event->enabled = ((int) strtol(readbuf, NULL, 10));
 396                 // Todo, read other event info.
 397                 event_num++;
 398             }
 399         }
 400         closedir(dir);
 401     }
 402     return MRAA_SUCCESS;
 403 }
 404
 405 static mraa_result_t
 406 mraa_iio_event_poll_nonblock(int fd, struct iio_event_data* data)
 407 {
 408     struct pollfd pfd;
 409
 410     if (fd < 0) {
 411         return MRAA_ERROR_INVALID_RESOURCE;
 412     }
 413
 414     pfd.fd = fd;
 415     pfd.events = POLLIN;
 416
 417     // Wait for it forever or until pthread_cancel
 418     // poll is a cancelable point like sleep()
 419     int x = poll(&pfd, 1, -1);
 420
 421     read(fd, data, sizeof(struct iio_event_data));
 422
 423     return MRAA_SUCCESS;
 424 }
 425
 426 mraa_result_t
 427 mraa_iio_event_poll(mraa_iio_context dev, struct iio_event_data* data)
 428 {
 429     char bu[MAX_SIZE];
 430     int ret;
 431     int event_fd;
 432     int fd;
 433
 434     sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
 435     fd = open(bu, 0);
 436     ret = ioctl(fd, IIO_GET_EVENT_FD_IOCTL, &event_fd);
 437     close(fd);
 438
 439     if (ret == -1 || event_fd == -1)
 440         return MRAA_ERROR_UNSPECIFIED;
 441
 442     ret = read(event_fd, data, sizeof(struct iio_event_data));
 443
 444     close(event_fd);
 445     return MRAA_SUCCESS;
 446 }
 447
 448 static void*
 449 mraa_iio_event_handler(void* arg)
 450 {
 451     struct iio_event_data data;
 452     mraa_iio_context dev = (mraa_iio_context) arg;
 453
 454     for (;;) {
 455         if (mraa_iio_event_poll_nonblock(dev->fp_event, &data) == MRAA_SUCCESS) {
 456             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 457             dev->isr_event(&data);
 458             pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 459         } else {
 460             // we must have got an error code so die nicely
 461             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 462             return NULL;
 463         }
 464     }
 465 }
 466
 467 mraa_result_t
 468 mraa_iio_event_setup_callback(mraa_iio_context dev, void (*fptr)(struct iio_event_data* data), void* args)
 469 {
 470     int ret;
 471     char bu[MAX_SIZE];
 472     if (dev->thread_id != 0) {
 473         return MRAA_ERROR_NO_RESOURCES;
 474     }
 475
 476     sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
 477     dev->fp = open(bu, O_RDONLY | O_NONBLOCK);
 478     if (dev->fp == -1) {
 479         return MRAA_ERROR_INVALID_RESOURCE;
 480     }
 481     ret = ioctl(dev->fp, IIO_GET_EVENT_FD_IOCTL, &dev->fp_event);
 482     close(dev->fp);
 483
 484     if (ret == -1 || dev->fp_event == -1) {
 485         return MRAA_ERROR_UNSPECIFIED;
 486     }
 487
 488     dev->isr_event = fptr;
 489     pthread_create(&dev->thread_id, NULL, mraa_iio_event_handler, (void*) dev);
 490
 491     return MRAA_SUCCESS;
 492 }
 493
 494 mraa_result_t
 495 mraa_iio_event_extract_event(struct iio_event_data* event,
 496                              int* chan_type,
 497                              int* modifier,
 498                              int* type,
 499                              int* direction,
 500                              int* channel,
 501                              int* channel2,
 502                              int* different)
 503 {
 504     *chan_type = IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event->id);
 505     *modifier = IIO_EVENT_CODE_EXTRACT_MODIFIER(event->id);
 506     *type = IIO_EVENT_CODE_EXTRACT_TYPE(event->id);
 507     *direction = IIO_EVENT_CODE_EXTRACT_DIR(event->id);
 508     *channel = IIO_EVENT_CODE_EXTRACT_CHAN(event->id);
 509     *channel2 = IIO_EVENT_CODE_EXTRACT_CHAN2(event->id);
 510     *different = IIO_EVENT_CODE_EXTRACT_DIFF(event->id);
 511     return MRAA_SUCCESS;
 512 }
 513
 514 mraa_result_t
 515 mraa_iio_get_mounting_matrix(mraa_iio_context dev, float mm[9])
 516 {
 517     char buf[MAX_SIZE];
 518     FILE* fp;
 519
 520     memset(buf, 0, MAX_SIZE);
 521     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_MOUNTING_MATRIX, dev->num);
 522     fp = fopen(buf, "r");
 523     if (fp != NULL) {
 524         fscanf(fp, "%f %f %f\n%f %f %f\n%f %f %f\n", &mm[0], &mm[1], &mm[2], &mm[3], &mm[4], &mm[5],
 525                &mm[6], &mm[7], &mm[8]);
 526         fclose(fp);
 527         return MRAA_SUCCESS;
 528     }
 529     return MRAA_ERROR_UNSPECIFIED;
 530 }
 531
 532 mraa_result_t
 533 mraa_iio_create_trigger(mraa_iio_context dev, const char* trigger)
 534 {
 535     struct stat configfs_status;
 536     struct stat trigger_status;
 537     char buf[MAX_SIZE];
 538
 539     if (stat(IIO_CONFIGFS_TRIGGER, &configfs_status) == 0) {
 540         memset(buf, 0, MAX_SIZE);
 541         snprintf(buf, MAX_SIZE, IIO_CONFIGFS_TRIGGER "%s", trigger);
 542         if (stat(buf, &trigger_status) != 0) {
 543             if (mkdir(buf, configfs_status.st_mode) == 0)
 544                 return MRAA_SUCCESS;
 545         } else {
 546             // trigger folder already created
 547             return MRAA_SUCCESS;
 548         }
 549     }
 550
 551     return MRAA_ERROR_UNSPECIFIED;
 552 }
 553
 554 mraa_result_t
 555 mraa_iio_update_channels(mraa_iio_context dev)
 556 {
 557     const struct dirent* ent;
 558     DIR* dir;
 559     int chan_num = 0;
 560     char buf[MAX_SIZE];
 561     char readbuf[32];
 562     int fd;
 563     mraa_iio_channel* chan;
 564
 565     dev->datasize = 0;
 566     memset(buf, 0, MAX_SIZE);
 567     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM, dev->num);
 568     dir = opendir(buf);
 569     if (dir != NULL) {
 570         while ((ent = readdir(dir)) != NULL) {
 571             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_index"), "_index") == 0) {
 572                 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM "/%s", dev->num, ent->d_name);
 573                 fd = open(buf, O_RDONLY);
 574                 if (fd > 0) {
 575                     if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 576                         break;
 577                     }
 578                     chan_num = ((int) strtol(readbuf, NULL, 10));
 579                     chan = &dev->channels[chan_num];
 580                     chan->index = chan_num;
 581                     close(fd);
 582
 583                     buf[(strlen(buf) - 5)] = '\0';
 584                     char* str = strdup(buf);
 585                     // grab the enable flag of channel
 586                     snprintf(buf, MAX_SIZE, "%sen", str);
 587                     fd = open(buf, O_RDONLY);
 588                     if (fd > 0) {
 589                         if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 590                             syslog(LOG_ERR, "iio: Failed to read a sensible value from sysfs");
 591                             return -1;
 592                         }
 593                         chan->enabled = (int) strtol(readbuf, NULL, 10);
 594                         // only calculate enable buffer size for trigger buffer extract data
 595                         if (chan->enabled) {
 596                             dev->datasize += chan->bytes;
 597                         }
 598                         close(fd);
 599                     }
 600                     // clean up str var
 601                     free(str);
 602                 }
 603             }
 604         }
 605     }
 606     return MRAA_SUCCESS;
 607 }
 608
 609 mraa_result_t
 610 mraa_iio_stop(mraa_iio_context dev)
 611 {
 612     free(dev->channels);
 613     return MRAA_SUCCESS;
 614 }