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     memset(readbuf, 0, 32);
 369     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS, dev->num);
 370     dir = opendir(buf);
 371     if (dir != NULL) {
 372         while ((ent = readdir(dir)) != NULL) {
 373             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
 374                 event_num++;
 375             }
 376         }
 377         dev->event_num = event_num;
 378         // no need proceed if no event found
 379         if (event_num == 0) {
 380             closedir(dir);
 381             return MRAA_SUCCESS;
 382         }
 383         mraa_iio_event* event;
 384         dev->events = calloc(event_num, sizeof(mraa_iio_event));
 385         if (dev->events == NULL) {
 386             closedir(dir);
 387             return MRAA_ERROR_UNSPECIFIED;
 388         }
 389         rewinddir(dir);
 390         event_num = 0;
 391         while ((ent = readdir(dir)) != NULL) {
 392             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
 393                 event = &dev->events[event_num];
 394                 event->name = strdup(ent->d_name);
 395                 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS "/%s", dev->num, ent->d_name);
 396                 fd = open(buf, O_RDONLY);
 397                 if (fd != -1) {
 398                     if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 399                         close(fd);
 400                         break;
 401                     }
 402                     close(fd);
 403                 }
 404                 event->enabled = ((int) strtol(readbuf, NULL, 10));
 405                 // Todo, read other event info.
 406                 event_num++;
 407             }
 408         }
 409         closedir(dir);
 410     }
 411     return MRAA_SUCCESS;
 412 }
 413
 414 static mraa_result_t
 415 mraa_iio_event_poll_nonblock(int fd, struct iio_event_data* data)
 416 {
 417     struct pollfd pfd;
 418
 419     if (fd < 0) {
 420         return MRAA_ERROR_INVALID_RESOURCE;
 421     }
 422
 423     pfd.fd = fd;
 424     pfd.events = POLLIN;
 425
 426     // Wait for it forever or until pthread_cancel
 427     // poll is a cancelable point like sleep()
 428     int x = poll(&pfd, 1, -1);
 429
 430     read(fd, data, sizeof(struct iio_event_data));
 431
 432     return MRAA_SUCCESS;
 433 }
 434
 435 mraa_result_t
 436 mraa_iio_event_poll(mraa_iio_context dev, struct iio_event_data* data)
 437 {
 438     char bu[MAX_SIZE];
 439     int ret;
 440     int event_fd;
 441     int fd;
 442
 443     sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
 444     fd = open(bu, 0);
 445     ret = ioctl(fd, IIO_GET_EVENT_FD_IOCTL, &event_fd);
 446     close(fd);
 447
 448     if (ret == -1 || event_fd == -1)
 449         return MRAA_ERROR_UNSPECIFIED;
 450
 451     ret = read(event_fd, data, sizeof(struct iio_event_data));
 452
 453     close(event_fd);
 454     return MRAA_SUCCESS;
 455 }
 456
 457 static void*
 458 mraa_iio_event_handler(void* arg)
 459 {
 460     struct iio_event_data data;
 461     mraa_iio_context dev = (mraa_iio_context) arg;
 462
 463     for (;;) {
 464         if (mraa_iio_event_poll_nonblock(dev->fp_event, &data) == MRAA_SUCCESS) {
 465             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 466             dev->isr_event(&data, dev->isr_args);
 467             pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 468         } else {
 469             // we must have got an error code so die nicely
 470             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 471             return NULL;
 472         }
 473     }
 474 }
 475
 476 mraa_result_t
 477 mraa_iio_event_setup_callback(mraa_iio_context dev, void (*fptr)(struct iio_event_data* data, void* args), void* args)
 478 {
 479     int ret;
 480     char bu[MAX_SIZE];
 481     if (dev->thread_id != 0) {
 482         return MRAA_ERROR_NO_RESOURCES;
 483     }
 484
 485     sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
 486     dev->fp = open(bu, O_RDONLY | O_NONBLOCK);
 487     if (dev->fp == -1) {
 488         return MRAA_ERROR_INVALID_RESOURCE;
 489     }
 490     ret = ioctl(dev->fp, IIO_GET_EVENT_FD_IOCTL, &dev->fp_event);
 491     close(dev->fp);
 492
 493     if (ret == -1 || dev->fp_event == -1) {
 494         return MRAA_ERROR_UNSPECIFIED;
 495     }
 496
 497     dev->isr_event = fptr;
 498     dev->isr_args = args;
 499     pthread_create(&dev->thread_id, NULL, mraa_iio_event_handler, (void*) dev);
 500
 501     return MRAA_SUCCESS;
 502 }
 503
 504 mraa_result_t
 505 mraa_iio_event_extract_event(struct iio_event_data* event,
 506                              int* chan_type,
 507                              int* modifier,
 508                              int* type,
 509                              int* direction,
 510                              int* channel,
 511                              int* channel2,
 512                              int* different)
 513 {
 514     *chan_type = IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event->id);
 515     *modifier = IIO_EVENT_CODE_EXTRACT_MODIFIER(event->id);
 516     *type = IIO_EVENT_CODE_EXTRACT_TYPE(event->id);
 517     *direction = IIO_EVENT_CODE_EXTRACT_DIR(event->id);
 518     *channel = IIO_EVENT_CODE_EXTRACT_CHAN(event->id);
 519     *channel2 = IIO_EVENT_CODE_EXTRACT_CHAN2(event->id);
 520     *different = IIO_EVENT_CODE_EXTRACT_DIFF(event->id);
 521     return MRAA_SUCCESS;
 522 }
 523
 524 mraa_result_t
 525 mraa_iio_get_mounting_matrix(mraa_iio_context dev, float mm[9])
 526 {
 527     char buf[MAX_SIZE];
 528     FILE* fp;
 529
 530     memset(buf, 0, MAX_SIZE);
 531     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_MOUNTING_MATRIX, dev->num);
 532     fp = fopen(buf, "r");
 533     if (fp != NULL) {
 534         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],
 535                &mm[6], &mm[7], &mm[8]);
 536         fclose(fp);
 537         return MRAA_SUCCESS;
 538     }
 539     return MRAA_ERROR_UNSPECIFIED;
 540 }
 541
 542 mraa_result_t
 543 mraa_iio_create_trigger(mraa_iio_context dev, const char* trigger)
 544 {
 545     struct stat configfs_status;
 546     struct stat trigger_status;
 547     char buf[MAX_SIZE];
 548     int ret;
 549
 550     if (stat(IIO_CONFIGFS_TRIGGER, &configfs_status) == 0) {
 551         memset(buf, 0, MAX_SIZE);
 552         snprintf(buf, MAX_SIZE, IIO_CONFIGFS_TRIGGER "%s", trigger);
 553     // we actually don't care if this doesn't succeed, as it just means
 554     // it's already been initialised
 555     mkdir(buf, configfs_status.st_mode);
 556     }
 557
 558     return MRAA_ERROR_UNSPECIFIED;
 559 }
 560
 561 mraa_result_t
 562 mraa_iio_update_channels(mraa_iio_context dev)
 563 {
 564     const struct dirent* ent;
 565     DIR* dir;
 566     int chan_num = 0;
 567     char buf[MAX_SIZE];
 568     char readbuf[32];
 569     int fd;
 570     mraa_iio_channel* chan;
 571
 572     dev->datasize = 0;
 573     memset(buf, 0, MAX_SIZE);
 574     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM, dev->num);
 575     dir = opendir(buf);
 576     if (dir != NULL) {
 577         while ((ent = readdir(dir)) != NULL) {
 578             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_index"), "_index") == 0) {
 579                 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM "/%s", dev->num, ent->d_name);
 580                 fd = open(buf, O_RDONLY);
 581                 if (fd != -1) {
 582                     if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 583                         close(fd);
 584                         break;
 585                     }
 586                     chan_num = ((int) strtol(readbuf, NULL, 10));
 587                     if (chan_num >= 0 && chan_num < dev->chan_num) {
 588                         chan = &dev->channels[chan_num];
 589                         chan->index = chan_num;
 590                         close(fd);
 591
 592                         buf[(strlen(buf) - 5)] = '\0';
 593                         char* str = strdup(buf);
 594                         // grab the enable flag of channel
 595                         snprintf(buf, MAX_SIZE, "%sen", str);
 596                         fd = open(buf, O_RDONLY);
 597                         if (fd != -1) {
 598                             if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 599                                 syslog(LOG_ERR, "iio: Failed to read a sensible value from sysfs");
 600                                 free(str);
 601                                 return -1;
 602                             }
 603                             chan->enabled = (int) strtol(readbuf, NULL, 10);
 604                             // only calculate enable buffer size for trigger buffer extract data
 605                             if (chan->enabled) {
 606                                 dev->datasize += chan->bytes;
 607                             }
 608                             close(fd);
 609                         }
 610                         // clean up str var
 611                         free(str);
 612                     }
 613                     else {
 614                         close(fd);
 615                     }
 616                 }
 617             }
 618         }
 619     }
 620     return MRAA_SUCCESS;
 621 }
 622
 623 mraa_result_t
 624 mraa_iio_close(mraa_iio_context dev)
 625 {
 626     free(dev->channels);
 627     return MRAA_SUCCESS;
 628 }