mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 19:00:25 +00:00
![Dmitry Baryshkov](/assets/img/avatar_default.png)
There might be cases when the IIO channel is attached to the device subnode instead of being attached to the main device node. Allow drivers to query IIO channels by using device tree nodes. Signed-off-by: Dmitry Baryshkov <dmitry.baryshkov@linaro.org> Link: https://lore.kernel.org/r/20201204025509.1075506-8-dmitry.baryshkov@linaro.org Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
947 lines
21 KiB
C
947 lines
21 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/* The industrial I/O core in kernel channel mapping
|
|
*
|
|
* Copyright (c) 2011 Jonathan Cameron
|
|
*/
|
|
#include <linux/err.h>
|
|
#include <linux/export.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/iio/iio.h>
|
|
#include "iio_core.h"
|
|
#include <linux/iio/machine.h>
|
|
#include <linux/iio/driver.h>
|
|
#include <linux/iio/consumer.h>
|
|
|
|
struct iio_map_internal {
|
|
struct iio_dev *indio_dev;
|
|
struct iio_map *map;
|
|
struct list_head l;
|
|
};
|
|
|
|
static LIST_HEAD(iio_map_list);
|
|
static DEFINE_MUTEX(iio_map_list_lock);
|
|
|
|
static int iio_map_array_unregister_locked(struct iio_dev *indio_dev)
|
|
{
|
|
int ret = -ENODEV;
|
|
struct iio_map_internal *mapi, *next;
|
|
|
|
list_for_each_entry_safe(mapi, next, &iio_map_list, l) {
|
|
if (indio_dev == mapi->indio_dev) {
|
|
list_del(&mapi->l);
|
|
kfree(mapi);
|
|
ret = 0;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int iio_map_array_register(struct iio_dev *indio_dev, struct iio_map *maps)
|
|
{
|
|
int i = 0, ret = 0;
|
|
struct iio_map_internal *mapi;
|
|
|
|
if (maps == NULL)
|
|
return 0;
|
|
|
|
mutex_lock(&iio_map_list_lock);
|
|
while (maps[i].consumer_dev_name != NULL) {
|
|
mapi = kzalloc(sizeof(*mapi), GFP_KERNEL);
|
|
if (mapi == NULL) {
|
|
ret = -ENOMEM;
|
|
goto error_ret;
|
|
}
|
|
mapi->map = &maps[i];
|
|
mapi->indio_dev = indio_dev;
|
|
list_add_tail(&mapi->l, &iio_map_list);
|
|
i++;
|
|
}
|
|
error_ret:
|
|
if (ret)
|
|
iio_map_array_unregister_locked(indio_dev);
|
|
mutex_unlock(&iio_map_list_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_map_array_register);
|
|
|
|
|
|
/*
|
|
* Remove all map entries associated with the given iio device
|
|
*/
|
|
int iio_map_array_unregister(struct iio_dev *indio_dev)
|
|
{
|
|
int ret;
|
|
|
|
mutex_lock(&iio_map_list_lock);
|
|
ret = iio_map_array_unregister_locked(indio_dev);
|
|
mutex_unlock(&iio_map_list_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_map_array_unregister);
|
|
|
|
static const struct iio_chan_spec
|
|
*iio_chan_spec_from_name(const struct iio_dev *indio_dev, const char *name)
|
|
{
|
|
int i;
|
|
const struct iio_chan_spec *chan = NULL;
|
|
|
|
for (i = 0; i < indio_dev->num_channels; i++)
|
|
if (indio_dev->channels[i].datasheet_name &&
|
|
strcmp(name, indio_dev->channels[i].datasheet_name) == 0) {
|
|
chan = &indio_dev->channels[i];
|
|
break;
|
|
}
|
|
return chan;
|
|
}
|
|
|
|
#ifdef CONFIG_OF
|
|
|
|
static int iio_dev_node_match(struct device *dev, const void *data)
|
|
{
|
|
return dev->of_node == data && dev->type == &iio_device_type;
|
|
}
|
|
|
|
/**
|
|
* __of_iio_simple_xlate - translate iiospec to the IIO channel index
|
|
* @indio_dev: pointer to the iio_dev structure
|
|
* @iiospec: IIO specifier as found in the device tree
|
|
*
|
|
* This is simple translation function, suitable for the most 1:1 mapped
|
|
* channels in IIO chips. This function performs only one sanity check:
|
|
* whether IIO index is less than num_channels (that is specified in the
|
|
* iio_dev).
|
|
*/
|
|
static int __of_iio_simple_xlate(struct iio_dev *indio_dev,
|
|
const struct of_phandle_args *iiospec)
|
|
{
|
|
if (!iiospec->args_count)
|
|
return 0;
|
|
|
|
if (iiospec->args[0] >= indio_dev->num_channels) {
|
|
dev_err(&indio_dev->dev, "invalid channel index %u\n",
|
|
iiospec->args[0]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return iiospec->args[0];
|
|
}
|
|
|
|
static int __of_iio_channel_get(struct iio_channel *channel,
|
|
struct device_node *np, int index)
|
|
{
|
|
struct device *idev;
|
|
struct iio_dev *indio_dev;
|
|
int err;
|
|
struct of_phandle_args iiospec;
|
|
|
|
err = of_parse_phandle_with_args(np, "io-channels",
|
|
"#io-channel-cells",
|
|
index, &iiospec);
|
|
if (err)
|
|
return err;
|
|
|
|
idev = bus_find_device(&iio_bus_type, NULL, iiospec.np,
|
|
iio_dev_node_match);
|
|
of_node_put(iiospec.np);
|
|
if (idev == NULL)
|
|
return -EPROBE_DEFER;
|
|
|
|
indio_dev = dev_to_iio_dev(idev);
|
|
channel->indio_dev = indio_dev;
|
|
if (indio_dev->info->of_xlate)
|
|
index = indio_dev->info->of_xlate(indio_dev, &iiospec);
|
|
else
|
|
index = __of_iio_simple_xlate(indio_dev, &iiospec);
|
|
if (index < 0)
|
|
goto err_put;
|
|
channel->channel = &indio_dev->channels[index];
|
|
|
|
return 0;
|
|
|
|
err_put:
|
|
iio_device_put(indio_dev);
|
|
return index;
|
|
}
|
|
|
|
static struct iio_channel *of_iio_channel_get(struct device_node *np, int index)
|
|
{
|
|
struct iio_channel *channel;
|
|
int err;
|
|
|
|
if (index < 0)
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
channel = kzalloc(sizeof(*channel), GFP_KERNEL);
|
|
if (channel == NULL)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
err = __of_iio_channel_get(channel, np, index);
|
|
if (err)
|
|
goto err_free_channel;
|
|
|
|
return channel;
|
|
|
|
err_free_channel:
|
|
kfree(channel);
|
|
return ERR_PTR(err);
|
|
}
|
|
|
|
struct iio_channel *of_iio_channel_get_by_name(struct device_node *np,
|
|
const char *name)
|
|
{
|
|
struct iio_channel *chan = NULL;
|
|
|
|
/* Walk up the tree of devices looking for a matching iio channel */
|
|
while (np) {
|
|
int index = 0;
|
|
|
|
/*
|
|
* For named iio channels, first look up the name in the
|
|
* "io-channel-names" property. If it cannot be found, the
|
|
* index will be an error code, and of_iio_channel_get()
|
|
* will fail.
|
|
*/
|
|
if (name)
|
|
index = of_property_match_string(np, "io-channel-names",
|
|
name);
|
|
chan = of_iio_channel_get(np, index);
|
|
if (!IS_ERR(chan) || PTR_ERR(chan) == -EPROBE_DEFER)
|
|
break;
|
|
else if (name && index >= 0) {
|
|
pr_err("ERROR: could not get IIO channel %pOF:%s(%i)\n",
|
|
np, name ? name : "", index);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* No matching IIO channel found on this node.
|
|
* If the parent node has a "io-channel-ranges" property,
|
|
* then we can try one of its channels.
|
|
*/
|
|
np = np->parent;
|
|
if (np && !of_get_property(np, "io-channel-ranges", NULL))
|
|
return NULL;
|
|
}
|
|
|
|
return chan;
|
|
}
|
|
EXPORT_SYMBOL_GPL(of_iio_channel_get_by_name);
|
|
|
|
static struct iio_channel *of_iio_channel_get_all(struct device *dev)
|
|
{
|
|
struct iio_channel *chans;
|
|
int i, mapind, nummaps = 0;
|
|
int ret;
|
|
|
|
do {
|
|
ret = of_parse_phandle_with_args(dev->of_node,
|
|
"io-channels",
|
|
"#io-channel-cells",
|
|
nummaps, NULL);
|
|
if (ret < 0)
|
|
break;
|
|
} while (++nummaps);
|
|
|
|
if (nummaps == 0) /* no error, return NULL to search map table */
|
|
return NULL;
|
|
|
|
/* NULL terminated array to save passing size */
|
|
chans = kcalloc(nummaps + 1, sizeof(*chans), GFP_KERNEL);
|
|
if (chans == NULL)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
/* Search for OF matches */
|
|
for (mapind = 0; mapind < nummaps; mapind++) {
|
|
ret = __of_iio_channel_get(&chans[mapind], dev->of_node,
|
|
mapind);
|
|
if (ret)
|
|
goto error_free_chans;
|
|
}
|
|
return chans;
|
|
|
|
error_free_chans:
|
|
for (i = 0; i < mapind; i++)
|
|
iio_device_put(chans[i].indio_dev);
|
|
kfree(chans);
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
#else /* CONFIG_OF */
|
|
|
|
static inline struct iio_channel *of_iio_channel_get_all(struct device *dev)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
#endif /* CONFIG_OF */
|
|
|
|
static struct iio_channel *iio_channel_get_sys(const char *name,
|
|
const char *channel_name)
|
|
{
|
|
struct iio_map_internal *c_i = NULL, *c = NULL;
|
|
struct iio_channel *channel;
|
|
int err;
|
|
|
|
if (name == NULL && channel_name == NULL)
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
/* first find matching entry the channel map */
|
|
mutex_lock(&iio_map_list_lock);
|
|
list_for_each_entry(c_i, &iio_map_list, l) {
|
|
if ((name && strcmp(name, c_i->map->consumer_dev_name) != 0) ||
|
|
(channel_name &&
|
|
strcmp(channel_name, c_i->map->consumer_channel) != 0))
|
|
continue;
|
|
c = c_i;
|
|
iio_device_get(c->indio_dev);
|
|
break;
|
|
}
|
|
mutex_unlock(&iio_map_list_lock);
|
|
if (c == NULL)
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
channel = kzalloc(sizeof(*channel), GFP_KERNEL);
|
|
if (channel == NULL) {
|
|
err = -ENOMEM;
|
|
goto error_no_mem;
|
|
}
|
|
|
|
channel->indio_dev = c->indio_dev;
|
|
|
|
if (c->map->adc_channel_label) {
|
|
channel->channel =
|
|
iio_chan_spec_from_name(channel->indio_dev,
|
|
c->map->adc_channel_label);
|
|
|
|
if (channel->channel == NULL) {
|
|
err = -EINVAL;
|
|
goto error_no_chan;
|
|
}
|
|
}
|
|
|
|
return channel;
|
|
|
|
error_no_chan:
|
|
kfree(channel);
|
|
error_no_mem:
|
|
iio_device_put(c->indio_dev);
|
|
return ERR_PTR(err);
|
|
}
|
|
|
|
struct iio_channel *iio_channel_get(struct device *dev,
|
|
const char *channel_name)
|
|
{
|
|
const char *name = dev ? dev_name(dev) : NULL;
|
|
struct iio_channel *channel;
|
|
|
|
if (dev) {
|
|
channel = of_iio_channel_get_by_name(dev->of_node,
|
|
channel_name);
|
|
if (channel != NULL)
|
|
return channel;
|
|
}
|
|
|
|
return iio_channel_get_sys(name, channel_name);
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_channel_get);
|
|
|
|
void iio_channel_release(struct iio_channel *channel)
|
|
{
|
|
if (!channel)
|
|
return;
|
|
iio_device_put(channel->indio_dev);
|
|
kfree(channel);
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_channel_release);
|
|
|
|
static void devm_iio_channel_free(struct device *dev, void *res)
|
|
{
|
|
struct iio_channel *channel = *(struct iio_channel **)res;
|
|
|
|
iio_channel_release(channel);
|
|
}
|
|
|
|
struct iio_channel *devm_iio_channel_get(struct device *dev,
|
|
const char *channel_name)
|
|
{
|
|
struct iio_channel **ptr, *channel;
|
|
|
|
ptr = devres_alloc(devm_iio_channel_free, sizeof(*ptr), GFP_KERNEL);
|
|
if (!ptr)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
channel = iio_channel_get(dev, channel_name);
|
|
if (IS_ERR(channel)) {
|
|
devres_free(ptr);
|
|
return channel;
|
|
}
|
|
|
|
*ptr = channel;
|
|
devres_add(dev, ptr);
|
|
|
|
return channel;
|
|
}
|
|
EXPORT_SYMBOL_GPL(devm_iio_channel_get);
|
|
|
|
struct iio_channel *devm_of_iio_channel_get_by_name(struct device *dev,
|
|
struct device_node *np,
|
|
const char *channel_name)
|
|
{
|
|
struct iio_channel **ptr, *channel;
|
|
|
|
ptr = devres_alloc(devm_iio_channel_free, sizeof(*ptr), GFP_KERNEL);
|
|
if (!ptr)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
channel = of_iio_channel_get_by_name(np, channel_name);
|
|
if (IS_ERR(channel)) {
|
|
devres_free(ptr);
|
|
return channel;
|
|
}
|
|
|
|
*ptr = channel;
|
|
devres_add(dev, ptr);
|
|
|
|
return channel;
|
|
}
|
|
EXPORT_SYMBOL_GPL(devm_of_iio_channel_get_by_name);
|
|
|
|
struct iio_channel *iio_channel_get_all(struct device *dev)
|
|
{
|
|
const char *name;
|
|
struct iio_channel *chans;
|
|
struct iio_map_internal *c = NULL;
|
|
int nummaps = 0;
|
|
int mapind = 0;
|
|
int i, ret;
|
|
|
|
if (dev == NULL)
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
chans = of_iio_channel_get_all(dev);
|
|
if (chans)
|
|
return chans;
|
|
|
|
name = dev_name(dev);
|
|
|
|
mutex_lock(&iio_map_list_lock);
|
|
/* first count the matching maps */
|
|
list_for_each_entry(c, &iio_map_list, l)
|
|
if (name && strcmp(name, c->map->consumer_dev_name) != 0)
|
|
continue;
|
|
else
|
|
nummaps++;
|
|
|
|
if (nummaps == 0) {
|
|
ret = -ENODEV;
|
|
goto error_ret;
|
|
}
|
|
|
|
/* NULL terminated array to save passing size */
|
|
chans = kcalloc(nummaps + 1, sizeof(*chans), GFP_KERNEL);
|
|
if (chans == NULL) {
|
|
ret = -ENOMEM;
|
|
goto error_ret;
|
|
}
|
|
|
|
/* for each map fill in the chans element */
|
|
list_for_each_entry(c, &iio_map_list, l) {
|
|
if (name && strcmp(name, c->map->consumer_dev_name) != 0)
|
|
continue;
|
|
chans[mapind].indio_dev = c->indio_dev;
|
|
chans[mapind].data = c->map->consumer_data;
|
|
chans[mapind].channel =
|
|
iio_chan_spec_from_name(chans[mapind].indio_dev,
|
|
c->map->adc_channel_label);
|
|
if (chans[mapind].channel == NULL) {
|
|
ret = -EINVAL;
|
|
goto error_free_chans;
|
|
}
|
|
iio_device_get(chans[mapind].indio_dev);
|
|
mapind++;
|
|
}
|
|
if (mapind == 0) {
|
|
ret = -ENODEV;
|
|
goto error_free_chans;
|
|
}
|
|
mutex_unlock(&iio_map_list_lock);
|
|
|
|
return chans;
|
|
|
|
error_free_chans:
|
|
for (i = 0; i < nummaps; i++)
|
|
iio_device_put(chans[i].indio_dev);
|
|
kfree(chans);
|
|
error_ret:
|
|
mutex_unlock(&iio_map_list_lock);
|
|
|
|
return ERR_PTR(ret);
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_channel_get_all);
|
|
|
|
void iio_channel_release_all(struct iio_channel *channels)
|
|
{
|
|
struct iio_channel *chan = &channels[0];
|
|
|
|
while (chan->indio_dev) {
|
|
iio_device_put(chan->indio_dev);
|
|
chan++;
|
|
}
|
|
kfree(channels);
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_channel_release_all);
|
|
|
|
static void devm_iio_channel_free_all(struct device *dev, void *res)
|
|
{
|
|
struct iio_channel *channels = *(struct iio_channel **)res;
|
|
|
|
iio_channel_release_all(channels);
|
|
}
|
|
|
|
struct iio_channel *devm_iio_channel_get_all(struct device *dev)
|
|
{
|
|
struct iio_channel **ptr, *channels;
|
|
|
|
ptr = devres_alloc(devm_iio_channel_free_all, sizeof(*ptr), GFP_KERNEL);
|
|
if (!ptr)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
channels = iio_channel_get_all(dev);
|
|
if (IS_ERR(channels)) {
|
|
devres_free(ptr);
|
|
return channels;
|
|
}
|
|
|
|
*ptr = channels;
|
|
devres_add(dev, ptr);
|
|
|
|
return channels;
|
|
}
|
|
EXPORT_SYMBOL_GPL(devm_iio_channel_get_all);
|
|
|
|
static int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
|
|
enum iio_chan_info_enum info)
|
|
{
|
|
int unused;
|
|
int vals[INDIO_MAX_RAW_ELEMENTS];
|
|
int ret;
|
|
int val_len = 2;
|
|
|
|
if (val2 == NULL)
|
|
val2 = &unused;
|
|
|
|
if (!iio_channel_has_info(chan->channel, info))
|
|
return -EINVAL;
|
|
|
|
if (chan->indio_dev->info->read_raw_multi) {
|
|
ret = chan->indio_dev->info->read_raw_multi(chan->indio_dev,
|
|
chan->channel, INDIO_MAX_RAW_ELEMENTS,
|
|
vals, &val_len, info);
|
|
*val = vals[0];
|
|
*val2 = vals[1];
|
|
} else
|
|
ret = chan->indio_dev->info->read_raw(chan->indio_dev,
|
|
chan->channel, val, val2, info);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int iio_read_channel_raw(struct iio_channel *chan, int *val)
|
|
{
|
|
int ret;
|
|
|
|
mutex_lock(&chan->indio_dev->info_exist_lock);
|
|
if (chan->indio_dev->info == NULL) {
|
|
ret = -ENODEV;
|
|
goto err_unlock;
|
|
}
|
|
|
|
ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
|
|
err_unlock:
|
|
mutex_unlock(&chan->indio_dev->info_exist_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_read_channel_raw);
|
|
|
|
int iio_read_channel_average_raw(struct iio_channel *chan, int *val)
|
|
{
|
|
int ret;
|
|
|
|
mutex_lock(&chan->indio_dev->info_exist_lock);
|
|
if (chan->indio_dev->info == NULL) {
|
|
ret = -ENODEV;
|
|
goto err_unlock;
|
|
}
|
|
|
|
ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_AVERAGE_RAW);
|
|
err_unlock:
|
|
mutex_unlock(&chan->indio_dev->info_exist_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_read_channel_average_raw);
|
|
|
|
static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
|
|
int raw, int *processed, unsigned int scale)
|
|
{
|
|
int scale_type, scale_val, scale_val2, offset;
|
|
s64 raw64 = raw;
|
|
int ret;
|
|
|
|
ret = iio_channel_read(chan, &offset, NULL, IIO_CHAN_INFO_OFFSET);
|
|
if (ret >= 0)
|
|
raw64 += offset;
|
|
|
|
scale_type = iio_channel_read(chan, &scale_val, &scale_val2,
|
|
IIO_CHAN_INFO_SCALE);
|
|
if (scale_type < 0) {
|
|
/*
|
|
* Just pass raw values as processed if no scaling is
|
|
* available.
|
|
*/
|
|
*processed = raw;
|
|
return 0;
|
|
}
|
|
|
|
switch (scale_type) {
|
|
case IIO_VAL_INT:
|
|
*processed = raw64 * scale_val;
|
|
break;
|
|
case IIO_VAL_INT_PLUS_MICRO:
|
|
if (scale_val2 < 0)
|
|
*processed = -raw64 * scale_val;
|
|
else
|
|
*processed = raw64 * scale_val;
|
|
*processed += div_s64(raw64 * (s64)scale_val2 * scale,
|
|
1000000LL);
|
|
break;
|
|
case IIO_VAL_INT_PLUS_NANO:
|
|
if (scale_val2 < 0)
|
|
*processed = -raw64 * scale_val;
|
|
else
|
|
*processed = raw64 * scale_val;
|
|
*processed += div_s64(raw64 * (s64)scale_val2 * scale,
|
|
1000000000LL);
|
|
break;
|
|
case IIO_VAL_FRACTIONAL:
|
|
*processed = div_s64(raw64 * (s64)scale_val * scale,
|
|
scale_val2);
|
|
break;
|
|
case IIO_VAL_FRACTIONAL_LOG2:
|
|
*processed = (raw64 * (s64)scale_val * scale) >> scale_val2;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
|
|
int *processed, unsigned int scale)
|
|
{
|
|
int ret;
|
|
|
|
mutex_lock(&chan->indio_dev->info_exist_lock);
|
|
if (chan->indio_dev->info == NULL) {
|
|
ret = -ENODEV;
|
|
goto err_unlock;
|
|
}
|
|
|
|
ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,
|
|
scale);
|
|
err_unlock:
|
|
mutex_unlock(&chan->indio_dev->info_exist_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
|
|
|
|
int iio_read_channel_attribute(struct iio_channel *chan, int *val, int *val2,
|
|
enum iio_chan_info_enum attribute)
|
|
{
|
|
int ret;
|
|
|
|
mutex_lock(&chan->indio_dev->info_exist_lock);
|
|
if (chan->indio_dev->info == NULL) {
|
|
ret = -ENODEV;
|
|
goto err_unlock;
|
|
}
|
|
|
|
ret = iio_channel_read(chan, val, val2, attribute);
|
|
err_unlock:
|
|
mutex_unlock(&chan->indio_dev->info_exist_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_read_channel_attribute);
|
|
|
|
int iio_read_channel_offset(struct iio_channel *chan, int *val, int *val2)
|
|
{
|
|
return iio_read_channel_attribute(chan, val, val2, IIO_CHAN_INFO_OFFSET);
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_read_channel_offset);
|
|
|
|
int iio_read_channel_processed(struct iio_channel *chan, int *val)
|
|
{
|
|
int ret;
|
|
|
|
mutex_lock(&chan->indio_dev->info_exist_lock);
|
|
if (chan->indio_dev->info == NULL) {
|
|
ret = -ENODEV;
|
|
goto err_unlock;
|
|
}
|
|
|
|
if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) {
|
|
ret = iio_channel_read(chan, val, NULL,
|
|
IIO_CHAN_INFO_PROCESSED);
|
|
} else {
|
|
ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
|
|
if (ret < 0)
|
|
goto err_unlock;
|
|
ret = iio_convert_raw_to_processed_unlocked(chan, *val, val, 1);
|
|
}
|
|
|
|
err_unlock:
|
|
mutex_unlock(&chan->indio_dev->info_exist_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_read_channel_processed);
|
|
|
|
int iio_read_channel_scale(struct iio_channel *chan, int *val, int *val2)
|
|
{
|
|
return iio_read_channel_attribute(chan, val, val2, IIO_CHAN_INFO_SCALE);
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_read_channel_scale);
|
|
|
|
static int iio_channel_read_avail(struct iio_channel *chan,
|
|
const int **vals, int *type, int *length,
|
|
enum iio_chan_info_enum info)
|
|
{
|
|
if (!iio_channel_has_available(chan->channel, info))
|
|
return -EINVAL;
|
|
|
|
return chan->indio_dev->info->read_avail(chan->indio_dev, chan->channel,
|
|
vals, type, length, info);
|
|
}
|
|
|
|
int iio_read_avail_channel_attribute(struct iio_channel *chan,
|
|
const int **vals, int *type, int *length,
|
|
enum iio_chan_info_enum attribute)
|
|
{
|
|
int ret;
|
|
|
|
mutex_lock(&chan->indio_dev->info_exist_lock);
|
|
if (!chan->indio_dev->info) {
|
|
ret = -ENODEV;
|
|
goto err_unlock;
|
|
}
|
|
|
|
ret = iio_channel_read_avail(chan, vals, type, length, attribute);
|
|
err_unlock:
|
|
mutex_unlock(&chan->indio_dev->info_exist_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_read_avail_channel_attribute);
|
|
|
|
int iio_read_avail_channel_raw(struct iio_channel *chan,
|
|
const int **vals, int *length)
|
|
{
|
|
int ret;
|
|
int type;
|
|
|
|
ret = iio_read_avail_channel_attribute(chan, vals, &type, length,
|
|
IIO_CHAN_INFO_RAW);
|
|
|
|
if (ret >= 0 && type != IIO_VAL_INT)
|
|
/* raw values are assumed to be IIO_VAL_INT */
|
|
ret = -EINVAL;
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_read_avail_channel_raw);
|
|
|
|
static int iio_channel_read_max(struct iio_channel *chan,
|
|
int *val, int *val2, int *type,
|
|
enum iio_chan_info_enum info)
|
|
{
|
|
int unused;
|
|
const int *vals;
|
|
int length;
|
|
int ret;
|
|
|
|
if (!val2)
|
|
val2 = &unused;
|
|
|
|
ret = iio_channel_read_avail(chan, &vals, type, &length, info);
|
|
switch (ret) {
|
|
case IIO_AVAIL_RANGE:
|
|
switch (*type) {
|
|
case IIO_VAL_INT:
|
|
*val = vals[2];
|
|
break;
|
|
default:
|
|
*val = vals[4];
|
|
*val2 = vals[5];
|
|
}
|
|
return 0;
|
|
|
|
case IIO_AVAIL_LIST:
|
|
if (length <= 0)
|
|
return -EINVAL;
|
|
switch (*type) {
|
|
case IIO_VAL_INT:
|
|
*val = vals[--length];
|
|
while (length) {
|
|
if (vals[--length] > *val)
|
|
*val = vals[length];
|
|
}
|
|
break;
|
|
default:
|
|
/* FIXME: learn about max for other iio values */
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
|
|
default:
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
int iio_read_max_channel_raw(struct iio_channel *chan, int *val)
|
|
{
|
|
int ret;
|
|
int type;
|
|
|
|
mutex_lock(&chan->indio_dev->info_exist_lock);
|
|
if (!chan->indio_dev->info) {
|
|
ret = -ENODEV;
|
|
goto err_unlock;
|
|
}
|
|
|
|
ret = iio_channel_read_max(chan, val, NULL, &type, IIO_CHAN_INFO_RAW);
|
|
err_unlock:
|
|
mutex_unlock(&chan->indio_dev->info_exist_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_read_max_channel_raw);
|
|
|
|
int iio_get_channel_type(struct iio_channel *chan, enum iio_chan_type *type)
|
|
{
|
|
int ret = 0;
|
|
/* Need to verify underlying driver has not gone away */
|
|
|
|
mutex_lock(&chan->indio_dev->info_exist_lock);
|
|
if (chan->indio_dev->info == NULL) {
|
|
ret = -ENODEV;
|
|
goto err_unlock;
|
|
}
|
|
|
|
*type = chan->channel->type;
|
|
err_unlock:
|
|
mutex_unlock(&chan->indio_dev->info_exist_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_get_channel_type);
|
|
|
|
static int iio_channel_write(struct iio_channel *chan, int val, int val2,
|
|
enum iio_chan_info_enum info)
|
|
{
|
|
return chan->indio_dev->info->write_raw(chan->indio_dev,
|
|
chan->channel, val, val2, info);
|
|
}
|
|
|
|
int iio_write_channel_attribute(struct iio_channel *chan, int val, int val2,
|
|
enum iio_chan_info_enum attribute)
|
|
{
|
|
int ret;
|
|
|
|
mutex_lock(&chan->indio_dev->info_exist_lock);
|
|
if (chan->indio_dev->info == NULL) {
|
|
ret = -ENODEV;
|
|
goto err_unlock;
|
|
}
|
|
|
|
ret = iio_channel_write(chan, val, val2, attribute);
|
|
err_unlock:
|
|
mutex_unlock(&chan->indio_dev->info_exist_lock);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_write_channel_attribute);
|
|
|
|
int iio_write_channel_raw(struct iio_channel *chan, int val)
|
|
{
|
|
return iio_write_channel_attribute(chan, val, 0, IIO_CHAN_INFO_RAW);
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_write_channel_raw);
|
|
|
|
unsigned int iio_get_channel_ext_info_count(struct iio_channel *chan)
|
|
{
|
|
const struct iio_chan_spec_ext_info *ext_info;
|
|
unsigned int i = 0;
|
|
|
|
if (!chan->channel->ext_info)
|
|
return i;
|
|
|
|
for (ext_info = chan->channel->ext_info; ext_info->name; ext_info++)
|
|
++i;
|
|
|
|
return i;
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_get_channel_ext_info_count);
|
|
|
|
static const struct iio_chan_spec_ext_info *iio_lookup_ext_info(
|
|
const struct iio_channel *chan,
|
|
const char *attr)
|
|
{
|
|
const struct iio_chan_spec_ext_info *ext_info;
|
|
|
|
if (!chan->channel->ext_info)
|
|
return NULL;
|
|
|
|
for (ext_info = chan->channel->ext_info; ext_info->name; ++ext_info) {
|
|
if (!strcmp(attr, ext_info->name))
|
|
return ext_info;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
ssize_t iio_read_channel_ext_info(struct iio_channel *chan,
|
|
const char *attr, char *buf)
|
|
{
|
|
const struct iio_chan_spec_ext_info *ext_info;
|
|
|
|
ext_info = iio_lookup_ext_info(chan, attr);
|
|
if (!ext_info)
|
|
return -EINVAL;
|
|
|
|
return ext_info->read(chan->indio_dev, ext_info->private,
|
|
chan->channel, buf);
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_read_channel_ext_info);
|
|
|
|
ssize_t iio_write_channel_ext_info(struct iio_channel *chan, const char *attr,
|
|
const char *buf, size_t len)
|
|
{
|
|
const struct iio_chan_spec_ext_info *ext_info;
|
|
|
|
ext_info = iio_lookup_ext_info(chan, attr);
|
|
if (!ext_info)
|
|
return -EINVAL;
|
|
|
|
return ext_info->write(chan->indio_dev, ext_info->private,
|
|
chan->channel, buf, len);
|
|
}
|
|
EXPORT_SYMBOL_GPL(iio_write_channel_ext_info);
|