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