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