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