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