drivers/iio/inkern.c

   1 /* The industrial I/O core in kernel channel mapping
   2  *
   3  * Copyright (c) 2011 Jonathan Cameron
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  */
   9 #include <linux/err.h>
  10 #include <linux/export.h>
  11 #include <linux/slab.h>
  12 #include <linux/mutex.h>
  13 #include <linux/of.h>
  14
  15 #include <linux/iio/iio.h>
  16 #include "iio_core.h"
  17 #include <linux/iio/machine.h>
  18 #include <linux/iio/driver.h>
  19 #include <linux/iio/consumer.h>
  20
  21 struct iio_map_internal {
  22         struct iio_dev *indio_dev;
  23         struct iio_map *map;
  24         struct list_head l;
  25 };
  26
  27 static LIST_HEAD(iio_map_list);
  28 static DEFINE_MUTEX(iio_map_list_lock);
  29
  30 int iio_map_array_register(struct iio_dev *indio_dev, struct iio_map *maps)
  31 {
  32         int i = 0, ret = 0;
  33         struct iio_map_internal *mapi;
  34
  35         if (maps == NULL)
  36                 return 0;
  37
  38         mutex_lock(&iio_map_list_lock);
  39         while (maps[i].consumer_dev_name != NULL) {
  40                 mapi = kzalloc(sizeof(*mapi), GFP_KERNEL);
  41                 if (mapi == NULL) {
  42                         ret = -ENOMEM;
  43                         goto error_ret;
  44                 }
  45                 mapi->map = &maps[i];
  46                 mapi->indio_dev = indio_dev;
  47                 list_add(&mapi->l, &iio_map_list);
  48                 i++;
  49         }
  50 error_ret:
  51         mutex_unlock(&iio_map_list_lock);
  52
  53         return ret;
  54 }
  55 EXPORT_SYMBOL_GPL(iio_map_array_register);
  56
  57
  58 /*
  59  * Remove all map entries associated with the given iio device
  60  */
  61 int iio_map_array_unregister(struct iio_dev *indio_dev)
  62 {
  63         int ret = -ENODEV;
  64         struct iio_map_internal *mapi;
  65         struct list_head *pos, *tmp;
  66
  67         mutex_lock(&iio_map_list_lock);
  68         list_for_each_safe(pos, tmp, &iio_map_list) {
  69                 mapi = list_entry(pos, struct iio_map_internal, l);
  70                 if (indio_dev == mapi->indio_dev) {
  71                         list_del(&mapi->l);
  72                         kfree(mapi);
  73                         ret = 0;
  74                 }
  75         }
  76         mutex_unlock(&iio_map_list_lock);
  77         return ret;
  78 }
  79 EXPORT_SYMBOL_GPL(iio_map_array_unregister);
  80
  81 static const struct iio_chan_spec
  82 *iio_chan_spec_from_name(const struct iio_dev *indio_dev, const char *name)
  83 {
  84         int i;
  85         const struct iio_chan_spec *chan = NULL;
  86
  87         for (i = 0; i < indio_dev->num_channels; i++)
  88                 if (indio_dev->channels[i].datasheet_name &&
  89                     strcmp(name, indio_dev->channels[i].datasheet_name) == 0) {
  90                         chan = &indio_dev->channels[i];
  91                         break;
  92                 }
  93         return chan;
  94 }
  95
  96 #ifdef CONFIG_OF
  97
  98 static int iio_dev_node_match(struct device *dev, void *data)
  99 {
 100         return dev->of_node == data && dev->type == &iio_device_type;
 101 }
 102
 103 /**
 104  * __of_iio_simple_xlate - translate iiospec to the IIO channel index
 105  * @indio_dev:  pointer to the iio_dev structure
 106  * @iiospec:    IIO specifier as found in the device tree
 107  *
 108  * This is simple translation function, suitable for the most 1:1 mapped
 109  * channels in IIO chips. This function performs only one sanity check:
 110  * whether IIO index is less than num_channels (that is specified in the
 111  * iio_dev).
 112  */
 113 static int __of_iio_simple_xlate(struct iio_dev *indio_dev,
 114                                 const struct of_phandle_args *iiospec)
 115 {
 116         if (!iiospec->args_count)
 117                 return 0;
 118
 119         if (iiospec->args[0] >= indio_dev->num_channels)
 120                 return -EINVAL;
 121
 122         return iiospec->args[0];
 123 }
 124
 125 static int __of_iio_channel_get(struct iio_channel *channel,
 126                                 struct device_node *np, int index)
 127 {
 128         struct device *idev;
 129         struct iio_dev *indio_dev;
 130         int err;
 131         struct of_phandle_args iiospec;
 132
 133         err = of_parse_phandle_with_args(np, "io-channels",
 134                                          "#io-channel-cells",
 135                                          index, &iiospec);
 136         if (err)
 137                 return err;
 138
 139         idev = bus_find_device(&iio_bus_type, NULL, iiospec.np,
 140                                iio_dev_node_match);
 141         of_node_put(iiospec.np);
 142         if (idev == NULL)
 143                 return -EPROBE_DEFER;
 144
 145         indio_dev = dev_to_iio_dev(idev);
 146         channel->indio_dev = indio_dev;
 147         if (indio_dev->info->of_xlate)
 148                 index = indio_dev->info->of_xlate(indio_dev, &iiospec);
 149         else
 150                 index = __of_iio_simple_xlate(indio_dev, &iiospec);
 151         if (index < 0)
 152                 goto err_put;
 153         channel->channel = &indio_dev->channels[index];
 154
 155         return 0;
 156
 157 err_put:
 158         iio_device_put(indio_dev);
 159         return index;
 160 }
 161
 162 static struct iio_channel *of_iio_channel_get(struct device_node *np, int index)
 163 {
 164         struct iio_channel *channel;
 165         int err;
 166
 167         if (index < 0)
 168                 return ERR_PTR(-EINVAL);
 169
 170         channel = kzalloc(sizeof(*channel), GFP_KERNEL);
 171         if (channel == NULL)
 172                 return ERR_PTR(-ENOMEM);
 173
 174         err = __of_iio_channel_get(channel, np, index);
 175         if (err)
 176                 goto err_free_channel;
 177
 178         return channel;
 179
 180 err_free_channel:
 181         kfree(channel);
 182         return ERR_PTR(err);
 183 }
 184
 185 static struct iio_channel *of_iio_channel_get_by_name(struct device_node *np,
 186                                                       const char *name)
 187 {
 188         struct iio_channel *chan = NULL;
 189
 190         /* Walk up the tree of devices looking for a matching iio channel */
 191         while (np) {
 192                 int index = 0;
 193
 194                 /*
 195                  * For named iio channels, first look up the name in the
 196                  * "io-channel-names" property.  If it cannot be found, the
 197                  * index will be an error code, and of_iio_channel_get()
 198                  * will fail.
 199                  */
 200                 if (name)
 201                         index = of_property_match_string(np, "io-channel-names",
 202                                                          name);
 203                 chan = of_iio_channel_get(np, index);
 204                 if (!IS_ERR(chan) || PTR_ERR(chan) == -EPROBE_DEFER)
 205                         break;
 206                 else if (name && index >= 0) {
 207                         pr_err("ERROR: could not get IIO channel %s:%s(%i)\n",
 208                                 np->full_name, name ? name : "", index);
 209                         return NULL;
 210                 }
 211
 212                 /*
 213                  * No matching IIO channel found on this node.
 214                  * If the parent node has a "io-channel-ranges" property,
 215                  * then we can try one of its channels.
 216                  */
 217                 np = np->parent;
 218                 if (np && !of_get_property(np, "io-channel-ranges", NULL))
 219                         return NULL;
 220         }
 221
 222         return chan;
 223 }
 224
 225 static struct iio_channel *of_iio_channel_get_all(struct device *dev)
 226 {
 227         struct iio_channel *chans;
 228         int i, mapind, nummaps = 0;
 229         int ret;
 230
 231         do {
 232                 ret = of_parse_phandle_with_args(dev->of_node,
 233                                                  "io-channels",
 234                                                  "#io-channel-cells",
 235                                                  nummaps, NULL);
 236                 if (ret < 0)
 237                         break;
 238         } while (++nummaps);
 239
 240         if (nummaps == 0)       /* no error, return NULL to search map table */
 241                 return NULL;
 242
 243         /* NULL terminated array to save passing size */
 244         chans = kcalloc(nummaps + 1, sizeof(*chans), GFP_KERNEL);
 245         if (chans == NULL)
 246                 return ERR_PTR(-ENOMEM);
 247
 248         /* Search for OF matches */
 249         for (mapind = 0; mapind < nummaps; mapind++) {
 250                 ret = __of_iio_channel_get(&chans[mapind], dev->of_node,
 251                                            mapind);
 252                 if (ret)
 253                         goto error_free_chans;
 254         }
 255         return chans;
 256
 257 error_free_chans:
 258         for (i = 0; i < mapind; i++)
 259                 iio_device_put(chans[i].indio_dev);
 260         kfree(chans);
 261         return ERR_PTR(ret);
 262 }
 263
 264 #else /* CONFIG_OF */
 265
 266 static inline struct iio_channel *
 267 of_iio_channel_get_by_name(struct device_node *np, const char *name)
 268 {
 269         return NULL;
 270 }
 271
 272 static inline struct iio_channel *of_iio_channel_get_all(struct device *dev)
 273 {
 274         return NULL;
 275 }
 276
 277 #endif /* CONFIG_OF */
 278
 279 static struct iio_channel *iio_channel_get_sys(const char *name,
 280                                                const char *channel_name)
 281 {
 282         struct iio_map_internal *c_i = NULL, *c = NULL;
 283         struct iio_channel *channel;
 284         int err;
 285
 286         if (name == NULL && channel_name == NULL)
 287                 return ERR_PTR(-ENODEV);
 288
 289         /* first find matching entry the channel map */
 290         mutex_lock(&iio_map_list_lock);
 291         list_for_each_entry(c_i, &iio_map_list, l) {
 292                 if ((name && strcmp(name, c_i->map->consumer_dev_name) != 0) ||
 293                     (channel_name &&
 294                      strcmp(channel_name, c_i->map->consumer_channel) != 0))
 295                         continue;
 296                 c = c_i;
 297                 iio_device_get(c->indio_dev);
 298                 break;
 299         }
 300         mutex_unlock(&iio_map_list_lock);
 301         if (c == NULL)
 302                 return ERR_PTR(-ENODEV);
 303
 304         channel = kzalloc(sizeof(*channel), GFP_KERNEL);
 305         if (channel == NULL) {
 306                 err = -ENOMEM;
 307                 goto error_no_mem;
 308         }
 309
 310         channel->indio_dev = c->indio_dev;
 311
 312         if (c->map->adc_channel_label) {
 313                 channel->channel =
 314                         iio_chan_spec_from_name(channel->indio_dev,
 315                                                 c->map->adc_channel_label);
 316
 317                 if (channel->channel == NULL) {
 318                         err = -EINVAL;
 319                         goto error_no_chan;
 320                 }
 321         }
 322
 323         return channel;
 324
 325 error_no_chan:
 326         kfree(channel);
 327 error_no_mem:
 328         iio_device_put(c->indio_dev);
 329         return ERR_PTR(err);
 330 }
 331
 332 struct iio_channel *iio_channel_get(struct device *dev,
 333                                     const char *channel_name)
 334 {
 335         const char *name = dev ? dev_name(dev) : NULL;
 336         struct iio_channel *channel;
 337
 338         if (dev) {
 339                 channel = of_iio_channel_get_by_name(dev->of_node,
 340                                                      channel_name);
 341                 if (channel != NULL)
 342                         return channel;
 343         }
 344
 345         return iio_channel_get_sys(name, channel_name);
 346 }
 347 EXPORT_SYMBOL_GPL(iio_channel_get);
 348
 349 void iio_channel_release(struct iio_channel *channel)
 350 {
 351         iio_device_put(channel->indio_dev);
 352         kfree(channel);
 353 }
 354 EXPORT_SYMBOL_GPL(iio_channel_release);
 355
 356 struct iio_channel *iio_channel_get_all(struct device *dev)
 357 {
 358         const char *name;
 359         struct iio_channel *chans;
 360         struct iio_map_internal *c = NULL;
 361         int nummaps = 0;
 362         int mapind = 0;
 363         int i, ret;
 364
 365         if (dev == NULL)
 366                 return ERR_PTR(-EINVAL);
 367
 368         chans = of_iio_channel_get_all(dev);
 369         if (chans)
 370                 return chans;
 371
 372         name = dev_name(dev);
 373
 374         mutex_lock(&iio_map_list_lock);
 375         /* first count the matching maps */
 376         list_for_each_entry(c, &iio_map_list, l)
 377                 if (name && strcmp(name, c->map->consumer_dev_name) != 0)
 378                         continue;
 379                 else
 380                         nummaps++;
 381
 382         if (nummaps == 0) {
 383                 ret = -ENODEV;
 384                 goto error_ret;
 385         }
 386
 387         /* NULL terminated array to save passing size */
 388         chans = kzalloc(sizeof(*chans)*(nummaps + 1), GFP_KERNEL);
 389         if (chans == NULL) {
 390                 ret = -ENOMEM;
 391                 goto error_ret;
 392         }
 393
 394         /* for each map fill in the chans element */
 395         list_for_each_entry(c, &iio_map_list, l) {
 396                 if (name && strcmp(name, c->map->consumer_dev_name) != 0)
 397                         continue;
 398                 chans[mapind].indio_dev = c->indio_dev;
 399                 chans[mapind].data = c->map->consumer_data;
 400                 chans[mapind].channel =
 401                         iio_chan_spec_from_name(chans[mapind].indio_dev,
 402                                                 c->map->adc_channel_label);
 403                 if (chans[mapind].channel == NULL) {
 404                         ret = -EINVAL;
 405                         goto error_free_chans;
 406                 }
 407                 iio_device_get(chans[mapind].indio_dev);
 408                 mapind++;
 409         }
 410         if (mapind == 0) {
 411                 ret = -ENODEV;
 412                 goto error_free_chans;
 413         }
 414         mutex_unlock(&iio_map_list_lock);
 415
 416         return chans;
 417
 418 error_free_chans:
 419         for (i = 0; i < nummaps; i++)
 420                 iio_device_put(chans[i].indio_dev);
 421         kfree(chans);
 422 error_ret:
 423         mutex_unlock(&iio_map_list_lock);
 424
 425         return ERR_PTR(ret);
 426 }
 427 EXPORT_SYMBOL_GPL(iio_channel_get_all);
 428
 429 void iio_channel_release_all(struct iio_channel *channels)
 430 {
 431         struct iio_channel *chan = &channels[0];
 432
 433         while (chan->indio_dev) {
 434                 iio_device_put(chan->indio_dev);
 435                 chan++;
 436         }
 437         kfree(channels);
 438 }
 439 EXPORT_SYMBOL_GPL(iio_channel_release_all);
 440
 441 static int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
 442         enum iio_chan_info_enum info)
 443 {
 444         int unused;
 445         int vals[INDIO_MAX_RAW_ELEMENTS];
 446         int ret;
 447         int val_len = 2;
 448
 449         if (val2 == NULL)
 450                 val2 = &unused;
 451
 452         if (chan->indio_dev->info->read_raw_multi) {
 453                 ret = chan->indio_dev->info->read_raw_multi(chan->indio_dev,
 454                                         chan->channel, INDIO_MAX_RAW_ELEMENTS,
 455                                         vals, &val_len, info);
 456                 *val = vals[0];
 457                 *val2 = vals[1];
 458         } else
 459                 ret = chan->indio_dev->info->read_raw(chan->indio_dev,
 460                                         chan->channel, val, val2, info);
 461
 462         return ret;
 463 }
 464
 465 int iio_read_channel_raw(struct iio_channel *chan, int *val)
 466 {
 467         int ret;
 468
 469         mutex_lock(&chan->indio_dev->info_exist_lock);
 470         if (chan->indio_dev->info == NULL) {
 471                 ret = -ENODEV;
 472                 goto err_unlock;
 473         }
 474
 475         ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
 476 err_unlock:
 477         mutex_unlock(&chan->indio_dev->info_exist_lock);
 478
 479         return ret;
 480 }
 481 EXPORT_SYMBOL_GPL(iio_read_channel_raw);
 482
 483 int iio_read_channel_average_raw(struct iio_channel *chan, int *val)
 484 {
 485         int ret;
 486
 487         mutex_lock(&chan->indio_dev->info_exist_lock);
 488         if (chan->indio_dev->info == NULL) {
 489                 ret = -ENODEV;
 490                 goto err_unlock;
 491         }
 492
 493         ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_AVERAGE_RAW);
 494 err_unlock:
 495         mutex_unlock(&chan->indio_dev->info_exist_lock);
 496
 497         return ret;
 498 }
 499 EXPORT_SYMBOL_GPL(iio_read_channel_average_raw);
 500
 501 static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
 502         int raw, int *processed, unsigned int scale)
 503 {
 504         int scale_type, scale_val, scale_val2, offset;
 505         s64 raw64 = raw;
 506         int ret;
 507
 508         ret = iio_channel_read(chan, &offset, NULL, IIO_CHAN_INFO_OFFSET);
 509         if (ret >= 0)
 510                 raw64 += offset;
 511
 512         scale_type = iio_channel_read(chan, &scale_val, &scale_val2,
 513                                         IIO_CHAN_INFO_SCALE);
 514         if (scale_type < 0)
 515                 return scale_type;
 516
 517         switch (scale_type) {
 518         case IIO_VAL_INT:
 519                 *processed = raw64 * scale_val;
 520                 break;
 521         case IIO_VAL_INT_PLUS_MICRO:
 522                 if (scale_val2 < 0)
 523                         *processed = -raw64 * scale_val;
 524                 else
 525                         *processed = raw64 * scale_val;
 526                 *processed += div_s64(raw64 * (s64)scale_val2 * scale,
 527                                       1000000LL);
 528                 break;
 529         case IIO_VAL_INT_PLUS_NANO:
 530                 if (scale_val2 < 0)
 531                         *processed = -raw64 * scale_val;
 532                 else
 533                         *processed = raw64 * scale_val;
 534                 *processed += div_s64(raw64 * (s64)scale_val2 * scale,
 535                                       1000000000LL);
 536                 break;
 537         case IIO_VAL_FRACTIONAL:
 538                 *processed = div_s64(raw64 * (s64)scale_val * scale,
 539                                      scale_val2);
 540                 break;
 541         case IIO_VAL_FRACTIONAL_LOG2:
 542                 *processed = (raw64 * (s64)scale_val * scale) >> scale_val2;
 543                 break;
 544         default:
 545                 return -EINVAL;
 546         }
 547
 548         return 0;
 549 }
 550
 551 int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
 552         int *processed, unsigned int scale)
 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_convert_raw_to_processed_unlocked(chan, raw, processed,
 563                                                         scale);
 564 err_unlock:
 565         mutex_unlock(&chan->indio_dev->info_exist_lock);
 566
 567         return ret;
 568 }
 569 EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
 570
 571 int iio_read_channel_processed(struct iio_channel *chan, int *val)
 572 {
 573         int ret;
 574
 575         mutex_lock(&chan->indio_dev->info_exist_lock);
 576         if (chan->indio_dev->info == NULL) {
 577                 ret = -ENODEV;
 578                 goto err_unlock;
 579         }
 580
 581         if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) {
 582                 ret = iio_channel_read(chan, val, NULL,
 583                                        IIO_CHAN_INFO_PROCESSED);
 584         } else {
 585                 ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
 586                 if (ret < 0)
 587                         goto err_unlock;
 588                 ret = iio_convert_raw_to_processed_unlocked(chan, *val, val, 1);
 589         }
 590
 591 err_unlock:
 592         mutex_unlock(&chan->indio_dev->info_exist_lock);
 593
 594         return ret;
 595 }
 596 EXPORT_SYMBOL_GPL(iio_read_channel_processed);
 597
 598 int iio_read_channel_scale(struct iio_channel *chan, int *val, int *val2)
 599 {
 600         int ret;
 601
 602         mutex_lock(&chan->indio_dev->info_exist_lock);
 603         if (chan->indio_dev->info == NULL) {
 604                 ret = -ENODEV;
 605                 goto err_unlock;
 606         }
 607
 608         ret = iio_channel_read(chan, val, val2, IIO_CHAN_INFO_SCALE);
 609 err_unlock:
 610         mutex_unlock(&chan->indio_dev->info_exist_lock);
 611
 612         return ret;
 613 }
 614 EXPORT_SYMBOL_GPL(iio_read_channel_scale);
 615
 616 int iio_get_channel_type(struct iio_channel *chan, enum iio_chan_type *type)
 617 {
 618         int ret = 0;
 619         /* Need to verify underlying driver has not gone away */
 620
 621         mutex_lock(&chan->indio_dev->info_exist_lock);
 622         if (chan->indio_dev->info == NULL) {
 623                 ret = -ENODEV;
 624                 goto err_unlock;
 625         }
 626
 627         *type = chan->channel->type;
 628 err_unlock:
 629         mutex_unlock(&chan->indio_dev->info_exist_lock);
 630
 631         return ret;
 632 }
 633 EXPORT_SYMBOL_GPL(iio_get_channel_type);