1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
2a980e046SJonathan Cameron /* The industrial I/O core in kernel channel mapping
3a980e046SJonathan Cameron *
4a980e046SJonathan Cameron * Copyright (c) 2011 Jonathan Cameron
5a980e046SJonathan Cameron */
6a980e046SJonathan Cameron #include <linux/err.h>
7a980e046SJonathan Cameron #include <linux/export.h>
897aee715SHerve Codina #include <linux/minmax.h>
9524cfdf6SHerve Codina #include <linux/mutex.h>
101e64b9c5SNuno Sá #include <linux/property.h>
11a980e046SJonathan Cameron #include <linux/slab.h>
12a980e046SJonathan Cameron
13a980e046SJonathan Cameron #include <linux/iio/iio.h>
14b804e2b7SJonathan Cameron #include <linux/iio/iio-opaque.h>
15a980e046SJonathan Cameron #include "iio_core.h"
16a980e046SJonathan Cameron #include <linux/iio/machine.h>
17a980e046SJonathan Cameron #include <linux/iio/driver.h>
18a980e046SJonathan Cameron #include <linux/iio/consumer.h>
19a980e046SJonathan Cameron
20a980e046SJonathan Cameron struct iio_map_internal {
21a980e046SJonathan Cameron struct iio_dev *indio_dev;
22a980e046SJonathan Cameron struct iio_map *map;
23a980e046SJonathan Cameron struct list_head l;
24a980e046SJonathan Cameron };
25a980e046SJonathan Cameron
26a980e046SJonathan Cameron static LIST_HEAD(iio_map_list);
27a980e046SJonathan Cameron static DEFINE_MUTEX(iio_map_list_lock);
28a980e046SJonathan Cameron
iio_map_array_unregister_locked(struct iio_dev * indio_dev)29cc9fb60eSLino Sanfilippo static int iio_map_array_unregister_locked(struct iio_dev *indio_dev)
30cc9fb60eSLino Sanfilippo {
31cc9fb60eSLino Sanfilippo int ret = -ENODEV;
32cc9fb60eSLino Sanfilippo struct iio_map_internal *mapi, *next;
33cc9fb60eSLino Sanfilippo
34cc9fb60eSLino Sanfilippo list_for_each_entry_safe(mapi, next, &iio_map_list, l) {
35cc9fb60eSLino Sanfilippo if (indio_dev == mapi->indio_dev) {
36cc9fb60eSLino Sanfilippo list_del(&mapi->l);
37cc9fb60eSLino Sanfilippo kfree(mapi);
38cc9fb60eSLino Sanfilippo ret = 0;
39cc9fb60eSLino Sanfilippo }
40cc9fb60eSLino Sanfilippo }
41cc9fb60eSLino Sanfilippo return ret;
42cc9fb60eSLino Sanfilippo }
43cc9fb60eSLino Sanfilippo
iio_map_array_register(struct iio_dev * indio_dev,struct iio_map * maps)44a980e046SJonathan Cameron int iio_map_array_register(struct iio_dev *indio_dev, struct iio_map *maps)
45a980e046SJonathan Cameron {
46a980e046SJonathan Cameron int i = 0, ret = 0;
47a980e046SJonathan Cameron struct iio_map_internal *mapi;
48a980e046SJonathan Cameron
49110f1158SNuno Sá if (!maps)
50a980e046SJonathan Cameron return 0;
51a980e046SJonathan Cameron
52a980e046SJonathan Cameron mutex_lock(&iio_map_list_lock);
53110f1158SNuno Sá while (maps[i].consumer_dev_name) {
54a980e046SJonathan Cameron mapi = kzalloc(sizeof(*mapi), GFP_KERNEL);
55110f1158SNuno Sá if (!mapi) {
56a980e046SJonathan Cameron ret = -ENOMEM;
57a980e046SJonathan Cameron goto error_ret;
58a980e046SJonathan Cameron }
59a980e046SJonathan Cameron mapi->map = &maps[i];
60a980e046SJonathan Cameron mapi->indio_dev = indio_dev;
61bc4b2a51SGaurav Gupta list_add_tail(&mapi->l, &iio_map_list);
62a980e046SJonathan Cameron i++;
63a980e046SJonathan Cameron }
64a980e046SJonathan Cameron error_ret:
6534fce6caSLino Sanfilippo if (ret)
6634fce6caSLino Sanfilippo iio_map_array_unregister_locked(indio_dev);
67a980e046SJonathan Cameron mutex_unlock(&iio_map_list_lock);
68a980e046SJonathan Cameron
69a980e046SJonathan Cameron return ret;
70a980e046SJonathan Cameron }
71a980e046SJonathan Cameron EXPORT_SYMBOL_GPL(iio_map_array_register);
72a980e046SJonathan Cameron
736cb2afd7SGuenter Roeck /*
746cb2afd7SGuenter Roeck * Remove all map entries associated with the given iio device
75a980e046SJonathan Cameron */
iio_map_array_unregister(struct iio_dev * indio_dev)766cb2afd7SGuenter Roeck int iio_map_array_unregister(struct iio_dev *indio_dev)
77a980e046SJonathan Cameron {
78cc9fb60eSLino Sanfilippo int ret;
79a980e046SJonathan Cameron
80a980e046SJonathan Cameron mutex_lock(&iio_map_list_lock);
81cc9fb60eSLino Sanfilippo ret = iio_map_array_unregister_locked(indio_dev);
82a980e046SJonathan Cameron mutex_unlock(&iio_map_list_lock);
83cc9fb60eSLino Sanfilippo
84a980e046SJonathan Cameron return ret;
85a980e046SJonathan Cameron }
86a980e046SJonathan Cameron EXPORT_SYMBOL_GPL(iio_map_array_unregister);
87a980e046SJonathan Cameron
iio_map_array_unregister_cb(void * indio_dev)8825c02edfSAlexandru Ardelean static void iio_map_array_unregister_cb(void *indio_dev)
8925c02edfSAlexandru Ardelean {
9025c02edfSAlexandru Ardelean iio_map_array_unregister(indio_dev);
9125c02edfSAlexandru Ardelean }
9225c02edfSAlexandru Ardelean
devm_iio_map_array_register(struct device * dev,struct iio_dev * indio_dev,struct iio_map * maps)9325c02edfSAlexandru Ardelean int devm_iio_map_array_register(struct device *dev, struct iio_dev *indio_dev, struct iio_map *maps)
9425c02edfSAlexandru Ardelean {
9525c02edfSAlexandru Ardelean int ret;
9625c02edfSAlexandru Ardelean
9725c02edfSAlexandru Ardelean ret = iio_map_array_register(indio_dev, maps);
9825c02edfSAlexandru Ardelean if (ret)
9925c02edfSAlexandru Ardelean return ret;
10025c02edfSAlexandru Ardelean
10125c02edfSAlexandru Ardelean return devm_add_action_or_reset(dev, iio_map_array_unregister_cb, indio_dev);
10225c02edfSAlexandru Ardelean }
10325c02edfSAlexandru Ardelean EXPORT_SYMBOL_GPL(devm_iio_map_array_register);
10425c02edfSAlexandru Ardelean
105a980e046SJonathan Cameron static const struct iio_chan_spec
iio_chan_spec_from_name(const struct iio_dev * indio_dev,const char * name)106314be14bSJonathan Cameron *iio_chan_spec_from_name(const struct iio_dev *indio_dev, const char *name)
107a980e046SJonathan Cameron {
108a980e046SJonathan Cameron int i;
109a980e046SJonathan Cameron const struct iio_chan_spec *chan = NULL;
110a980e046SJonathan Cameron
111a980e046SJonathan Cameron for (i = 0; i < indio_dev->num_channels; i++)
112a980e046SJonathan Cameron if (indio_dev->channels[i].datasheet_name &&
113a980e046SJonathan Cameron strcmp(name, indio_dev->channels[i].datasheet_name) == 0) {
114a980e046SJonathan Cameron chan = &indio_dev->channels[i];
115a980e046SJonathan Cameron break;
116a980e046SJonathan Cameron }
117a980e046SJonathan Cameron return chan;
118a980e046SJonathan Cameron }
119a980e046SJonathan Cameron
120acd82567SIvan T. Ivanov /**
1211e64b9c5SNuno Sá * __fwnode_iio_simple_xlate - translate iiospec to the IIO channel index
122acd82567SIvan T. Ivanov * @indio_dev: pointer to the iio_dev structure
123acd82567SIvan T. Ivanov * @iiospec: IIO specifier as found in the device tree
124acd82567SIvan T. Ivanov *
125acd82567SIvan T. Ivanov * This is simple translation function, suitable for the most 1:1 mapped
126acd82567SIvan T. Ivanov * channels in IIO chips. This function performs only one sanity check:
127acd82567SIvan T. Ivanov * whether IIO index is less than num_channels (that is specified in the
128acd82567SIvan T. Ivanov * iio_dev).
129acd82567SIvan T. Ivanov */
__fwnode_iio_simple_xlate(struct iio_dev * indio_dev,const struct fwnode_reference_args * iiospec)1301e64b9c5SNuno Sá static int __fwnode_iio_simple_xlate(struct iio_dev *indio_dev,
1311e64b9c5SNuno Sá const struct fwnode_reference_args *iiospec)
132acd82567SIvan T. Ivanov {
1331e64b9c5SNuno Sá if (!iiospec->nargs)
134acd82567SIvan T. Ivanov return 0;
135acd82567SIvan T. Ivanov
1361f202725SStefan Wahren if (iiospec->args[0] >= indio_dev->num_channels) {
1371e64b9c5SNuno Sá dev_err(&indio_dev->dev, "invalid channel index %llu\n",
1381f202725SStefan Wahren iiospec->args[0]);
139acd82567SIvan T. Ivanov return -EINVAL;
1401f202725SStefan Wahren }
141acd82567SIvan T. Ivanov
142acd82567SIvan T. Ivanov return iiospec->args[0];
143acd82567SIvan T. Ivanov }
144acd82567SIvan T. Ivanov
__fwnode_iio_channel_get(struct iio_channel * channel,struct fwnode_handle * fwnode,int index)1451e64b9c5SNuno Sá static int __fwnode_iio_channel_get(struct iio_channel *channel,
1461e64b9c5SNuno Sá struct fwnode_handle *fwnode, int index)
1471e64b9c5SNuno Sá {
1481e64b9c5SNuno Sá struct fwnode_reference_args iiospec;
14917d82b47SGuenter Roeck struct device *idev;
15017d82b47SGuenter Roeck struct iio_dev *indio_dev;
15117d82b47SGuenter Roeck int err;
15217d82b47SGuenter Roeck
1531e64b9c5SNuno Sá err = fwnode_property_get_reference_args(fwnode, "io-channels",
1541e64b9c5SNuno Sá "#io-channel-cells", 0,
15517d82b47SGuenter Roeck index, &iiospec);
15617d82b47SGuenter Roeck if (err)
15717d82b47SGuenter Roeck return err;
15817d82b47SGuenter Roeck
1591e64b9c5SNuno Sá idev = bus_find_device_by_fwnode(&iio_bus_type, iiospec.fwnode);
160110f1158SNuno Sá if (!idev) {
1611e64b9c5SNuno Sá fwnode_handle_put(iiospec.fwnode);
16217d82b47SGuenter Roeck return -EPROBE_DEFER;
16379c3e848SNuno Sá }
16417d82b47SGuenter Roeck
16517d82b47SGuenter Roeck indio_dev = dev_to_iio_dev(idev);
16617d82b47SGuenter Roeck channel->indio_dev = indio_dev;
167b22bc4d6SNuno Sá if (indio_dev->info->fwnode_xlate)
1681e64b9c5SNuno Sá index = indio_dev->info->fwnode_xlate(indio_dev, &iiospec);
169acd82567SIvan T. Ivanov else
1701e64b9c5SNuno Sá index = __fwnode_iio_simple_xlate(indio_dev, &iiospec);
1711e64b9c5SNuno Sá fwnode_handle_put(iiospec.fwnode);
172acd82567SIvan T. Ivanov if (index < 0)
17317d82b47SGuenter Roeck goto err_put;
17417d82b47SGuenter Roeck channel->channel = &indio_dev->channels[index];
17517d82b47SGuenter Roeck
17617d82b47SGuenter Roeck return 0;
17717d82b47SGuenter Roeck
17817d82b47SGuenter Roeck err_put:
17917d82b47SGuenter Roeck iio_device_put(indio_dev);
180acd82567SIvan T. Ivanov return index;
18117d82b47SGuenter Roeck }
18217d82b47SGuenter Roeck
fwnode_iio_channel_get(struct fwnode_handle * fwnode,int index)1831e64b9c5SNuno Sá static struct iio_channel *fwnode_iio_channel_get(struct fwnode_handle *fwnode,
1841e64b9c5SNuno Sá int index)
18517d82b47SGuenter Roeck {
18617d82b47SGuenter Roeck struct iio_channel *channel;
18717d82b47SGuenter Roeck int err;
18817d82b47SGuenter Roeck
18917d82b47SGuenter Roeck if (index < 0)
19017d82b47SGuenter Roeck return ERR_PTR(-EINVAL);
19117d82b47SGuenter Roeck
19217d82b47SGuenter Roeck channel = kzalloc(sizeof(*channel), GFP_KERNEL);
193110f1158SNuno Sá if (!channel)
19417d82b47SGuenter Roeck return ERR_PTR(-ENOMEM);
19517d82b47SGuenter Roeck
1961e64b9c5SNuno Sá err = __fwnode_iio_channel_get(channel, fwnode, index);
19717d82b47SGuenter Roeck if (err)
19817d82b47SGuenter Roeck goto err_free_channel;
19917d82b47SGuenter Roeck
20017d82b47SGuenter Roeck return channel;
20117d82b47SGuenter Roeck
20217d82b47SGuenter Roeck err_free_channel:
20317d82b47SGuenter Roeck kfree(channel);
20417d82b47SGuenter Roeck return ERR_PTR(err);
20517d82b47SGuenter Roeck }
20617d82b47SGuenter Roeck
2071e64b9c5SNuno Sá static struct iio_channel *
__fwnode_iio_channel_get_by_name(struct fwnode_handle * fwnode,const char * name)2081e64b9c5SNuno Sá __fwnode_iio_channel_get_by_name(struct fwnode_handle *fwnode, const char *name)
20917d82b47SGuenter Roeck {
210ed5e5ed4SNuno Sá struct iio_channel *chan;
21117d82b47SGuenter Roeck int index = 0;
21217d82b47SGuenter Roeck
21317d82b47SGuenter Roeck /*
21417d82b47SGuenter Roeck * For named iio channels, first look up the name in the
21517d82b47SGuenter Roeck * "io-channel-names" property. If it cannot be found, the
2161e64b9c5SNuno Sá * index will be an error code, and fwnode_iio_channel_get()
21717d82b47SGuenter Roeck * will fail.
21817d82b47SGuenter Roeck */
21917d82b47SGuenter Roeck if (name)
2201e64b9c5SNuno Sá index = fwnode_property_match_string(fwnode, "io-channel-names",
2211e64b9c5SNuno Sá name);
222d6bb09eaSNuno Sá
2231e64b9c5SNuno Sá chan = fwnode_iio_channel_get(fwnode, index);
224872687f6SJohannes Pointner if (!IS_ERR(chan) || PTR_ERR(chan) == -EPROBE_DEFER)
225ed5e5ed4SNuno Sá return chan;
226ed5e5ed4SNuno Sá if (name) {
227ed5e5ed4SNuno Sá if (index >= 0) {
2281e64b9c5SNuno Sá pr_err("ERROR: could not get IIO channel %pfw:%s(%i)\n",
2291e64b9c5SNuno Sá fwnode, name, index);
230ed5e5ed4SNuno Sá /*
231ed5e5ed4SNuno Sá * In this case, we found 'name' in 'io-channel-names'
232ed5e5ed4SNuno Sá * but somehow we still fail so that we should not proceed
233ed5e5ed4SNuno Sá * with any other lookup. Hence, explicitly return -EINVAL
234ed5e5ed4SNuno Sá * (maybe not the better error code) so that the caller
235ed5e5ed4SNuno Sá * won't do a system lookup.
236ed5e5ed4SNuno Sá */
237ed5e5ed4SNuno Sá return ERR_PTR(-EINVAL);
238ed5e5ed4SNuno Sá }
239ed5e5ed4SNuno Sá /*
2401e64b9c5SNuno Sá * If index < 0, then fwnode_property_get_reference_args() fails
2411e64b9c5SNuno Sá * with -EINVAL or -ENOENT (ACPI case) which is expected. We
2421e64b9c5SNuno Sá * should not proceed if we get any other error.
243ed5e5ed4SNuno Sá */
2441e64b9c5SNuno Sá if (PTR_ERR(chan) != -EINVAL && PTR_ERR(chan) != -ENOENT)
245ed5e5ed4SNuno Sá return chan;
246ed5e5ed4SNuno Sá } else if (PTR_ERR(chan) != -ENOENT) {
247ed5e5ed4SNuno Sá /*
248ed5e5ed4SNuno Sá * if !name, then we should only proceed the lookup if
2491e64b9c5SNuno Sá * fwnode_property_get_reference_args() returns -ENOENT.
250ed5e5ed4SNuno Sá */
251ed5e5ed4SNuno Sá return chan;
25217d82b47SGuenter Roeck }
25317d82b47SGuenter Roeck
254d6bb09eaSNuno Sá /* so we continue the lookup */
255d6bb09eaSNuno Sá return ERR_PTR(-ENODEV);
256d6bb09eaSNuno Sá }
257d6bb09eaSNuno Sá
fwnode_iio_channel_get_by_name(struct fwnode_handle * fwnode,const char * name)2581e64b9c5SNuno Sá struct iio_channel *fwnode_iio_channel_get_by_name(struct fwnode_handle *fwnode,
259d6bb09eaSNuno Sá const char *name)
260d6bb09eaSNuno Sá {
2611e64b9c5SNuno Sá struct fwnode_handle *parent;
262d6bb09eaSNuno Sá struct iio_channel *chan;
263d6bb09eaSNuno Sá
264d6bb09eaSNuno Sá /* Walk up the tree of devices looking for a matching iio channel */
2651e64b9c5SNuno Sá chan = __fwnode_iio_channel_get_by_name(fwnode, name);
266d6bb09eaSNuno Sá if (!IS_ERR(chan) || PTR_ERR(chan) != -ENODEV)
267d6bb09eaSNuno Sá return chan;
268d6bb09eaSNuno Sá
26917d82b47SGuenter Roeck /*
27017d82b47SGuenter Roeck * No matching IIO channel found on this node.
27117d82b47SGuenter Roeck * If the parent node has a "io-channel-ranges" property,
27217d82b47SGuenter Roeck * then we can try one of its channels.
27317d82b47SGuenter Roeck */
2741e64b9c5SNuno Sá fwnode_for_each_parent_node(fwnode, parent) {
2751e64b9c5SNuno Sá if (!fwnode_property_present(parent, "io-channel-ranges")) {
2761e64b9c5SNuno Sá fwnode_handle_put(parent);
277ed5e5ed4SNuno Sá return ERR_PTR(-ENODEV);
2781e64b9c5SNuno Sá }
279d6bb09eaSNuno Sá
2801e64b9c5SNuno Sá chan = __fwnode_iio_channel_get_by_name(fwnode, name);
2811e64b9c5SNuno Sá if (!IS_ERR(chan) || PTR_ERR(chan) != -ENODEV) {
2821e64b9c5SNuno Sá fwnode_handle_put(parent);
283d6bb09eaSNuno Sá return chan;
2841e64b9c5SNuno Sá }
28517d82b47SGuenter Roeck }
286a2c12493SAdam Thomson
287ed5e5ed4SNuno Sá return ERR_PTR(-ENODEV);
28817d82b47SGuenter Roeck }
2891e64b9c5SNuno Sá EXPORT_SYMBOL_GPL(fwnode_iio_channel_get_by_name);
29017d82b47SGuenter Roeck
fwnode_iio_channel_get_all(struct device * dev)2911e64b9c5SNuno Sá static struct iio_channel *fwnode_iio_channel_get_all(struct device *dev)
29217d82b47SGuenter Roeck {
2931e64b9c5SNuno Sá struct fwnode_handle *fwnode = dev_fwnode(dev);
29417d82b47SGuenter Roeck struct iio_channel *chans;
29517d82b47SGuenter Roeck int i, mapind, nummaps = 0;
29617d82b47SGuenter Roeck int ret;
29717d82b47SGuenter Roeck
29817d82b47SGuenter Roeck do {
2991e64b9c5SNuno Sá ret = fwnode_property_get_reference_args(fwnode, "io-channels",
3001e64b9c5SNuno Sá "#io-channel-cells", 0,
30117d82b47SGuenter Roeck nummaps, NULL);
30217d82b47SGuenter Roeck if (ret < 0)
30317d82b47SGuenter Roeck break;
30417d82b47SGuenter Roeck } while (++nummaps);
30517d82b47SGuenter Roeck
306ed5e5ed4SNuno Sá if (nummaps == 0)
307ed5e5ed4SNuno Sá return ERR_PTR(-ENODEV);
30817d82b47SGuenter Roeck
30917d82b47SGuenter Roeck /* NULL terminated array to save passing size */
31017d82b47SGuenter Roeck chans = kcalloc(nummaps + 1, sizeof(*chans), GFP_KERNEL);
311110f1158SNuno Sá if (!chans)
31217d82b47SGuenter Roeck return ERR_PTR(-ENOMEM);
31317d82b47SGuenter Roeck
3141e64b9c5SNuno Sá /* Search for FW matches */
31517d82b47SGuenter Roeck for (mapind = 0; mapind < nummaps; mapind++) {
3161e64b9c5SNuno Sá ret = __fwnode_iio_channel_get(&chans[mapind], fwnode, mapind);
31717d82b47SGuenter Roeck if (ret)
31817d82b47SGuenter Roeck goto error_free_chans;
31917d82b47SGuenter Roeck }
32017d82b47SGuenter Roeck return chans;
32117d82b47SGuenter Roeck
32217d82b47SGuenter Roeck error_free_chans:
32317d82b47SGuenter Roeck for (i = 0; i < mapind; i++)
32417d82b47SGuenter Roeck iio_device_put(chans[i].indio_dev);
32517d82b47SGuenter Roeck kfree(chans);
32617d82b47SGuenter Roeck return ERR_PTR(ret);
32717d82b47SGuenter Roeck }
32817d82b47SGuenter Roeck
iio_channel_get_sys(const char * name,const char * channel_name)3295aa57f0aSGuenter Roeck static struct iio_channel *iio_channel_get_sys(const char *name,
3305aa57f0aSGuenter Roeck const char *channel_name)
331a980e046SJonathan Cameron {
332a980e046SJonathan Cameron struct iio_map_internal *c_i = NULL, *c = NULL;
333a980e046SJonathan Cameron struct iio_channel *channel;
3343183bac1SKim, Milo int err;
335a980e046SJonathan Cameron
336110f1158SNuno Sá if (!(name || channel_name))
337a980e046SJonathan Cameron return ERR_PTR(-ENODEV);
338a980e046SJonathan Cameron
339a980e046SJonathan Cameron /* first find matching entry the channel map */
340a980e046SJonathan Cameron mutex_lock(&iio_map_list_lock);
341a980e046SJonathan Cameron list_for_each_entry(c_i, &iio_map_list, l) {
342a980e046SJonathan Cameron if ((name && strcmp(name, c_i->map->consumer_dev_name) != 0) ||
343a980e046SJonathan Cameron (channel_name &&
344a980e046SJonathan Cameron strcmp(channel_name, c_i->map->consumer_channel) != 0))
345a980e046SJonathan Cameron continue;
346a980e046SJonathan Cameron c = c_i;
3471875ffd2SLars-Peter Clausen iio_device_get(c->indio_dev);
348a980e046SJonathan Cameron break;
349a980e046SJonathan Cameron }
350a980e046SJonathan Cameron mutex_unlock(&iio_map_list_lock);
351110f1158SNuno Sá if (!c)
352a980e046SJonathan Cameron return ERR_PTR(-ENODEV);
353a980e046SJonathan Cameron
3542cc412b5SKim, Milo channel = kzalloc(sizeof(*channel), GFP_KERNEL);
355110f1158SNuno Sá if (!channel) {
3563183bac1SKim, Milo err = -ENOMEM;
357801c4b5cSKim, Milo goto error_no_mem;
3583183bac1SKim, Milo }
359a980e046SJonathan Cameron
360a980e046SJonathan Cameron channel->indio_dev = c->indio_dev;
361a980e046SJonathan Cameron
362b2b79ffaSKim, Milo if (c->map->adc_channel_label) {
363a980e046SJonathan Cameron channel->channel =
364a980e046SJonathan Cameron iio_chan_spec_from_name(channel->indio_dev,
365a980e046SJonathan Cameron c->map->adc_channel_label);
366a980e046SJonathan Cameron
367110f1158SNuno Sá if (!channel->channel) {
3683183bac1SKim, Milo err = -EINVAL;
369b2b79ffaSKim, Milo goto error_no_chan;
370b2b79ffaSKim, Milo }
3713183bac1SKim, Milo }
372b2b79ffaSKim, Milo
373a980e046SJonathan Cameron return channel;
374b2b79ffaSKim, Milo
375b2b79ffaSKim, Milo error_no_chan:
376b2b79ffaSKim, Milo kfree(channel);
377801c4b5cSKim, Milo error_no_mem:
378801c4b5cSKim, Milo iio_device_put(c->indio_dev);
3793183bac1SKim, Milo return ERR_PTR(err);
380a980e046SJonathan Cameron }
3815aa57f0aSGuenter Roeck
iio_channel_get(struct device * dev,const char * channel_name)3825aa57f0aSGuenter Roeck struct iio_channel *iio_channel_get(struct device *dev,
3835aa57f0aSGuenter Roeck const char *channel_name)
3845aa57f0aSGuenter Roeck {
3855aa57f0aSGuenter Roeck const char *name = dev ? dev_name(dev) : NULL;
38617d82b47SGuenter Roeck struct iio_channel *channel;
3875aa57f0aSGuenter Roeck
38817d82b47SGuenter Roeck if (dev) {
3891e64b9c5SNuno Sá channel = fwnode_iio_channel_get_by_name(dev_fwnode(dev),
39017d82b47SGuenter Roeck channel_name);
391ed5e5ed4SNuno Sá if (!IS_ERR(channel) || PTR_ERR(channel) != -ENODEV)
39217d82b47SGuenter Roeck return channel;
39317d82b47SGuenter Roeck }
394a2c12493SAdam Thomson
3955aa57f0aSGuenter Roeck return iio_channel_get_sys(name, channel_name);
3965aa57f0aSGuenter Roeck }
397314be14bSJonathan Cameron EXPORT_SYMBOL_GPL(iio_channel_get);
398a980e046SJonathan Cameron
iio_channel_release(struct iio_channel * channel)399314be14bSJonathan Cameron void iio_channel_release(struct iio_channel *channel)
400a980e046SJonathan Cameron {
401d81dac3cSDan Carpenter if (!channel)
402d81dac3cSDan Carpenter return;
4031875ffd2SLars-Peter Clausen iio_device_put(channel->indio_dev);
404a980e046SJonathan Cameron kfree(channel);
405a980e046SJonathan Cameron }
406314be14bSJonathan Cameron EXPORT_SYMBOL_GPL(iio_channel_release);
407a980e046SJonathan Cameron
devm_iio_channel_free(void * iio_channel)4087349e8a3SYicong Yang static void devm_iio_channel_free(void *iio_channel)
4098bf872d8SLaxman Dewangan {
4107349e8a3SYicong Yang iio_channel_release(iio_channel);
4118bf872d8SLaxman Dewangan }
4128bf872d8SLaxman Dewangan
devm_iio_channel_get(struct device * dev,const char * channel_name)4138bf872d8SLaxman Dewangan struct iio_channel *devm_iio_channel_get(struct device *dev,
4148bf872d8SLaxman Dewangan const char *channel_name)
4158bf872d8SLaxman Dewangan {
4167349e8a3SYicong Yang struct iio_channel *channel;
4177349e8a3SYicong Yang int ret;
4188bf872d8SLaxman Dewangan
4198bf872d8SLaxman Dewangan channel = iio_channel_get(dev, channel_name);
4207349e8a3SYicong Yang if (IS_ERR(channel))
4218bf872d8SLaxman Dewangan return channel;
4228bf872d8SLaxman Dewangan
4237349e8a3SYicong Yang ret = devm_add_action_or_reset(dev, devm_iio_channel_free, channel);
4247349e8a3SYicong Yang if (ret)
4257349e8a3SYicong Yang return ERR_PTR(ret);
4268bf872d8SLaxman Dewangan
4278bf872d8SLaxman Dewangan return channel;
4288bf872d8SLaxman Dewangan }
4298bf872d8SLaxman Dewangan EXPORT_SYMBOL_GPL(devm_iio_channel_get);
4308bf872d8SLaxman Dewangan
devm_fwnode_iio_channel_get_by_name(struct device * dev,struct fwnode_handle * fwnode,const char * channel_name)4311e64b9c5SNuno Sá struct iio_channel *devm_fwnode_iio_channel_get_by_name(struct device *dev,
4321e64b9c5SNuno Sá struct fwnode_handle *fwnode,
4336e39b145SDmitry Baryshkov const char *channel_name)
4346e39b145SDmitry Baryshkov {
4357349e8a3SYicong Yang struct iio_channel *channel;
4367349e8a3SYicong Yang int ret;
4376e39b145SDmitry Baryshkov
4381e64b9c5SNuno Sá channel = fwnode_iio_channel_get_by_name(fwnode, channel_name);
4397349e8a3SYicong Yang if (IS_ERR(channel))
4406e39b145SDmitry Baryshkov return channel;
4416e39b145SDmitry Baryshkov
4427349e8a3SYicong Yang ret = devm_add_action_or_reset(dev, devm_iio_channel_free, channel);
4437349e8a3SYicong Yang if (ret)
4447349e8a3SYicong Yang return ERR_PTR(ret);
4456e39b145SDmitry Baryshkov
4466e39b145SDmitry Baryshkov return channel;
4476e39b145SDmitry Baryshkov }
4481e64b9c5SNuno Sá EXPORT_SYMBOL_GPL(devm_fwnode_iio_channel_get_by_name);
4496e39b145SDmitry Baryshkov
iio_channel_get_all(struct device * dev)450ca7d98dbSGuenter Roeck struct iio_channel *iio_channel_get_all(struct device *dev)
451a980e046SJonathan Cameron {
452ca7d98dbSGuenter Roeck const char *name;
453a980e046SJonathan Cameron struct iio_channel *chans;
454a980e046SJonathan Cameron struct iio_map_internal *c = NULL;
455a980e046SJonathan Cameron int nummaps = 0;
456a980e046SJonathan Cameron int mapind = 0;
457a980e046SJonathan Cameron int i, ret;
458a980e046SJonathan Cameron
459110f1158SNuno Sá if (!dev)
460a980e046SJonathan Cameron return ERR_PTR(-EINVAL);
46117d82b47SGuenter Roeck
4621e64b9c5SNuno Sá chans = fwnode_iio_channel_get_all(dev);
463ed5e5ed4SNuno Sá /*
464ed5e5ed4SNuno Sá * We only want to carry on if the error is -ENODEV. Anything else
465ed5e5ed4SNuno Sá * should be reported up the stack.
466ed5e5ed4SNuno Sá */
467ed5e5ed4SNuno Sá if (!IS_ERR(chans) || PTR_ERR(chans) != -ENODEV)
46817d82b47SGuenter Roeck return chans;
46917d82b47SGuenter Roeck
470ca7d98dbSGuenter Roeck name = dev_name(dev);
471a980e046SJonathan Cameron
472a980e046SJonathan Cameron mutex_lock(&iio_map_list_lock);
473a980e046SJonathan Cameron /* first count the matching maps */
474a980e046SJonathan Cameron list_for_each_entry(c, &iio_map_list, l)
475a980e046SJonathan Cameron if (name && strcmp(name, c->map->consumer_dev_name) != 0)
476a980e046SJonathan Cameron continue;
477a980e046SJonathan Cameron else
478a980e046SJonathan Cameron nummaps++;
479a980e046SJonathan Cameron
480a980e046SJonathan Cameron if (nummaps == 0) {
481a980e046SJonathan Cameron ret = -ENODEV;
482a980e046SJonathan Cameron goto error_ret;
483a980e046SJonathan Cameron }
484a980e046SJonathan Cameron
485a980e046SJonathan Cameron /* NULL terminated array to save passing size */
4866396bb22SKees Cook chans = kcalloc(nummaps + 1, sizeof(*chans), GFP_KERNEL);
487110f1158SNuno Sá if (!chans) {
488a980e046SJonathan Cameron ret = -ENOMEM;
489a980e046SJonathan Cameron goto error_ret;
490a980e046SJonathan Cameron }
491a980e046SJonathan Cameron
492a980e046SJonathan Cameron /* for each map fill in the chans element */
493a980e046SJonathan Cameron list_for_each_entry(c, &iio_map_list, l) {
494a980e046SJonathan Cameron if (name && strcmp(name, c->map->consumer_dev_name) != 0)
495a980e046SJonathan Cameron continue;
496a980e046SJonathan Cameron chans[mapind].indio_dev = c->indio_dev;
4970464415dSJonathan Cameron chans[mapind].data = c->map->consumer_data;
498a980e046SJonathan Cameron chans[mapind].channel =
499a980e046SJonathan Cameron iio_chan_spec_from_name(chans[mapind].indio_dev,
500a980e046SJonathan Cameron c->map->adc_channel_label);
501110f1158SNuno Sá if (!chans[mapind].channel) {
502a980e046SJonathan Cameron ret = -EINVAL;
503a980e046SJonathan Cameron goto error_free_chans;
504a980e046SJonathan Cameron }
5051875ffd2SLars-Peter Clausen iio_device_get(chans[mapind].indio_dev);
506a980e046SJonathan Cameron mapind++;
507a980e046SJonathan Cameron }
508a980e046SJonathan Cameron if (mapind == 0) {
509a980e046SJonathan Cameron ret = -ENODEV;
510a980e046SJonathan Cameron goto error_free_chans;
511a980e046SJonathan Cameron }
512e59b9afeSDan Carpenter mutex_unlock(&iio_map_list_lock);
513e59b9afeSDan Carpenter
514a980e046SJonathan Cameron return chans;
515a980e046SJonathan Cameron
516a980e046SJonathan Cameron error_free_chans:
517a980e046SJonathan Cameron for (i = 0; i < nummaps; i++)
5181875ffd2SLars-Peter Clausen iio_device_put(chans[i].indio_dev);
519a980e046SJonathan Cameron kfree(chans);
520a980e046SJonathan Cameron error_ret:
521a980e046SJonathan Cameron mutex_unlock(&iio_map_list_lock);
522a980e046SJonathan Cameron
523a980e046SJonathan Cameron return ERR_PTR(ret);
524a980e046SJonathan Cameron }
525314be14bSJonathan Cameron EXPORT_SYMBOL_GPL(iio_channel_get_all);
526a980e046SJonathan Cameron
iio_channel_release_all(struct iio_channel * channels)527314be14bSJonathan Cameron void iio_channel_release_all(struct iio_channel *channels)
528a980e046SJonathan Cameron {
529a980e046SJonathan Cameron struct iio_channel *chan = &channels[0];
530a980e046SJonathan Cameron
531a980e046SJonathan Cameron while (chan->indio_dev) {
5321875ffd2SLars-Peter Clausen iio_device_put(chan->indio_dev);
533a980e046SJonathan Cameron chan++;
534a980e046SJonathan Cameron }
535a980e046SJonathan Cameron kfree(channels);
536a980e046SJonathan Cameron }
537314be14bSJonathan Cameron EXPORT_SYMBOL_GPL(iio_channel_release_all);
538a980e046SJonathan Cameron
devm_iio_channel_free_all(void * iio_channels)5397349e8a3SYicong Yang static void devm_iio_channel_free_all(void *iio_channels)
540efc2c013SLaxman Dewangan {
5417349e8a3SYicong Yang iio_channel_release_all(iio_channels);
542efc2c013SLaxman Dewangan }
543efc2c013SLaxman Dewangan
devm_iio_channel_get_all(struct device * dev)544efc2c013SLaxman Dewangan struct iio_channel *devm_iio_channel_get_all(struct device *dev)
545efc2c013SLaxman Dewangan {
5467349e8a3SYicong Yang struct iio_channel *channels;
5477349e8a3SYicong Yang int ret;
548efc2c013SLaxman Dewangan
549efc2c013SLaxman Dewangan channels = iio_channel_get_all(dev);
5507349e8a3SYicong Yang if (IS_ERR(channels))
551efc2c013SLaxman Dewangan return channels;
552efc2c013SLaxman Dewangan
5537349e8a3SYicong Yang ret = devm_add_action_or_reset(dev, devm_iio_channel_free_all,
5547349e8a3SYicong Yang channels);
5557349e8a3SYicong Yang if (ret)
5567349e8a3SYicong Yang return ERR_PTR(ret);
557efc2c013SLaxman Dewangan
558efc2c013SLaxman Dewangan return channels;
559efc2c013SLaxman Dewangan }
560efc2c013SLaxman Dewangan EXPORT_SYMBOL_GPL(devm_iio_channel_get_all);
561efc2c013SLaxman Dewangan
iio_channel_read(struct iio_channel * chan,int * val,int * val2,enum iio_chan_info_enum info)56248e44ce0SLars-Peter Clausen static int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
56348e44ce0SLars-Peter Clausen enum iio_chan_info_enum info)
56448e44ce0SLars-Peter Clausen {
56548e44ce0SLars-Peter Clausen int unused;
5669fbfb4b3SSrinivas Pandruvada int vals[INDIO_MAX_RAW_ELEMENTS];
5679fbfb4b3SSrinivas Pandruvada int ret;
5689fbfb4b3SSrinivas Pandruvada int val_len = 2;
56948e44ce0SLars-Peter Clausen
570110f1158SNuno Sá if (!val2)
57148e44ce0SLars-Peter Clausen val2 = &unused;
57248e44ce0SLars-Peter Clausen
57365de7654SFabien Proriol if (!iio_channel_has_info(chan->channel, info))
57465de7654SFabien Proriol return -EINVAL;
57565de7654SFabien Proriol
5769fbfb4b3SSrinivas Pandruvada if (chan->indio_dev->info->read_raw_multi) {
5779fbfb4b3SSrinivas Pandruvada ret = chan->indio_dev->info->read_raw_multi(chan->indio_dev,
5789fbfb4b3SSrinivas Pandruvada chan->channel, INDIO_MAX_RAW_ELEMENTS,
5799fbfb4b3SSrinivas Pandruvada vals, &val_len, info);
5809fbfb4b3SSrinivas Pandruvada *val = vals[0];
5819fbfb4b3SSrinivas Pandruvada *val2 = vals[1];
582110f1158SNuno Sá } else {
5839fbfb4b3SSrinivas Pandruvada ret = chan->indio_dev->info->read_raw(chan->indio_dev,
5849fbfb4b3SSrinivas Pandruvada chan->channel, val, val2, info);
585110f1158SNuno Sá }
5869fbfb4b3SSrinivas Pandruvada
5879fbfb4b3SSrinivas Pandruvada return ret;
58848e44ce0SLars-Peter Clausen }
58948e44ce0SLars-Peter Clausen
iio_read_channel_raw(struct iio_channel * chan,int * val)590314be14bSJonathan Cameron int iio_read_channel_raw(struct iio_channel *chan, int *val)
591a980e046SJonathan Cameron {
592b804e2b7SJonathan Cameron struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
59348e44ce0SLars-Peter Clausen int ret;
594a980e046SJonathan Cameron
595b804e2b7SJonathan Cameron mutex_lock(&iio_dev_opaque->info_exist_lock);
596110f1158SNuno Sá if (!chan->indio_dev->info) {
597a980e046SJonathan Cameron ret = -ENODEV;
598a980e046SJonathan Cameron goto err_unlock;
599a980e046SJonathan Cameron }
600a980e046SJonathan Cameron
60148e44ce0SLars-Peter Clausen ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
602a980e046SJonathan Cameron err_unlock:
603b804e2b7SJonathan Cameron mutex_unlock(&iio_dev_opaque->info_exist_lock);
604a980e046SJonathan Cameron
605a980e046SJonathan Cameron return ret;
606a980e046SJonathan Cameron }
607314be14bSJonathan Cameron EXPORT_SYMBOL_GPL(iio_read_channel_raw);
608a980e046SJonathan Cameron
iio_read_channel_average_raw(struct iio_channel * chan,int * val)609476d4af2SSebastian Reichel int iio_read_channel_average_raw(struct iio_channel *chan, int *val)
610476d4af2SSebastian Reichel {
611b804e2b7SJonathan Cameron struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
612476d4af2SSebastian Reichel int ret;
613476d4af2SSebastian Reichel
614b804e2b7SJonathan Cameron mutex_lock(&iio_dev_opaque->info_exist_lock);
615110f1158SNuno Sá if (!chan->indio_dev->info) {
616476d4af2SSebastian Reichel ret = -ENODEV;
617476d4af2SSebastian Reichel goto err_unlock;
618476d4af2SSebastian Reichel }
619476d4af2SSebastian Reichel
620476d4af2SSebastian Reichel ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_AVERAGE_RAW);
621476d4af2SSebastian Reichel err_unlock:
622b804e2b7SJonathan Cameron mutex_unlock(&iio_dev_opaque->info_exist_lock);
623476d4af2SSebastian Reichel
624476d4af2SSebastian Reichel return ret;
625476d4af2SSebastian Reichel }
626476d4af2SSebastian Reichel EXPORT_SYMBOL_GPL(iio_read_channel_average_raw);
627476d4af2SSebastian Reichel
iio_convert_raw_to_processed_unlocked(struct iio_channel * chan,int raw,int * processed,unsigned int scale)62848e44ce0SLars-Peter Clausen static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
629110f1158SNuno Sá int raw, int *processed,
630110f1158SNuno Sá unsigned int scale)
63148e44ce0SLars-Peter Clausen {
632ca851233SLiam Beguin int scale_type, scale_val, scale_val2;
633ca851233SLiam Beguin int offset_type, offset_val, offset_val2;
63448e44ce0SLars-Peter Clausen s64 raw64 = raw;
63548e44ce0SLars-Peter Clausen
636ca851233SLiam Beguin offset_type = iio_channel_read(chan, &offset_val, &offset_val2,
637ca851233SLiam Beguin IIO_CHAN_INFO_OFFSET);
638ca851233SLiam Beguin if (offset_type >= 0) {
639ca851233SLiam Beguin switch (offset_type) {
640ca851233SLiam Beguin case IIO_VAL_INT:
641ca851233SLiam Beguin break;
642ca851233SLiam Beguin case IIO_VAL_INT_PLUS_MICRO:
643ca851233SLiam Beguin case IIO_VAL_INT_PLUS_NANO:
644ca851233SLiam Beguin /*
645ca851233SLiam Beguin * Both IIO_VAL_INT_PLUS_MICRO and IIO_VAL_INT_PLUS_NANO
646ca851233SLiam Beguin * implicitely truncate the offset to it's integer form.
647ca851233SLiam Beguin */
648ca851233SLiam Beguin break;
649ca851233SLiam Beguin case IIO_VAL_FRACTIONAL:
650ca851233SLiam Beguin offset_val /= offset_val2;
651ca851233SLiam Beguin break;
652ca851233SLiam Beguin case IIO_VAL_FRACTIONAL_LOG2:
653ca851233SLiam Beguin offset_val >>= offset_val2;
654ca851233SLiam Beguin break;
655ca851233SLiam Beguin default:
656ca851233SLiam Beguin return -EINVAL;
657ca851233SLiam Beguin }
658ca851233SLiam Beguin
659ca851233SLiam Beguin raw64 += offset_val;
660ca851233SLiam Beguin }
66148e44ce0SLars-Peter Clausen
66248e44ce0SLars-Peter Clausen scale_type = iio_channel_read(chan, &scale_val, &scale_val2,
66348e44ce0SLars-Peter Clausen IIO_CHAN_INFO_SCALE);
664adc8ec5fSLinus Walleij if (scale_type < 0) {
665adc8ec5fSLinus Walleij /*
66614b457fdSLiam Beguin * If no channel scaling is available apply consumer scale to
66714b457fdSLiam Beguin * raw value and return.
668adc8ec5fSLinus Walleij */
66914b457fdSLiam Beguin *processed = raw * scale;
670adc8ec5fSLinus Walleij return 0;
671adc8ec5fSLinus Walleij }
67248e44ce0SLars-Peter Clausen
67348e44ce0SLars-Peter Clausen switch (scale_type) {
67448e44ce0SLars-Peter Clausen case IIO_VAL_INT:
6751bca97ffSLiam Beguin *processed = raw64 * scale_val * scale;
67648e44ce0SLars-Peter Clausen break;
67748e44ce0SLars-Peter Clausen case IIO_VAL_INT_PLUS_MICRO:
67848e44ce0SLars-Peter Clausen if (scale_val2 < 0)
67948e44ce0SLars-Peter Clausen *processed = -raw64 * scale_val;
68048e44ce0SLars-Peter Clausen else
68148e44ce0SLars-Peter Clausen *processed = raw64 * scale_val;
68248e44ce0SLars-Peter Clausen *processed += div_s64(raw64 * (s64)scale_val2 * scale,
68348e44ce0SLars-Peter Clausen 1000000LL);
68448e44ce0SLars-Peter Clausen break;
68548e44ce0SLars-Peter Clausen case IIO_VAL_INT_PLUS_NANO:
68648e44ce0SLars-Peter Clausen if (scale_val2 < 0)
68748e44ce0SLars-Peter Clausen *processed = -raw64 * scale_val;
68848e44ce0SLars-Peter Clausen else
68948e44ce0SLars-Peter Clausen *processed = raw64 * scale_val;
69048e44ce0SLars-Peter Clausen *processed += div_s64(raw64 * (s64)scale_val2 * scale,
69148e44ce0SLars-Peter Clausen 1000000000LL);
69248e44ce0SLars-Peter Clausen break;
69348e44ce0SLars-Peter Clausen case IIO_VAL_FRACTIONAL:
69448e44ce0SLars-Peter Clausen *processed = div_s64(raw64 * (s64)scale_val * scale,
69548e44ce0SLars-Peter Clausen scale_val2);
69648e44ce0SLars-Peter Clausen break;
697103d9fb9SLars-Peter Clausen case IIO_VAL_FRACTIONAL_LOG2:
698103d9fb9SLars-Peter Clausen *processed = (raw64 * (s64)scale_val * scale) >> scale_val2;
699103d9fb9SLars-Peter Clausen break;
70048e44ce0SLars-Peter Clausen default:
70148e44ce0SLars-Peter Clausen return -EINVAL;
70248e44ce0SLars-Peter Clausen }
70348e44ce0SLars-Peter Clausen
70448e44ce0SLars-Peter Clausen return 0;
70548e44ce0SLars-Peter Clausen }
70648e44ce0SLars-Peter Clausen
iio_convert_raw_to_processed(struct iio_channel * chan,int raw,int * processed,unsigned int scale)70748e44ce0SLars-Peter Clausen int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
70848e44ce0SLars-Peter Clausen int *processed, unsigned int scale)
70948e44ce0SLars-Peter Clausen {
710b804e2b7SJonathan Cameron struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
71148e44ce0SLars-Peter Clausen int ret;
71248e44ce0SLars-Peter Clausen
713b804e2b7SJonathan Cameron mutex_lock(&iio_dev_opaque->info_exist_lock);
714110f1158SNuno Sá if (!chan->indio_dev->info) {
71548e44ce0SLars-Peter Clausen ret = -ENODEV;
71648e44ce0SLars-Peter Clausen goto err_unlock;
71748e44ce0SLars-Peter Clausen }
71848e44ce0SLars-Peter Clausen
71948e44ce0SLars-Peter Clausen ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,
72048e44ce0SLars-Peter Clausen scale);
72148e44ce0SLars-Peter Clausen err_unlock:
722b804e2b7SJonathan Cameron mutex_unlock(&iio_dev_opaque->info_exist_lock);
72348e44ce0SLars-Peter Clausen
72448e44ce0SLars-Peter Clausen return ret;
72548e44ce0SLars-Peter Clausen }
72648e44ce0SLars-Peter Clausen EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
72748e44ce0SLars-Peter Clausen
iio_read_channel_attribute(struct iio_channel * chan,int * val,int * val2,enum iio_chan_info_enum attribute)72834739a21SArnaud Pouliquen int iio_read_channel_attribute(struct iio_channel *chan, int *val, int *val2,
7290023e67dSMatt Ranostay enum iio_chan_info_enum attribute)
7300023e67dSMatt Ranostay {
731b804e2b7SJonathan Cameron struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
7320023e67dSMatt Ranostay int ret;
7330023e67dSMatt Ranostay
734b804e2b7SJonathan Cameron mutex_lock(&iio_dev_opaque->info_exist_lock);
735110f1158SNuno Sá if (!chan->indio_dev->info) {
7360023e67dSMatt Ranostay ret = -ENODEV;
7370023e67dSMatt Ranostay goto err_unlock;
7380023e67dSMatt Ranostay }
7390023e67dSMatt Ranostay
7400023e67dSMatt Ranostay ret = iio_channel_read(chan, val, val2, attribute);
7410023e67dSMatt Ranostay err_unlock:
742b804e2b7SJonathan Cameron mutex_unlock(&iio_dev_opaque->info_exist_lock);
7430023e67dSMatt Ranostay
7440023e67dSMatt Ranostay return ret;
7450023e67dSMatt Ranostay }
74634739a21SArnaud Pouliquen EXPORT_SYMBOL_GPL(iio_read_channel_attribute);
7470023e67dSMatt Ranostay
iio_read_channel_offset(struct iio_channel * chan,int * val,int * val2)7480023e67dSMatt Ranostay int iio_read_channel_offset(struct iio_channel *chan, int *val, int *val2)
7490023e67dSMatt Ranostay {
7500023e67dSMatt Ranostay return iio_read_channel_attribute(chan, val, val2, IIO_CHAN_INFO_OFFSET);
7510023e67dSMatt Ranostay }
7520023e67dSMatt Ranostay EXPORT_SYMBOL_GPL(iio_read_channel_offset);
7530023e67dSMatt Ranostay
iio_read_channel_processed_scale(struct iio_channel * chan,int * val,unsigned int scale)754635ef601SLinus Walleij int iio_read_channel_processed_scale(struct iio_channel *chan, int *val,
755635ef601SLinus Walleij unsigned int scale)
75648e44ce0SLars-Peter Clausen {
757b804e2b7SJonathan Cameron struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
75848e44ce0SLars-Peter Clausen int ret;
75948e44ce0SLars-Peter Clausen
760b804e2b7SJonathan Cameron mutex_lock(&iio_dev_opaque->info_exist_lock);
761110f1158SNuno Sá if (!chan->indio_dev->info) {
76248e44ce0SLars-Peter Clausen ret = -ENODEV;
76348e44ce0SLars-Peter Clausen goto err_unlock;
76448e44ce0SLars-Peter Clausen }
76548e44ce0SLars-Peter Clausen
76648e44ce0SLars-Peter Clausen if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) {
76748e44ce0SLars-Peter Clausen ret = iio_channel_read(chan, val, NULL,
76848e44ce0SLars-Peter Clausen IIO_CHAN_INFO_PROCESSED);
769b3b64e2cSLinus Walleij if (ret < 0)
770635ef601SLinus Walleij goto err_unlock;
771635ef601SLinus Walleij *val *= scale;
77248e44ce0SLars-Peter Clausen } else {
77348e44ce0SLars-Peter Clausen ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
77448e44ce0SLars-Peter Clausen if (ret < 0)
77548e44ce0SLars-Peter Clausen goto err_unlock;
776635ef601SLinus Walleij ret = iio_convert_raw_to_processed_unlocked(chan, *val, val,
777635ef601SLinus Walleij scale);
77848e44ce0SLars-Peter Clausen }
77948e44ce0SLars-Peter Clausen
78048e44ce0SLars-Peter Clausen err_unlock:
781b804e2b7SJonathan Cameron mutex_unlock(&iio_dev_opaque->info_exist_lock);
78248e44ce0SLars-Peter Clausen
78348e44ce0SLars-Peter Clausen return ret;
78448e44ce0SLars-Peter Clausen }
785635ef601SLinus Walleij EXPORT_SYMBOL_GPL(iio_read_channel_processed_scale);
786635ef601SLinus Walleij
iio_read_channel_processed(struct iio_channel * chan,int * val)787635ef601SLinus Walleij int iio_read_channel_processed(struct iio_channel *chan, int *val)
788635ef601SLinus Walleij {
789635ef601SLinus Walleij /* This is just a special case with scale factor 1 */
790635ef601SLinus Walleij return iio_read_channel_processed_scale(chan, val, 1);
791635ef601SLinus Walleij }
79248e44ce0SLars-Peter Clausen EXPORT_SYMBOL_GPL(iio_read_channel_processed);
79348e44ce0SLars-Peter Clausen
iio_read_channel_scale(struct iio_channel * chan,int * val,int * val2)794314be14bSJonathan Cameron int iio_read_channel_scale(struct iio_channel *chan, int *val, int *val2)
795a980e046SJonathan Cameron {
7960023e67dSMatt Ranostay return iio_read_channel_attribute(chan, val, val2, IIO_CHAN_INFO_SCALE);
797a980e046SJonathan Cameron }
798314be14bSJonathan Cameron EXPORT_SYMBOL_GPL(iio_read_channel_scale);
799a980e046SJonathan Cameron
iio_channel_read_avail(struct iio_channel * chan,const int ** vals,int * type,int * length,enum iio_chan_info_enum info)80000c5f80cSPeter Rosin static int iio_channel_read_avail(struct iio_channel *chan,
80100c5f80cSPeter Rosin const int **vals, int *type, int *length,
80200c5f80cSPeter Rosin enum iio_chan_info_enum info)
80300c5f80cSPeter Rosin {
80400c5f80cSPeter Rosin if (!iio_channel_has_available(chan->channel, info))
80500c5f80cSPeter Rosin return -EINVAL;
80600c5f80cSPeter Rosin
80700c5f80cSPeter Rosin return chan->indio_dev->info->read_avail(chan->indio_dev, chan->channel,
80800c5f80cSPeter Rosin vals, type, length, info);
80900c5f80cSPeter Rosin }
81000c5f80cSPeter Rosin
iio_read_avail_channel_attribute(struct iio_channel * chan,const int ** vals,int * type,int * length,enum iio_chan_info_enum attribute)8119f421096SArtur Rojek int iio_read_avail_channel_attribute(struct iio_channel *chan,
8129f421096SArtur Rojek const int **vals, int *type, int *length,
8139f421096SArtur Rojek enum iio_chan_info_enum attribute)
8149f421096SArtur Rojek {
815b804e2b7SJonathan Cameron struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
8169f421096SArtur Rojek int ret;
8179f421096SArtur Rojek
818b804e2b7SJonathan Cameron mutex_lock(&iio_dev_opaque->info_exist_lock);
8199f421096SArtur Rojek if (!chan->indio_dev->info) {
8209f421096SArtur Rojek ret = -ENODEV;
8219f421096SArtur Rojek goto err_unlock;
8229f421096SArtur Rojek }
8239f421096SArtur Rojek
8249f421096SArtur Rojek ret = iio_channel_read_avail(chan, vals, type, length, attribute);
8259f421096SArtur Rojek err_unlock:
826b804e2b7SJonathan Cameron mutex_unlock(&iio_dev_opaque->info_exist_lock);
8279f421096SArtur Rojek
8289f421096SArtur Rojek return ret;
8299f421096SArtur Rojek }
8309f421096SArtur Rojek EXPORT_SYMBOL_GPL(iio_read_avail_channel_attribute);
8319f421096SArtur Rojek
iio_read_avail_channel_raw(struct iio_channel * chan,const int ** vals,int * length)83200c5f80cSPeter Rosin int iio_read_avail_channel_raw(struct iio_channel *chan,
83300c5f80cSPeter Rosin const int **vals, int *length)
83400c5f80cSPeter Rosin {
83500c5f80cSPeter Rosin int ret;
83600c5f80cSPeter Rosin int type;
83700c5f80cSPeter Rosin
83889388ca4SArtur Rojek ret = iio_read_avail_channel_attribute(chan, vals, &type, length,
83989388ca4SArtur Rojek IIO_CHAN_INFO_RAW);
84000c5f80cSPeter Rosin
841c773f700SPeter Rosin if (ret >= 0 && type != IIO_VAL_INT)
84200c5f80cSPeter Rosin /* raw values are assumed to be IIO_VAL_INT */
84300c5f80cSPeter Rosin ret = -EINVAL;
84400c5f80cSPeter Rosin
84500c5f80cSPeter Rosin return ret;
84600c5f80cSPeter Rosin }
84700c5f80cSPeter Rosin EXPORT_SYMBOL_GPL(iio_read_avail_channel_raw);
84800c5f80cSPeter Rosin
iio_channel_read_max(struct iio_channel * chan,int * val,int * val2,int * type,enum iio_chan_info_enum info)84900c5f80cSPeter Rosin static int iio_channel_read_max(struct iio_channel *chan,
85000c5f80cSPeter Rosin int *val, int *val2, int *type,
85100c5f80cSPeter Rosin enum iio_chan_info_enum info)
85200c5f80cSPeter Rosin {
85300c5f80cSPeter Rosin const int *vals;
85400c5f80cSPeter Rosin int length;
85500c5f80cSPeter Rosin int ret;
85600c5f80cSPeter Rosin
85700c5f80cSPeter Rosin ret = iio_channel_read_avail(chan, &vals, type, &length, info);
858f75c544dSHerve Codina if (ret < 0)
859f75c544dSHerve Codina return ret;
860f75c544dSHerve Codina
86100c5f80cSPeter Rosin switch (ret) {
86200c5f80cSPeter Rosin case IIO_AVAIL_RANGE:
86300c5f80cSPeter Rosin switch (*type) {
86400c5f80cSPeter Rosin case IIO_VAL_INT:
86500c5f80cSPeter Rosin *val = vals[2];
86600c5f80cSPeter Rosin break;
86700c5f80cSPeter Rosin default:
86800c5f80cSPeter Rosin *val = vals[4];
869ad4e8480SHerve Codina if (val2)
87000c5f80cSPeter Rosin *val2 = vals[5];
87100c5f80cSPeter Rosin }
87200c5f80cSPeter Rosin return 0;
87300c5f80cSPeter Rosin
87400c5f80cSPeter Rosin case IIO_AVAIL_LIST:
87500c5f80cSPeter Rosin if (length <= 0)
87600c5f80cSPeter Rosin return -EINVAL;
87700c5f80cSPeter Rosin switch (*type) {
87800c5f80cSPeter Rosin case IIO_VAL_INT:
87997aee715SHerve Codina *val = max_array(vals, length);
88000c5f80cSPeter Rosin break;
88100c5f80cSPeter Rosin default:
8824dc60373SHerve Codina /* TODO: learn about max for other iio values */
88300c5f80cSPeter Rosin return -EINVAL;
88400c5f80cSPeter Rosin }
88500c5f80cSPeter Rosin return 0;
88600c5f80cSPeter Rosin
88700c5f80cSPeter Rosin default:
888f75c544dSHerve Codina return -EINVAL;
88900c5f80cSPeter Rosin }
89000c5f80cSPeter Rosin }
89100c5f80cSPeter Rosin
iio_read_max_channel_raw(struct iio_channel * chan,int * val)89200c5f80cSPeter Rosin int iio_read_max_channel_raw(struct iio_channel *chan, int *val)
89300c5f80cSPeter Rosin {
894b804e2b7SJonathan Cameron struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
89500c5f80cSPeter Rosin int ret;
89600c5f80cSPeter Rosin int type;
89700c5f80cSPeter Rosin
898b804e2b7SJonathan Cameron mutex_lock(&iio_dev_opaque->info_exist_lock);
89900c5f80cSPeter Rosin if (!chan->indio_dev->info) {
90000c5f80cSPeter Rosin ret = -ENODEV;
90100c5f80cSPeter Rosin goto err_unlock;
90200c5f80cSPeter Rosin }
90300c5f80cSPeter Rosin
90400c5f80cSPeter Rosin ret = iio_channel_read_max(chan, val, NULL, &type, IIO_CHAN_INFO_RAW);
90500c5f80cSPeter Rosin err_unlock:
906b804e2b7SJonathan Cameron mutex_unlock(&iio_dev_opaque->info_exist_lock);
90700c5f80cSPeter Rosin
90800c5f80cSPeter Rosin return ret;
90900c5f80cSPeter Rosin }
91000c5f80cSPeter Rosin EXPORT_SYMBOL_GPL(iio_read_max_channel_raw);
91100c5f80cSPeter Rosin
iio_channel_read_min(struct iio_channel * chan,int * val,int * val2,int * type,enum iio_chan_info_enum info)912*75604180SHerve Codina static int iio_channel_read_min(struct iio_channel *chan,
913*75604180SHerve Codina int *val, int *val2, int *type,
914*75604180SHerve Codina enum iio_chan_info_enum info)
915*75604180SHerve Codina {
916*75604180SHerve Codina const int *vals;
917*75604180SHerve Codina int length;
918*75604180SHerve Codina int ret;
919*75604180SHerve Codina
920*75604180SHerve Codina ret = iio_channel_read_avail(chan, &vals, type, &length, info);
921*75604180SHerve Codina if (ret < 0)
922*75604180SHerve Codina return ret;
923*75604180SHerve Codina
924*75604180SHerve Codina switch (ret) {
925*75604180SHerve Codina case IIO_AVAIL_RANGE:
926*75604180SHerve Codina switch (*type) {
927*75604180SHerve Codina case IIO_VAL_INT:
928*75604180SHerve Codina *val = vals[0];
929*75604180SHerve Codina break;
930*75604180SHerve Codina default:
931*75604180SHerve Codina *val = vals[0];
932*75604180SHerve Codina if (val2)
933*75604180SHerve Codina *val2 = vals[1];
934*75604180SHerve Codina }
935*75604180SHerve Codina return 0;
936*75604180SHerve Codina
937*75604180SHerve Codina case IIO_AVAIL_LIST:
938*75604180SHerve Codina if (length <= 0)
939*75604180SHerve Codina return -EINVAL;
940*75604180SHerve Codina switch (*type) {
941*75604180SHerve Codina case IIO_VAL_INT:
942*75604180SHerve Codina *val = min_array(vals, length);
943*75604180SHerve Codina break;
944*75604180SHerve Codina default:
945*75604180SHerve Codina /* TODO: learn about min for other iio values */
946*75604180SHerve Codina return -EINVAL;
947*75604180SHerve Codina }
948*75604180SHerve Codina return 0;
949*75604180SHerve Codina
950*75604180SHerve Codina default:
951*75604180SHerve Codina return -EINVAL;
952*75604180SHerve Codina }
953*75604180SHerve Codina }
954*75604180SHerve Codina
iio_read_min_channel_raw(struct iio_channel * chan,int * val)955*75604180SHerve Codina int iio_read_min_channel_raw(struct iio_channel *chan, int *val)
956*75604180SHerve Codina {
957*75604180SHerve Codina struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
958*75604180SHerve Codina int ret;
959*75604180SHerve Codina int type;
960*75604180SHerve Codina
961*75604180SHerve Codina mutex_lock(&iio_dev_opaque->info_exist_lock);
962*75604180SHerve Codina if (!chan->indio_dev->info) {
963*75604180SHerve Codina ret = -ENODEV;
964*75604180SHerve Codina goto err_unlock;
965*75604180SHerve Codina }
966*75604180SHerve Codina
967*75604180SHerve Codina ret = iio_channel_read_min(chan, val, NULL, &type, IIO_CHAN_INFO_RAW);
968*75604180SHerve Codina err_unlock:
969*75604180SHerve Codina mutex_unlock(&iio_dev_opaque->info_exist_lock);
970*75604180SHerve Codina
971*75604180SHerve Codina return ret;
972*75604180SHerve Codina }
973*75604180SHerve Codina EXPORT_SYMBOL_GPL(iio_read_min_channel_raw);
974*75604180SHerve Codina
iio_get_channel_type(struct iio_channel * chan,enum iio_chan_type * type)975314be14bSJonathan Cameron int iio_get_channel_type(struct iio_channel *chan, enum iio_chan_type *type)
976a980e046SJonathan Cameron {
977b804e2b7SJonathan Cameron struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
978a980e046SJonathan Cameron int ret = 0;
979a980e046SJonathan Cameron /* Need to verify underlying driver has not gone away */
980a980e046SJonathan Cameron
981b804e2b7SJonathan Cameron mutex_lock(&iio_dev_opaque->info_exist_lock);
982110f1158SNuno Sá if (!chan->indio_dev->info) {
983a980e046SJonathan Cameron ret = -ENODEV;
984a980e046SJonathan Cameron goto err_unlock;
985a980e046SJonathan Cameron }
986a980e046SJonathan Cameron
987a980e046SJonathan Cameron *type = chan->channel->type;
988a980e046SJonathan Cameron err_unlock:
989b804e2b7SJonathan Cameron mutex_unlock(&iio_dev_opaque->info_exist_lock);
990a980e046SJonathan Cameron
991a980e046SJonathan Cameron return ret;
992a980e046SJonathan Cameron }
993314be14bSJonathan Cameron EXPORT_SYMBOL_GPL(iio_get_channel_type);
994f9380e71SDmitry Eremin-Solenikov
iio_channel_write(struct iio_channel * chan,int val,int val2,enum iio_chan_info_enum info)995f9380e71SDmitry Eremin-Solenikov static int iio_channel_write(struct iio_channel *chan, int val, int val2,
996f9380e71SDmitry Eremin-Solenikov enum iio_chan_info_enum info)
997f9380e71SDmitry Eremin-Solenikov {
998f9380e71SDmitry Eremin-Solenikov return chan->indio_dev->info->write_raw(chan->indio_dev,
999f9380e71SDmitry Eremin-Solenikov chan->channel, val, val2, info);
1000f9380e71SDmitry Eremin-Solenikov }
1001f9380e71SDmitry Eremin-Solenikov
iio_write_channel_attribute(struct iio_channel * chan,int val,int val2,enum iio_chan_info_enum attribute)100234739a21SArnaud Pouliquen int iio_write_channel_attribute(struct iio_channel *chan, int val, int val2,
100334739a21SArnaud Pouliquen enum iio_chan_info_enum attribute)
1004f9380e71SDmitry Eremin-Solenikov {
1005b804e2b7SJonathan Cameron struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
1006f9380e71SDmitry Eremin-Solenikov int ret;
1007f9380e71SDmitry Eremin-Solenikov
1008b804e2b7SJonathan Cameron mutex_lock(&iio_dev_opaque->info_exist_lock);
1009110f1158SNuno Sá if (!chan->indio_dev->info) {
1010f9380e71SDmitry Eremin-Solenikov ret = -ENODEV;
1011f9380e71SDmitry Eremin-Solenikov goto err_unlock;
1012f9380e71SDmitry Eremin-Solenikov }
1013f9380e71SDmitry Eremin-Solenikov
101434739a21SArnaud Pouliquen ret = iio_channel_write(chan, val, val2, attribute);
1015f9380e71SDmitry Eremin-Solenikov err_unlock:
1016b804e2b7SJonathan Cameron mutex_unlock(&iio_dev_opaque->info_exist_lock);
1017f9380e71SDmitry Eremin-Solenikov
1018f9380e71SDmitry Eremin-Solenikov return ret;
1019f9380e71SDmitry Eremin-Solenikov }
102034739a21SArnaud Pouliquen EXPORT_SYMBOL_GPL(iio_write_channel_attribute);
102134739a21SArnaud Pouliquen
iio_write_channel_raw(struct iio_channel * chan,int val)102234739a21SArnaud Pouliquen int iio_write_channel_raw(struct iio_channel *chan, int val)
102334739a21SArnaud Pouliquen {
102434739a21SArnaud Pouliquen return iio_write_channel_attribute(chan, val, 0, IIO_CHAN_INFO_RAW);
102534739a21SArnaud Pouliquen }
1026f9380e71SDmitry Eremin-Solenikov EXPORT_SYMBOL_GPL(iio_write_channel_raw);
10278a848e75SPeter Rosin
iio_get_channel_ext_info_count(struct iio_channel * chan)10288a848e75SPeter Rosin unsigned int iio_get_channel_ext_info_count(struct iio_channel *chan)
10298a848e75SPeter Rosin {
10308a848e75SPeter Rosin const struct iio_chan_spec_ext_info *ext_info;
10318a848e75SPeter Rosin unsigned int i = 0;
10328a848e75SPeter Rosin
10338a848e75SPeter Rosin if (!chan->channel->ext_info)
10348a848e75SPeter Rosin return i;
10358a848e75SPeter Rosin
10368a848e75SPeter Rosin for (ext_info = chan->channel->ext_info; ext_info->name; ext_info++)
10378a848e75SPeter Rosin ++i;
10388a848e75SPeter Rosin
10398a848e75SPeter Rosin return i;
10408a848e75SPeter Rosin }
10418a848e75SPeter Rosin EXPORT_SYMBOL_GPL(iio_get_channel_ext_info_count);
10428a848e75SPeter Rosin
1043110f1158SNuno Sá static const struct iio_chan_spec_ext_info *
iio_lookup_ext_info(const struct iio_channel * chan,const char * attr)1044110f1158SNuno Sá iio_lookup_ext_info(const struct iio_channel *chan, const char *attr)
10458a848e75SPeter Rosin {
10468a848e75SPeter Rosin const struct iio_chan_spec_ext_info *ext_info;
10478a848e75SPeter Rosin
10488a848e75SPeter Rosin if (!chan->channel->ext_info)
10498a848e75SPeter Rosin return NULL;
10508a848e75SPeter Rosin
10518a848e75SPeter Rosin for (ext_info = chan->channel->ext_info; ext_info->name; ++ext_info) {
10528a848e75SPeter Rosin if (!strcmp(attr, ext_info->name))
10538a848e75SPeter Rosin return ext_info;
10548a848e75SPeter Rosin }
10558a848e75SPeter Rosin
10568a848e75SPeter Rosin return NULL;
10578a848e75SPeter Rosin }
10588a848e75SPeter Rosin
iio_read_channel_ext_info(struct iio_channel * chan,const char * attr,char * buf)10598a848e75SPeter Rosin ssize_t iio_read_channel_ext_info(struct iio_channel *chan,
10608a848e75SPeter Rosin const char *attr, char *buf)
10618a848e75SPeter Rosin {
10628a848e75SPeter Rosin const struct iio_chan_spec_ext_info *ext_info;
10638a848e75SPeter Rosin
10648a848e75SPeter Rosin ext_info = iio_lookup_ext_info(chan, attr);
10658a848e75SPeter Rosin if (!ext_info)
10668a848e75SPeter Rosin return -EINVAL;
10678a848e75SPeter Rosin
10688a848e75SPeter Rosin return ext_info->read(chan->indio_dev, ext_info->private,
10698a848e75SPeter Rosin chan->channel, buf);
10708a848e75SPeter Rosin }
10718a848e75SPeter Rosin EXPORT_SYMBOL_GPL(iio_read_channel_ext_info);
10728a848e75SPeter Rosin
iio_write_channel_ext_info(struct iio_channel * chan,const char * attr,const char * buf,size_t len)10738a848e75SPeter Rosin ssize_t iio_write_channel_ext_info(struct iio_channel *chan, const char *attr,
10748a848e75SPeter Rosin const char *buf, size_t len)
10758a848e75SPeter Rosin {
10768a848e75SPeter Rosin const struct iio_chan_spec_ext_info *ext_info;
10778a848e75SPeter Rosin
10788a848e75SPeter Rosin ext_info = iio_lookup_ext_info(chan, attr);
10798a848e75SPeter Rosin if (!ext_info)
10808a848e75SPeter Rosin return -EINVAL;
10818a848e75SPeter Rosin
10828a848e75SPeter Rosin return ext_info->write(chan->indio_dev, ext_info->private,
10838a848e75SPeter Rosin chan->channel, buf, len);
10848a848e75SPeter Rosin }
10858a848e75SPeter Rosin EXPORT_SYMBOL_GPL(iio_write_channel_ext_info);
1086