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