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