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 > 0) {
 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 > 0) {
 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 > 0) {
 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                         return -1;
 161                     }
 162                     chan->enabled = (int) strtol(readbuf, NULL, 10);
 163                     // only calculate enable buffer size for trigger buffer extract data
 164                     if (chan->enabled) {
 165                         dev->datasize += chan->bytes;
 166                     }
 167                     close(fd);
 168                 }
 169                 // clean up str var
 170                 free(str);
 171             }
 172         }
 173     }
 174     closedir(dir);
 175
 176     return MRAA_SUCCESS;
 177 }
 178
 179 const char*
 180 mraa_iio_get_device_name(mraa_iio_context dev)
 181 {
 182     return dev->name;
 183 }
 184
 185 int
 186 mraa_iio_get_device_num_by_name(const char* name)
 187 {
 188     int i;
 189
 190     if (plat_iio == NULL) {
 191         syslog(LOG_ERR, "iio: platform IIO structure is not initialized");
 192         return -1;
 193     }
 194
 195     if (name == NULL) {
 196         syslog(LOG_ERR, "iio: device name is NULL, unable to find its number");
 197         return -1;
 198     }
 199
 200     for (i = 0; i < plat_iio->iio_device_count; i++) {
 201         struct _iio* device;
 202         device = &plat_iio->iio_devices[i];
 203         // we want to check for exact match
 204         if (strncmp(device->name, name, strlen(device->name) + 1) == 0) {
 205             return device->num;
 206         }
 207     }
 208
 209     return -1;
 210 }
 211
 212 mraa_result_t
 213 mraa_iio_read_float(mraa_iio_context dev, const char* attr_name, float* data)
 214 {
 215     char buf[MAX_SIZE];
 216     mraa_result_t result = mraa_iio_read_string(dev, attr_name, buf, MAX_SIZE-1);
 217     if (result != MRAA_SUCCESS)
 218         return result;
 219     int status = sscanf(buf, "%f", data);
 220     result = status == 1 ? MRAA_SUCCESS : MRAA_ERROR_UNSPECIFIED;
 221     return result;
 222 }
 223
 224
 225 mraa_result_t
 226 mraa_iio_read_int(mraa_iio_context dev, const char* attr_name, int* data)
 227 {
 228     char buf[MAX_SIZE];
 229     mraa_result_t result = mraa_iio_read_string(dev, attr_name, buf, MAX_SIZE-1);
 230     if (result != MRAA_SUCCESS)
 231         return result;
 232     int status = sscanf(buf, "%d", data);
 233     result = status == 1 ? MRAA_SUCCESS : MRAA_ERROR_UNSPECIFIED;
 234     return result;
 235 }
 236
 237 mraa_result_t
 238 mraa_iio_read_string(mraa_iio_context dev, const char* attr_name, char* data, int max_len)
 239 {
 240     char buf[MAX_SIZE];
 241     mraa_result_t result = MRAA_ERROR_UNSPECIFIED;
 242     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, attr_name);
 243     int fd = open(buf, O_RDONLY);
 244     if (fd != -1) {
 245         ssize_t len = read(fd, data, max_len);
 246         if (len > 0)
 247             result = MRAA_SUCCESS;
 248         close(fd);
 249     }
 250     return result;
 251
 252 }
 253
 254 mraa_result_t
 255 mraa_iio_write_float(mraa_iio_context dev, const char* attr_name, const float data)
 256 {
 257     char buf[MAX_SIZE];
 258     snprintf(buf, MAX_SIZE, "%f", data);
 259     return mraa_iio_write_string(dev, attr_name, buf);
 260 }
 261
 262 mraa_result_t
 263 mraa_iio_write_int(mraa_iio_context dev, const char* attr_name, const int data)
 264 {
 265     char buf[MAX_SIZE];
 266     snprintf(buf, MAX_SIZE, "%d", data);
 267     return mraa_iio_write_string(dev, attr_name, buf);
 268 }
 269
 270 mraa_result_t
 271 mraa_iio_write_string(mraa_iio_context dev, const char* attr_name, const char* data)
 272 {
 273     char buf[MAX_SIZE];
 274     mraa_result_t result = MRAA_ERROR_UNSPECIFIED;
 275     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/%s", dev->num, attr_name);
 276     int fd = open(buf, O_WRONLY);
 277     if (fd != -1) {
 278         size_t len = strlen(data);
 279         ssize_t status = write(fd, data, len);
 280         if (status == len)
 281              result = MRAA_SUCCESS;
 282         close(fd);
 283     }
 284     return result;
 285 }
 286
 287 static mraa_result_t
 288 mraa_iio_wait_event(int fd, char* data, int* read_size)
 289 {
 290     struct pollfd pfd;
 291
 292     if (fd < 0) {
 293         return MRAA_ERROR_INVALID_RESOURCE;
 294     }
 295
 296     pfd.fd = fd;
 297     pfd.events = POLLIN;
 298
 299     // Wait for it forever or until pthread_cancel
 300     // poll is a cancelable point like sleep()
 301     int x = poll(&pfd, 1, -1);
 302
 303     memset(data, 0, 100);
 304     *read_size = read(fd, data, 100);
 305
 306     return MRAA_SUCCESS;
 307 }
 308
 309 static void*
 310 mraa_iio_trigger_handler(void* arg)
 311 {
 312     mraa_iio_context dev = (mraa_iio_context) arg;
 313     int i;
 314     char data[MAX_SIZE * 100];
 315     int read_size;
 316
 317     for (;;) {
 318         if (mraa_iio_wait_event(dev->fp, &data[0], &read_size) == MRAA_SUCCESS) {
 319             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 320             // only can process if readsize >= enabled channel's datasize
 321             for (i = 0; i < (read_size / dev->datasize); i++) {
 322                 dev->isr((void*)&data);
 323             }
 324             pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 325         } else {
 326             // we must have got an error code so die nicely
 327             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 328             return NULL;
 329         }
 330     }
 331 }
 332
 333 mraa_result_t
 334 mraa_iio_trigger_buffer(mraa_iio_context dev, void (*fptr)(char* data), void* args)
 335 {
 336     char bu[MAX_SIZE];
 337     if (dev->thread_id != 0) {
 338         return MRAA_ERROR_NO_RESOURCES;
 339     }
 340
 341     sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
 342     dev->fp = open(bu, O_RDONLY | O_NONBLOCK);
 343     if (dev->fp == -1) {
 344         return MRAA_ERROR_INVALID_RESOURCE;
 345     }
 346
 347     dev->isr = fptr;
 348     pthread_create(&dev->thread_id, NULL, mraa_iio_trigger_handler, (void*) dev);
 349
 350     return MRAA_SUCCESS;
 351 }
 352
 353 mraa_result_t
 354 mraa_iio_get_event_data(mraa_iio_context dev)
 355 {
 356     const struct dirent* ent;
 357     DIR* dir;
 358     int event_num = 0;
 359     char buf[MAX_SIZE];
 360     char readbuf[32];
 361     int fd;
 362     int ret = 0;
 363     int padint = 0;
 364     int curr_bytes = 0;
 365     char shortbuf, signchar;
 366     memset(buf, 0, MAX_SIZE);
 367     snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS, dev->num);
 368     dir = opendir(buf);
 369     if (dir != NULL) {
 370         while ((ent = readdir(dir)) != NULL) {
 371             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
 372                 event_num++;
 373             }
 374         }
 375         dev->event_num = event_num;
 376         // no need proceed if no event found
 377         if (event_num == 0) {
 378             closedir(dir);
 379             return MRAA_SUCCESS;
 380         }
 381         mraa_iio_event* event;
 382         dev->events = calloc(event_num, sizeof(mraa_iio_event));
 383         if (dev->events == NULL) {
 384             closedir(dir);
 385             return MRAA_ERROR_UNSPECIFIED;
 386         }
 387         rewinddir(dir);
 388         event_num = 0;
 389         while ((ent = readdir(dir)) != NULL) {
 390             if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
 391                 event = &dev->events[event_num];
 392                 event->name = strdup(ent->d_name);
 393                 snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_EVENTS "/%s", dev->num, ent->d_name);
 394                 fd = open(buf, O_RDONLY);
 395                 if (fd > 0) {
 396                     if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 397                         break;
 398                     }
 399                     close(fd);
 400                 }
 401                 event->enabled = ((int) strtol(readbuf, NULL, 10));
 402                 // Todo, read other event info.
 403                 event_num++;
 404             }
 405         }
 406         closedir(dir);
 407     }
 408     return MRAA_SUCCESS;
 409 }
 410
 411 static mraa_result_t
 412 mraa_iio_event_poll_nonblock(int fd, struct iio_event_data* data)
 413 {
 414     struct pollfd pfd;
 415
 416     if (fd < 0) {
 417         return MRAA_ERROR_INVALID_RESOURCE;
 418     }
 419
 420     pfd.fd = fd;
 421     pfd.events = POLLIN;
 422
 423     // Wait for it forever or until pthread_cancel
 424     // poll is a cancelable point like sleep()
 425     int x = poll(&pfd, 1, -1);
 426
 427     read(fd, data, sizeof(struct iio_event_data));
 428
 429     return MRAA_SUCCESS;
 430 }
 431
 432 mraa_result_t
 433 mraa_iio_event_poll(mraa_iio_context dev, struct iio_event_data* data)
 434 {
 435     char bu[MAX_SIZE];
 436     int ret;
 437     int event_fd;
 438     int fd;
 439
 440     sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
 441     fd = open(bu, 0);
 442     ret = ioctl(fd, IIO_GET_EVENT_FD_IOCTL, &event_fd);
 443     close(fd);
 444
 445     if (ret == -1 || event_fd == -1)
 446         return MRAA_ERROR_UNSPECIFIED;
 447
 448     ret = read(event_fd, data, sizeof(struct iio_event_data));
 449
 450     close(event_fd);
 451     return MRAA_SUCCESS;
 452 }
 453
 454 static void*
 455 mraa_iio_event_handler(void* arg)
 456 {
 457     struct iio_event_data data;
 458     mraa_iio_context dev = (mraa_iio_context) arg;
 459
 460     for (;;) {
 461         if (mraa_iio_event_poll_nonblock(dev->fp_event, &data) == MRAA_SUCCESS) {
 462             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 463             dev->isr_event(&data, dev->isr_args);
 464             pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 465         } else {
 466             // we must have got an error code so die nicely
 467             pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 468             return NULL;
 469         }
 470     }
 471 }
 472
 473 mraa_result_t
 474 mraa_iio_event_setup_callback(mraa_iio_context dev, void (*fptr)(struct iio_event_data* data, void* args), void* args)
 475 {
 476     int ret;
 477     char bu[MAX_SIZE];
 478     if (dev->thread_id != 0) {
 479         return MRAA_ERROR_NO_RESOURCES;
 480     }
 481
 482     sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
 483     dev->fp = open(bu, O_RDONLY | O_NONBLOCK);
 484     if (dev->fp == -1) {
 485         return MRAA_ERROR_INVALID_RESOURCE;
 486     }
 487     ret = ioctl(dev->fp, IIO_GET_EVENT_FD_IOCTL, &dev->fp_event);
 488     close(dev->fp);
 489
 490     if (ret == -1 || dev->fp_event == -1) {
 491         return MRAA_ERROR_UNSPECIFIED;
 492     }
 493
 494     dev->isr_event = fptr;
 495     dev->isr_args = args;
 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 mraa_result_t
 540 mraa_iio_create_trigger(mraa_iio_context dev, const char* trigger)
 541 {
 542     struct stat configfs_status;
 543     struct stat trigger_status;
 544     char buf[MAX_SIZE];
 545
 546     if (stat(IIO_CONFIGFS_TRIGGER, &configfs_status) == 0) {
 547         memset(buf, 0, MAX_SIZE);
 548         snprintf(buf, MAX_SIZE, IIO_CONFIGFS_TRIGGER "%s", trigger);
 549         if (stat(buf, &trigger_status) != 0) {
 550             if (mkdir(buf, configfs_status.st_mode) == 0)
 551                 return MRAA_SUCCESS;
 552         } else {
 553             // trigger folder already created
 554             return MRAA_SUCCESS;
 555         }
 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 > 0) {
 582                     if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 583                         break;
 584                     }
 585                     chan_num = ((int) strtol(readbuf, NULL, 10));
 586                     if (chan_num >= 0 && chan_num < dev->chan_num) {
 587                         chan = &dev->channels[chan_num];
 588                         chan->index = chan_num;
 589                         close(fd);
 590
 591                         buf[(strlen(buf) - 5)] = '\0';
 592                         char* str = strdup(buf);
 593                         // grab the enable flag of channel
 594                         snprintf(buf, MAX_SIZE, "%sen", str);
 595                         fd = open(buf, O_RDONLY);
 596                         if (fd > 0) {
 597                             if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
 598                                 syslog(LOG_ERR, "iio: Failed to read a sensible value from sysfs");
 599                                 free(str);
 600                                 return -1;
 601                             }
 602                             chan->enabled = (int) strtol(readbuf, NULL, 10);
 603                             // only calculate enable buffer size for trigger buffer extract data
 604                             if (chan->enabled) {
 605                                 dev->datasize += chan->bytes;
 606                             }
 607                             close(fd);
 608                         }
 609                         // clean up str var
 610                         free(str);
 611                     }
 612                 }
 613             }
 614         }
 615     }
 616     return MRAA_SUCCESS;
 617 }
 618
 619 mraa_result_t
 620 mraa_iio_close(mraa_iio_context dev)
 621 {
 622     free(dev->channels);
 623     return MRAA_SUCCESS;
 624 }