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