drivers/iio/inkern.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* The industrial I/O core in kernel channel mapping
   3  *
   4  * Copyright (c) 2011 Jonathan Cameron
   5  */
   6 #include <linux/err.h>
   7 #include <linux/export.h>
   8 #include <linux/slab.h>
   9 #include <linux/mutex.h>
  10 #include <linux/of.h>
  11
  12 #include <linux/iio/iio.h>
  13 #include "iio_core.h"
  14 #include <linux/iio/machine.h>
  15 #include <linux/iio/driver.h>
  16 #include <linux/iio/consumer.h>
  17
  18 struct iio_map_internal {
  19         struct iio_dev *indio_dev;
  20         struct iio_map *map;
  21         struct list_head l;
  22 };
  23
  24 static LIST_HEAD(iio_map_list);
  25 static DEFINE_MUTEX(iio_map_list_lock);
  26
  27 int iio_map_array_register(struct iio_dev *indio_dev, struct iio_map *maps)
  28 {
  29         int i = 0, ret = 0;
  30         struct iio_map_internal *mapi;
  31
  32         if (maps == NULL)
  33                 return 0;
  34
  35         mutex_lock(&iio_map_list_lock);
  36         while (maps[i].consumer_dev_name != NULL) {
  37                 mapi = kzalloc(sizeof(*mapi), GFP_KERNEL);
  38                 if (mapi == NULL) {
  39                         ret = -ENOMEM;
  40                         goto error_ret;
  41                 }
  42                 mapi->map = &maps[i];
  43                 mapi->indio_dev = indio_dev;
  44                 list_add_tail(&mapi->l, &iio_map_list);
  45                 i++;
  46         }
  47 error_ret:
  48         mutex_unlock(&iio_map_list_lock);
  49
  50         return ret;
  51 }
  52 EXPORT_SYMBOL_GPL(iio_map_array_register);
  53
  54
  55 /*
  56  * Remove all map entries associated with the given iio device
  57  */
  58 int iio_map_array_unregister(struct iio_dev *indio_dev)
  59 {
  60         int ret = -ENODEV;
  61         struct iio_map_internal *mapi, *next;
  62
  63         mutex_lock(&iio_map_list_lock);
  64         list_for_each_entry_safe(mapi, next, &iio_map_list, l) {
  65                 if (indio_dev == mapi->indio_dev) {
  66                         list_del(&mapi->l);
  67                         kfree(mapi);
  68                         ret = 0;
  69                 }
  70         }
  71         mutex_unlock(&iio_map_list_lock);
  72         return ret;
  73 }
  74 EXPORT_SYMBOL_GPL(iio_map_array_unregister);
  75
  76 static const struct iio_chan_spec
  77 *iio_chan_spec_from_name(const struct iio_dev *indio_dev, const char *name)
  78 {
  79         int i;
  80         const struct iio_chan_spec *chan = NULL;
  81
  82         for (i = 0; i < indio_dev->num_channels; i++)
  83                 if (indio_dev->channels[i].datasheet_name &&
  84                     strcmp(name, indio_dev->channels[i].datasheet_name) == 0) {
  85                         chan = &indio_dev->channels[i];
  86                         break;
  87                 }
  88         return chan;
  89 }
  90
  91 #ifdef CONFIG_OF
  92
  93 static int iio_dev_node_match(struct device *dev, const void *data)
  94 {
  95         return dev->of_node == data && dev->type == &iio_device_type;
  96 }
  97
  98 /**
  99  * __of_iio_simple_xlate - translate iiospec to the IIO channel index
 100  * @indio_dev:  pointer to the iio_dev structure
 101  * @iiospec:    IIO specifier as found in the device tree
 102  *
 103  * This is simple translation function, suitable for the most 1:1 mapped
 104  * channels in IIO chips. This function performs only one sanity check:
 105  * whether IIO index is less than num_channels (that is specified in the
 106  * iio_dev).
 107  */
 108 static int __of_iio_simple_xlate(struct iio_dev *indio_dev,
 109                                 const struct of_phandle_args *iiospec)
 110 {
 111         if (!iiospec->args_count)
 112                 return 0;
 113
 114         if (iiospec->args[0] >= indio_dev->num_channels) {
 115                 dev_err(&indio_dev->dev, "invalid channel index %u\n",
 116                         iiospec->args[0]);
 117                 return -EINVAL;
 118         }
 119
 120         return iiospec->args[0];
 121 }
 122
 123 static int __of_iio_channel_get(struct iio_channel *channel,
 124                                 struct device_node *np, int index)
 125 {
 126         struct device *idev;
 127         struct iio_dev *indio_dev;
 128         int err;
 129         struct of_phandle_args iiospec;
 130
 131         err = of_parse_phandle_with_args(np, "io-channels",
 132                                          "#io-channel-cells",
 133                                          index, &iiospec);
 134         if (err)
 135                 return err;
 136
 137         idev = bus_find_device(&iio_bus_type, NULL, iiospec.np,
 138                                iio_dev_node_match);
 139         of_node_put(iiospec.np);
 140         if (idev == NULL)
 141                 return -EPROBE_DEFER;
 142
 143         indio_dev = dev_to_iio_dev(idev);
 144         channel->indio_dev = indio_dev;
 145         if (indio_dev->info->of_xlate)
 146                 index = indio_dev->info->of_xlate(indio_dev, &iiospec);
 147         else
 148                 index = __of_iio_simple_xlate(indio_dev, &iiospec);
 149         if (index < 0)
 150                 goto err_put;
 151         channel->channel = &indio_dev->channels[index];
 152
 153         return 0;
 154
 155 err_put:
 156         iio_device_put(indio_dev);
 157         return index;
 158 }
 159
 160 static struct iio_channel *of_iio_channel_get(struct device_node *np, int index)
 161 {
 162         struct iio_channel *channel;
 163         int err;
 164
 165         if (index < 0)
 166                 return ERR_PTR(-EINVAL);
 167
 168         channel = kzalloc(sizeof(*channel), GFP_KERNEL);
 169         if (channel == NULL)
 170                 return ERR_PTR(-ENOMEM);
 171
 172         err = __of_iio_channel_get(channel, np, index);
 173         if (err)
 174                 goto err_free_channel;
 175
 176         return channel;
 177
 178 err_free_channel:
 179         kfree(channel);
 180         return ERR_PTR(err);
 181 }
 182
 183 static struct iio_channel *of_iio_channel_get_by_name(struct device_node *np,
 184                                                       const char *name)
 185 {
 186         struct iio_channel *chan = NULL;
 187
 188         /* Walk up the tree of devices looking for a matching iio channel */
 189         while (np) {
 190                 int index = 0;
 191
 192                 /*
 193                  * For named iio channels, first look up the name in the
 194                  * "io-channel-names" property.  If it cannot be found, the
 195                  * index will be an error code, and of_iio_channel_get()
 196                  * will fail.
 197                  */
 198                 if (name)
 199                         index = of_property_match_string(np, "io-channel-names",
 200                                                          name);
 201                 chan = of_iio_channel_get(np, index);
 202                 if (!IS_ERR(chan) || PTR_ERR(chan) == -EPROBE_DEFER)
 203                         break;
 204                 else if (name && index >= 0) {
 205                         pr_err("ERROR: could not get IIO channel %pOF:%s(%i)\n",
 206                                 np, name ? name : "", index);
 207                         return NULL;
 208                 }
 209
 210                 /*
 211                  * No matching IIO channel found on this node.
 212                  * If the parent node has a "io-channel-ranges" property,
 213                  * then we can try one of its channels.
 214                  */
 215                 np = np->parent;
 216                 if (np && !of_get_property(np, "io-channel-ranges", NULL))
 217                         return NULL;
 218         }
 219
 220         return chan;
 221 }
 222
 223 static struct iio_channel *of_iio_channel_get_all(struct device *dev)
 224 {
 225         struct iio_channel *chans;
 226         int i, mapind, nummaps = 0;
 227         int ret;
 228
 229         do {
 230                 ret = of_parse_phandle_with_args(dev->of_node,
 231                                                  "io-channels",
 232                                                  "#io-channel-cells",
 233                                                  nummaps, NULL);
 234                 if (ret < 0)
 235                         break;
 236         } while (++nummaps);
 237
 238         if (nummaps == 0)       /* no error, return NULL to search map table */
 239                 return NULL;
 240
 241         /* NULL terminated array to save passing size */
 242         chans = kcalloc(nummaps + 1, sizeof(*chans), GFP_KERNEL);
 243         if (chans == NULL)
 244                 return ERR_PTR(-ENOMEM);
 245
 246         /* Search for OF matches */
 247         for (mapind = 0; mapind < nummaps; mapind++) {
 248                 ret = __of_iio_channel_get(&chans[mapind], dev->of_node,
 249                                            mapind);
 250                 if (ret)
 251                         goto error_free_chans;
 252         }
 253         return chans;
 254
 255 error_free_chans:
 256         for (i = 0; i < mapind; i++)
 257                 iio_device_put(chans[i].indio_dev);
 258         kfree(chans);
 259         return ERR_PTR(ret);
 260 }
 261
 262 #else /* CONFIG_OF */
 263
 264 static inline struct iio_channel *
 265 of_iio_channel_get_by_name(struct device_node *np, const char *name)
 266 {
 267         return NULL;
 268 }
 269
 270 static inline struct iio_channel *of_iio_channel_get_all(struct device *dev)
 271 {
 272         return NULL;
 273 }
 274
 275 #endif /* CONFIG_OF */
 276
 277 static struct iio_channel *iio_channel_get_sys(const char *name,
 278                                                const char *channel_name)
 279 {
 280         struct iio_map_internal *c_i = NULL, *c = NULL;
 281         struct iio_channel *channel;
 282         int err;
 283
 284         if (name == NULL && channel_name == NULL)
 285                 return ERR_PTR(-ENODEV);
 286
 287         /* first find matching entry the channel map */
 288         mutex_lock(&iio_map_list_lock);
 289         list_for_each_entry(c_i, &iio_map_list, l) {
 290                 if ((name && strcmp(name, c_i->map->consumer_dev_name) != 0) ||
 291                     (channel_name &&
 292                      strcmp(channel_name, c_i->map->consumer_channel) != 0))
 293                         continue;
 294                 c = c_i;
 295                 iio_device_get(c->indio_dev);
 296                 break;
 297         }
 298         mutex_unlock(&iio_map_list_lock);
 299         if (c == NULL)
 300                 return ERR_PTR(-ENODEV);
 301
 302         channel = kzalloc(sizeof(*channel), GFP_KERNEL);
 303         if (channel == NULL) {
 304                 err = -ENOMEM;
 305                 goto error_no_mem;
 306         }
 307
 308         channel->indio_dev = c->indio_dev;
 309
 310         if (c->map->adc_channel_label) {
 311                 channel->channel =
 312                         iio_chan_spec_from_name(channel->indio_dev,
 313                                                 c->map->adc_channel_label);
 314
 315                 if (channel->channel == NULL) {
 316                         err = -EINVAL;
 317                         goto error_no_chan;
 318                 }
 319         }
 320
 321         return channel;
 322
 323 error_no_chan:
 324         kfree(channel);
 325 error_no_mem:
 326         iio_device_put(c->indio_dev);
 327         return ERR_PTR(err);
 328 }
 329
 330 struct iio_channel *iio_channel_get(struct device *dev,
 331                                     const char *channel_name)
 332 {
 333         const char *name = dev ? dev_name(dev) : NULL;
 334         struct iio_channel *channel;
 335
 336         if (dev) {
 337                 channel = of_iio_channel_get_by_name(dev->of_node,
 338                                                      channel_name);
 339                 if (channel != NULL)
 340                         return channel;
 341         }
 342
 343         return iio_channel_get_sys(name, channel_name);
 344 }
 345 EXPORT_SYMBOL_GPL(iio_channel_get);
 346
 347 void iio_channel_release(struct iio_channel *channel)
 348 {
 349         if (!channel)
 350                 return;
 351         iio_device_put(channel->indio_dev);
 352         kfree(channel);
 353 }
 354 EXPORT_SYMBOL_GPL(iio_channel_release);
 355
 356 static void devm_iio_channel_free(struct device *dev, void *res)
 357 {
 358         struct iio_channel *channel = *(struct iio_channel **)res;
 359
 360         iio_channel_release(channel);
 361 }
 362
 363 static int devm_iio_channel_match(struct device *dev, void *res, void *data)
 364 {
 365         struct iio_channel **r = res;
 366
 367         if (!r || !*r) {
 368                 WARN_ON(!r || !*r);
 369                 return 0;
 370         }
 371
 372         return *r == data;
 373 }
 374
 375 struct iio_channel *devm_iio_channel_get(struct device *dev,
 376                                          const char *channel_name)
 377 {
 378         struct iio_channel **ptr, *channel;
 379
 380         ptr = devres_alloc(devm_iio_channel_free, sizeof(*ptr), GFP_KERNEL);
 381         if (!ptr)
 382                 return ERR_PTR(-ENOMEM);
 383
 384         channel = iio_channel_get(dev, channel_name);
 385         if (IS_ERR(channel)) {
 386                 devres_free(ptr);
 387                 return channel;
 388         }
 389
 390         *ptr = channel;
 391         devres_add(dev, ptr);
 392
 393         return channel;
 394 }
 395 EXPORT_SYMBOL_GPL(devm_iio_channel_get);
 396
 397 void devm_iio_channel_release(struct device *dev, struct iio_channel *channel)
 398 {
 399         WARN_ON(devres_release(dev, devm_iio_channel_free,
 400                                devm_iio_channel_match, channel));
 401 }
 402 EXPORT_SYMBOL_GPL(devm_iio_channel_release);
 403
 404 struct iio_channel *iio_channel_get_all(struct device *dev)
 405 {
 406         const char *name;
 407         struct iio_channel *chans;
 408         struct iio_map_internal *c = NULL;
 409         int nummaps = 0;
 410         int mapind = 0;
 411         int i, ret;
 412
 413         if (dev == NULL)
 414                 return ERR_PTR(-EINVAL);
 415
 416         chans = of_iio_channel_get_all(dev);
 417         if (chans)
 418                 return chans;
 419
 420         name = dev_name(dev);
 421
 422         mutex_lock(&iio_map_list_lock);
 423         /* first count the matching maps */
 424         list_for_each_entry(c, &iio_map_list, l)
 425                 if (name && strcmp(name, c->map->consumer_dev_name) != 0)
 426                         continue;
 427                 else
 428                         nummaps++;
 429
 430         if (nummaps == 0) {
 431                 ret = -ENODEV;
 432                 goto error_ret;
 433         }
 434
 435         /* NULL terminated array to save passing size */
 436         chans = kcalloc(nummaps + 1, sizeof(*chans), GFP_KERNEL);
 437         if (chans == NULL) {
 438                 ret = -ENOMEM;
 439                 goto error_ret;
 440         }
 441
 442         /* for each map fill in the chans element */
 443         list_for_each_entry(c, &iio_map_list, l) {
 444                 if (name && strcmp(name, c->map->consumer_dev_name) != 0)
 445                         continue;
 446                 chans[mapind].indio_dev = c->indio_dev;
 447                 chans[mapind].data = c->map->consumer_data;
 448                 chans[mapind].channel =
 449                         iio_chan_spec_from_name(chans[mapind].indio_dev,
 450                                                 c->map->adc_channel_label);
 451                 if (chans[mapind].channel == NULL) {
 452                         ret = -EINVAL;
 453                         goto error_free_chans;
 454                 }
 455                 iio_device_get(chans[mapind].indio_dev);
 456                 mapind++;
 457         }
 458         if (mapind == 0) {
 459                 ret = -ENODEV;
 460                 goto error_free_chans;
 461         }
 462         mutex_unlock(&iio_map_list_lock);
 463
 464         return chans;
 465
 466 error_free_chans:
 467         for (i = 0; i < nummaps; i++)
 468                 iio_device_put(chans[i].indio_dev);
 469         kfree(chans);
 470 error_ret:
 471         mutex_unlock(&iio_map_list_lock);
 472
 473         return ERR_PTR(ret);
 474 }
 475 EXPORT_SYMBOL_GPL(iio_channel_get_all);
 476
 477 void iio_channel_release_all(struct iio_channel *channels)
 478 {
 479         struct iio_channel *chan = &channels[0];
 480
 481         while (chan->indio_dev) {
 482                 iio_device_put(chan->indio_dev);
 483                 chan++;
 484         }
 485         kfree(channels);
 486 }
 487 EXPORT_SYMBOL_GPL(iio_channel_release_all);
 488
 489 static void devm_iio_channel_free_all(struct device *dev, void *res)
 490 {
 491         struct iio_channel *channels = *(struct iio_channel **)res;
 492
 493         iio_channel_release_all(channels);
 494 }
 495
 496 struct iio_channel *devm_iio_channel_get_all(struct device *dev)
 497 {
 498         struct iio_channel **ptr, *channels;
 499
 500         ptr = devres_alloc(devm_iio_channel_free_all, sizeof(*ptr), GFP_KERNEL);
 501         if (!ptr)
 502                 return ERR_PTR(-ENOMEM);
 503
 504         channels = iio_channel_get_all(dev);
 505         if (IS_ERR(channels)) {
 506                 devres_free(ptr);
 507                 return channels;
 508         }
 509
 510         *ptr = channels;
 511         devres_add(dev, ptr);
 512
 513         return channels;
 514 }
 515 EXPORT_SYMBOL_GPL(devm_iio_channel_get_all);
 516
 517 void devm_iio_channel_release_all(struct device *dev,
 518                                   struct iio_channel *channels)
 519 {
 520         WARN_ON(devres_release(dev, devm_iio_channel_free_all,
 521                                devm_iio_channel_match, channels));
 522 }
 523 EXPORT_SYMBOL_GPL(devm_iio_channel_release_all);
 524
 525 static int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
 526         enum iio_chan_info_enum info)
 527 {
 528         int unused;
 529         int vals[INDIO_MAX_RAW_ELEMENTS];
 530         int ret;
 531         int val_len = 2;
 532
 533         if (val2 == NULL)
 534                 val2 = &unused;
 535
 536         if (!iio_channel_has_info(chan->channel, info))
 537                 return -EINVAL;
 538
 539         if (chan->indio_dev->info->read_raw_multi) {
 540                 ret = chan->indio_dev->info->read_raw_multi(chan->indio_dev,
 541                                         chan->channel, INDIO_MAX_RAW_ELEMENTS,
 542                                         vals, &val_len, info);
 543                 *val = vals[0];
 544                 *val2 = vals[1];
 545         } else
 546                 ret = chan->indio_dev->info->read_raw(chan->indio_dev,
 547                                         chan->channel, val, val2, info);
 548
 549         return ret;
 550 }
 551
 552 int iio_read_channel_raw(struct iio_channel *chan, int *val)
 553 {
 554         int ret;
 555
 556         mutex_lock(&chan->indio_dev->info_exist_lock);
 557         if (chan->indio_dev->info == NULL) {
 558                 ret = -ENODEV;
 559                 goto err_unlock;
 560         }
 561
 562         ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
 563 err_unlock:
 564         mutex_unlock(&chan->indio_dev->info_exist_lock);
 565
 566         return ret;
 567 }
 568 EXPORT_SYMBOL_GPL(iio_read_channel_raw);
 569
 570 int iio_read_channel_average_raw(struct iio_channel *chan, int *val)
 571 {
 572         int ret;
 573
 574         mutex_lock(&chan->indio_dev->info_exist_lock);
 575         if (chan->indio_dev->info == NULL) {
 576                 ret = -ENODEV;
 577                 goto err_unlock;
 578         }
 579
 580         ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_AVERAGE_RAW);
 581 err_unlock:
 582         mutex_unlock(&chan->indio_dev->info_exist_lock);
 583
 584         return ret;
 585 }
 586 EXPORT_SYMBOL_GPL(iio_read_channel_average_raw);
 587
 588 static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
 589         int raw, int *processed, unsigned int scale)
 590 {
 591         int scale_type, scale_val, scale_val2, offset;
 592         s64 raw64 = raw;
 593         int ret;
 594
 595         ret = iio_channel_read(chan, &offset, NULL, IIO_CHAN_INFO_OFFSET);
 596         if (ret >= 0)
 597                 raw64 += offset;
 598
 599         scale_type = iio_channel_read(chan, &scale_val, &scale_val2,
 600                                         IIO_CHAN_INFO_SCALE);
 601         if (scale_type < 0) {
 602                 /*
 603                  * Just pass raw values as processed if no scaling is
 604                  * available.
 605                  */
 606                 *processed = raw;
 607                 return 0;
 608         }
 609
 610         switch (scale_type) {
 611         case IIO_VAL_INT:
 612                 *processed = raw64 * scale_val;
 613                 break;
 614         case IIO_VAL_INT_PLUS_MICRO:
 615                 if (scale_val2 < 0)
 616                         *processed = -raw64 * scale_val;
 617                 else
 618                         *processed = raw64 * scale_val;
 619                 *processed += div_s64(raw64 * (s64)scale_val2 * scale,
 620                                       1000000LL);
 621                 break;
 622         case IIO_VAL_INT_PLUS_NANO:
 623                 if (scale_val2 < 0)
 624                         *processed = -raw64 * scale_val;
 625                 else
 626                         *processed = raw64 * scale_val;
 627                 *processed += div_s64(raw64 * (s64)scale_val2 * scale,
 628                                       1000000000LL);
 629                 break;
 630         case IIO_VAL_FRACTIONAL:
 631                 *processed = div_s64(raw64 * (s64)scale_val * scale,
 632                                      scale_val2);
 633                 break;
 634         case IIO_VAL_FRACTIONAL_LOG2:
 635                 *processed = (raw64 * (s64)scale_val * scale) >> scale_val2;
 636                 break;
 637         default:
 638                 return -EINVAL;
 639         }
 640
 641         return 0;
 642 }
 643
 644 int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
 645         int *processed, unsigned int scale)
 646 {
 647         int ret;
 648
 649         mutex_lock(&chan->indio_dev->info_exist_lock);
 650         if (chan->indio_dev->info == NULL) {
 651                 ret = -ENODEV;
 652                 goto err_unlock;
 653         }
 654
 655         ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,
 656                                                         scale);
 657 err_unlock:
 658         mutex_unlock(&chan->indio_dev->info_exist_lock);
 659
 660         return ret;
 661 }
 662 EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
 663
 664 int iio_read_channel_attribute(struct iio_channel *chan, int *val, int *val2,
 665                                enum iio_chan_info_enum attribute)
 666 {
 667         int ret;
 668
 669         mutex_lock(&chan->indio_dev->info_exist_lock);
 670         if (chan->indio_dev->info == NULL) {
 671                 ret = -ENODEV;
 672                 goto err_unlock;
 673         }
 674
 675         ret = iio_channel_read(chan, val, val2, attribute);
 676 err_unlock:
 677         mutex_unlock(&chan->indio_dev->info_exist_lock);
 678
 679         return ret;
 680 }
 681 EXPORT_SYMBOL_GPL(iio_read_channel_attribute);
 682
 683 int iio_read_channel_offset(struct iio_channel *chan, int *val, int *val2)
 684 {
 685         return iio_read_channel_attribute(chan, val, val2, IIO_CHAN_INFO_OFFSET);
 686 }
 687 EXPORT_SYMBOL_GPL(iio_read_channel_offset);
 688
 689 int iio_read_channel_processed(struct iio_channel *chan, int *val)
 690 {
 691         int ret;
 692
 693         mutex_lock(&chan->indio_dev->info_exist_lock);
 694         if (chan->indio_dev->info == NULL) {
 695                 ret = -ENODEV;
 696                 goto err_unlock;
 697         }
 698
 699         if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) {
 700                 ret = iio_channel_read(chan, val, NULL,
 701                                        IIO_CHAN_INFO_PROCESSED);
 702         } else {
 703                 ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
 704                 if (ret < 0)
 705                         goto err_unlock;
 706                 ret = iio_convert_raw_to_processed_unlocked(chan, *val, val, 1);
 707         }
 708
 709 err_unlock:
 710         mutex_unlock(&chan->indio_dev->info_exist_lock);
 711
 712         return ret;
 713 }
 714 EXPORT_SYMBOL_GPL(iio_read_channel_processed);
 715
 716 int iio_read_channel_scale(struct iio_channel *chan, int *val, int *val2)
 717 {
 718         return iio_read_channel_attribute(chan, val, val2, IIO_CHAN_INFO_SCALE);
 719 }
 720 EXPORT_SYMBOL_GPL(iio_read_channel_scale);
 721
 722 static int iio_channel_read_avail(struct iio_channel *chan,
 723                                   const int **vals, int *type, int *length,
 724                                   enum iio_chan_info_enum info)
 725 {
 726         if (!iio_channel_has_available(chan->channel, info))
 727                 return -EINVAL;
 728
 729         return chan->indio_dev->info->read_avail(chan->indio_dev, chan->channel,
 730                                                  vals, type, length, info);
 731 }
 732
 733 int iio_read_avail_channel_attribute(struct iio_channel *chan,
 734                                      const int **vals, int *type, int *length,
 735                                      enum iio_chan_info_enum attribute)
 736 {
 737         int ret;
 738
 739         mutex_lock(&chan->indio_dev->info_exist_lock);
 740         if (!chan->indio_dev->info) {
 741                 ret = -ENODEV;
 742                 goto err_unlock;
 743         }
 744
 745         ret = iio_channel_read_avail(chan, vals, type, length, attribute);
 746 err_unlock:
 747         mutex_unlock(&chan->indio_dev->info_exist_lock);
 748
 749         return ret;
 750 }
 751 EXPORT_SYMBOL_GPL(iio_read_avail_channel_attribute);
 752
 753 int iio_read_avail_channel_raw(struct iio_channel *chan,
 754                                const int **vals, int *length)
 755 {
 756         int ret;
 757         int type;
 758
 759         ret = iio_read_avail_channel_attribute(chan, vals, &type, length,
 760                                          IIO_CHAN_INFO_RAW);
 761
 762         if (ret >= 0 && type != IIO_VAL_INT)
 763                 /* raw values are assumed to be IIO_VAL_INT */
 764                 ret = -EINVAL;
 765
 766         return ret;
 767 }
 768 EXPORT_SYMBOL_GPL(iio_read_avail_channel_raw);
 769
 770 static int iio_channel_read_max(struct iio_channel *chan,
 771                                 int *val, int *val2, int *type,
 772                                 enum iio_chan_info_enum info)
 773 {
 774         int unused;
 775         const int *vals;
 776         int length;
 777         int ret;
 778
 779         if (!val2)
 780                 val2 = &unused;
 781
 782         ret = iio_channel_read_avail(chan, &vals, type, &length, info);
 783         switch (ret) {
 784         case IIO_AVAIL_RANGE:
 785                 switch (*type) {
 786                 case IIO_VAL_INT:
 787                         *val = vals[2];
 788                         break;
 789                 default:
 790                         *val = vals[4];
 791                         *val2 = vals[5];
 792                 }
 793                 return 0;
 794
 795         case IIO_AVAIL_LIST:
 796                 if (length <= 0)
 797                         return -EINVAL;
 798                 switch (*type) {
 799                 case IIO_VAL_INT:
 800                         *val = vals[--length];
 801                         while (length) {
 802                                 if (vals[--length] > *val)
 803                                         *val = vals[length];
 804                         }
 805                         break;
 806                 default:
 807                         /* FIXME: learn about max for other iio values */
 808                         return -EINVAL;
 809                 }
 810                 return 0;
 811
 812         default:
 813                 return ret;
 814         }
 815 }
 816
 817 int iio_read_max_channel_raw(struct iio_channel *chan, int *val)
 818 {
 819         int ret;
 820         int type;
 821
 822         mutex_lock(&chan->indio_dev->info_exist_lock);
 823         if (!chan->indio_dev->info) {
 824                 ret = -ENODEV;
 825                 goto err_unlock;
 826         }
 827
 828         ret = iio_channel_read_max(chan, val, NULL, &type, IIO_CHAN_INFO_RAW);
 829 err_unlock:
 830         mutex_unlock(&chan->indio_dev->info_exist_lock);
 831
 832         return ret;
 833 }
 834 EXPORT_SYMBOL_GPL(iio_read_max_channel_raw);
 835
 836 int iio_get_channel_type(struct iio_channel *chan, enum iio_chan_type *type)
 837 {
 838         int ret = 0;
 839         /* Need to verify underlying driver has not gone away */
 840
 841         mutex_lock(&chan->indio_dev->info_exist_lock);
 842         if (chan->indio_dev->info == NULL) {
 843                 ret = -ENODEV;
 844                 goto err_unlock;
 845         }
 846
 847         *type = chan->channel->type;
 848 err_unlock:
 849         mutex_unlock(&chan->indio_dev->info_exist_lock);
 850
 851         return ret;
 852 }
 853 EXPORT_SYMBOL_GPL(iio_get_channel_type);
 854
 855 static int iio_channel_write(struct iio_channel *chan, int val, int val2,
 856                              enum iio_chan_info_enum info)
 857 {
 858         return chan->indio_dev->info->write_raw(chan->indio_dev,
 859                                                 chan->channel, val, val2, info);
 860 }
 861
 862 int iio_write_channel_attribute(struct iio_channel *chan, int val, int val2,
 863                                 enum iio_chan_info_enum attribute)
 864 {
 865         int ret;
 866
 867         mutex_lock(&chan->indio_dev->info_exist_lock);
 868         if (chan->indio_dev->info == NULL) {
 869                 ret = -ENODEV;
 870                 goto err_unlock;
 871         }
 872
 873         ret = iio_channel_write(chan, val, val2, attribute);
 874 err_unlock:
 875         mutex_unlock(&chan->indio_dev->info_exist_lock);
 876
 877         return ret;
 878 }
 879 EXPORT_SYMBOL_GPL(iio_write_channel_attribute);
 880
 881 int iio_write_channel_raw(struct iio_channel *chan, int val)
 882 {
 883         return iio_write_channel_attribute(chan, val, 0, IIO_CHAN_INFO_RAW);
 884 }
 885 EXPORT_SYMBOL_GPL(iio_write_channel_raw);
 886
 887 unsigned int iio_get_channel_ext_info_count(struct iio_channel *chan)
 888 {
 889         const struct iio_chan_spec_ext_info *ext_info;
 890         unsigned int i = 0;
 891
 892         if (!chan->channel->ext_info)
 893                 return i;
 894
 895         for (ext_info = chan->channel->ext_info; ext_info->name; ext_info++)
 896                 ++i;
 897
 898         return i;
 899 }
 900 EXPORT_SYMBOL_GPL(iio_get_channel_ext_info_count);
 901
 902 static const struct iio_chan_spec_ext_info *iio_lookup_ext_info(
 903                                                 const struct iio_channel *chan,
 904                                                 const char *attr)
 905 {
 906         const struct iio_chan_spec_ext_info *ext_info;
 907
 908         if (!chan->channel->ext_info)
 909                 return NULL;
 910
 911         for (ext_info = chan->channel->ext_info; ext_info->name; ++ext_info) {
 912                 if (!strcmp(attr, ext_info->name))
 913                         return ext_info;
 914         }
 915
 916         return NULL;
 917 }
 918
 919 ssize_t iio_read_channel_ext_info(struct iio_channel *chan,
 920                                   const char *attr, char *buf)
 921 {
 922         const struct iio_chan_spec_ext_info *ext_info;
 923
 924         ext_info = iio_lookup_ext_info(chan, attr);
 925         if (!ext_info)
 926                 return -EINVAL;
 927
 928         return ext_info->read(chan->indio_dev, ext_info->private,
 929                               chan->channel, buf);
 930 }
 931 EXPORT_SYMBOL_GPL(iio_read_channel_ext_info);
 932
 933 ssize_t iio_write_channel_ext_info(struct iio_channel *chan, const char *attr,
 934                                    const char *buf, size_t len)
 935 {
 936         const struct iio_chan_spec_ext_info *ext_info;
 937
 938         ext_info = iio_lookup_ext_info(chan, attr);
 939         if (!ext_info)
 940                 return -EINVAL;
 941
 942         return ext_info->write(chan->indio_dev, ext_info->private,
 943                                chan->channel, buf, len);
 944 }
 945 EXPORT_SYMBOL_GPL(iio_write_channel_ext_info);