[deliverable/linux.git] / drivers / iio / inkern.c

/* The industrial I/O core in kernel channel mapping
 *
 * Copyright (c) 2011 Jonathan Cameron
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */
#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);

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(&mapi->l, &iio_map_list);
		i++;
	}
error_ret:
	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 = -ENODEV;
	struct iio_map_internal *mapi, *next;

	mutex_lock(&iio_map_list_lock);
	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;
		}
	}
	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, 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);
}

static 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 %s:%s(%i)\n",
				np->full_name, 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;
}

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_by_name(struct device_node *np, const char *name)
{
	return NULL;
}

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);
}

static int devm_iio_channel_match(struct device *dev, void *res, void *data)
{
	struct iio_channel **r = res;

	if (!r || !*r) {
		WARN_ON(!r || !*r);
		return 0;
	}

	return *r == data;
}

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);

void devm_iio_channel_release(struct device *dev, struct iio_channel *channel)
{
	WARN_ON(devres_release(dev, devm_iio_channel_free,
			       devm_iio_channel_match, channel));
}
EXPORT_SYMBOL_GPL(devm_iio_channel_release);

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 = kzalloc(sizeof(*chans)*(nummaps + 1), 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);

void devm_iio_channel_release_all(struct device *dev,
				  struct iio_channel *channels)
{
	WARN_ON(devres_release(dev, devm_iio_channel_free_all,
			       devm_iio_channel_match, channels));
}
EXPORT_SYMBOL_GPL(devm_iio_channel_release_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)
		return scale_type;

	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_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)
{
	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, IIO_CHAN_INFO_SCALE);
err_unlock:
	mutex_unlock(&chan->indio_dev->info_exist_lock);

	return ret;
}
EXPORT_SYMBOL_GPL(iio_read_channel_scale);

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_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_write(chan, val, 0, IIO_CHAN_INFO_RAW);
err_unlock:
	mutex_unlock(&chan->indio_dev->info_exist_lock);

	return ret;
}
EXPORT_SYMBOL_GPL(iio_write_channel_raw);
Commit	Line	Data
e27d75d7 JC	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>
17d82b47	13	#include <linux/of.h>
e27d75d7	14
06458e27	15	#include <linux/iio/iio.h>
e27d75d7	16	#include "iio_core.h"
06458e27 JC	17	#include <linux/iio/machine.h>
	18	#include <linux/iio/driver.h>
	19	#include <linux/iio/consumer.h>
e27d75d7 JC	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
6cb2afd7 GR	58	/*
6cb2afd7 GR	59	* Remove all map entries associated with the given iio device
e27d75d7	60	*/
6cb2afd7	61	int iio_map_array_unregister(struct iio_dev *indio_dev)
e27d75d7	62	{
6cb2afd7	63	int ret = -ENODEV;
c34c1819	64	struct iio_map_internal mapi, next;
e27d75d7 JC	65
e27d75d7 JC	66	mutex_lock(&iio_map_list_lock);
c34c1819	67	list_for_each_entry_safe(mapi, next, &iio_map_list, l) {
6cb2afd7 GR	68	if (indio_dev == mapi->indio_dev) {
	69	list_del(&mapi->l);
	70	kfree(mapi);
	71	ret = 0;
e27d75d7 JC	72	}
e27d75d7 JC	73	}
e27d75d7	74	mutex_unlock(&iio_map_list_lock);
e27d75d7 JC	75	return ret;
	76	}
	77	EXPORT_SYMBOL_GPL(iio_map_array_unregister);
	78
	79	static const struct iio_chan_spec
314be14b	80	iio_chan_spec_from_name(const struct iio_dev indio_dev, const char *name)
e27d75d7 JC	81	{
	82	int i;
	83	const struct iio_chan_spec *chan = NULL;
	84
	85	for (i = 0; i < indio_dev->num_channels; i++)
	86	if (indio_dev->channels[i].datasheet_name &&
	87	strcmp(name, indio_dev->channels[i].datasheet_name) == 0) {
	88	chan = &indio_dev->channels[i];
	89	break;
	90	}
	91	return chan;
	92	}
	93
17d82b47 GR	94	#ifdef CONFIG_OF
	95
	96	static int iio_dev_node_match(struct device dev, void data)
	97	{
	98	return dev->of_node == data && dev->type == &iio_device_type;
	99	}
	100
acd82567 II	101	/**
	102	* __of_iio_simple_xlate - translate iiospec to the IIO channel index
	103	* @indio_dev: pointer to the iio_dev structure
	104	* @iiospec: IIO specifier as found in the device tree
	105	*
	106	* This is simple translation function, suitable for the most 1:1 mapped
	107	* channels in IIO chips. This function performs only one sanity check:
	108	* whether IIO index is less than num_channels (that is specified in the
	109	* iio_dev).
	110	*/
	111	static int __of_iio_simple_xlate(struct iio_dev *indio_dev,
	112	const struct of_phandle_args *iiospec)
	113	{
	114	if (!iiospec->args_count)
	115	return 0;
	116
1f202725 SW	117	if (iiospec->args[0] >= indio_dev->num_channels) {
	118	dev_err(&indio_dev->dev, "invalid channel index %u\n",
	119	iiospec->args[0]);
acd82567	120	return -EINVAL;
1f202725	121	}
acd82567 II	122
	123	return iiospec->args[0];
	124	}
	125
17d82b47 GR	126	static int __of_iio_channel_get(struct iio_channel *channel,
	127	struct device_node *np, int index)
	128	{
	129	struct device *idev;
	130	struct iio_dev *indio_dev;
	131	int err;
	132	struct of_phandle_args iiospec;
	133
	134	err = of_parse_phandle_with_args(np, "io-channels",
	135	"#io-channel-cells",
	136	index, &iiospec);
	137	if (err)
	138	return err;
	139
	140	idev = bus_find_device(&iio_bus_type, NULL, iiospec.np,
	141	iio_dev_node_match);
	142	of_node_put(iiospec.np);
	143	if (idev == NULL)
	144	return -EPROBE_DEFER;
	145
	146	indio_dev = dev_to_iio_dev(idev);
	147	channel->indio_dev = indio_dev;
acd82567 II	148	if (indio_dev->info->of_xlate)
	149	index = indio_dev->info->of_xlate(indio_dev, &iiospec);
	150	else
	151	index = __of_iio_simple_xlate(indio_dev, &iiospec);
	152	if (index < 0)
17d82b47	153	goto err_put;
17d82b47 GR	154	channel->channel = &indio_dev->channels[index];
	155
	156	return 0;
	157
	158	err_put:
	159	iio_device_put(indio_dev);
acd82567	160	return index;
17d82b47 GR	161	}
	162
	163	static struct iio_channel of_iio_channel_get(struct device_node np, int index)
	164	{
	165	struct iio_channel *channel;
	166	int err;
	167
	168	if (index < 0)
	169	return ERR_PTR(-EINVAL);
	170
	171	channel = kzalloc(sizeof(*channel), GFP_KERNEL);
	172	if (channel == NULL)
	173	return ERR_PTR(-ENOMEM);
	174
	175	err = __of_iio_channel_get(channel, np, index);
	176	if (err)
	177	goto err_free_channel;
	178
	179	return channel;
	180
	181	err_free_channel:
	182	kfree(channel);
	183	return ERR_PTR(err);
	184	}
	185
	186	static struct iio_channel of_iio_channel_get_by_name(struct device_node np,
	187	const char *name)
	188	{
	189	struct iio_channel *chan = NULL;
	190
	191	/* Walk up the tree of devices looking for a matching iio channel */
	192	while (np) {
	193	int index = 0;
	194
	195	/*
	196	* For named iio channels, first look up the name in the
	197	* "io-channel-names" property. If it cannot be found, the
	198	* index will be an error code, and of_iio_channel_get()
	199	* will fail.
	200	*/
	201	if (name)
	202	index = of_property_match_string(np, "io-channel-names",
	203	name);
	204	chan = of_iio_channel_get(np, index);
872687f6	205	if (!IS_ERR(chan) \|\| PTR_ERR(chan) == -EPROBE_DEFER)
17d82b47 GR	206	break;
	207	else if (name && index >= 0) {
	208	pr_err("ERROR: could not get IIO channel %s:%s(%i)\n",
	209	np->full_name, name ? name : "", index);
a2c12493	210	return NULL;
17d82b47 GR	211	}
	212
	213	/*
	214	* No matching IIO channel found on this node.
	215	* If the parent node has a "io-channel-ranges" property,
	216	* then we can try one of its channels.
	217	*/
	218	np = np->parent;
	219	if (np && !of_get_property(np, "io-channel-ranges", NULL))
a2c12493	220	return NULL;
17d82b47	221	}
a2c12493	222
17d82b47 GR	223	return chan;
	224	}
	225
	226	static struct iio_channel of_iio_channel_get_all(struct device dev)
	227	{
	228	struct iio_channel *chans;
	229	int i, mapind, nummaps = 0;
	230	int ret;
	231
	232	do {
	233	ret = of_parse_phandle_with_args(dev->of_node,
	234	"io-channels",
	235	"#io-channel-cells",
	236	nummaps, NULL);
	237	if (ret < 0)
	238	break;
	239	} while (++nummaps);
	240
	241	if (nummaps == 0) /* no error, return NULL to search map table */
	242	return NULL;
	243
	244	/* NULL terminated array to save passing size */
	245	chans = kcalloc(nummaps + 1, sizeof(*chans), GFP_KERNEL);
	246	if (chans == NULL)
	247	return ERR_PTR(-ENOMEM);
	248
	249	/* Search for OF matches */
	250	for (mapind = 0; mapind < nummaps; mapind++) {
	251	ret = __of_iio_channel_get(&chans[mapind], dev->of_node,
	252	mapind);
	253	if (ret)
	254	goto error_free_chans;
	255	}
	256	return chans;
	257
	258	error_free_chans:
	259	for (i = 0; i < mapind; i++)
	260	iio_device_put(chans[i].indio_dev);
	261	kfree(chans);
	262	return ERR_PTR(ret);
	263	}
	264
	265	#else /* CONFIG_OF */
	266
	267	static inline struct iio_channel *
	268	of_iio_channel_get_by_name(struct device_node np, const char name)
	269	{
	270	return NULL;
	271	}
	272
	273	static inline struct iio_channel of_iio_channel_get_all(struct device dev)
	274	{
	275	return NULL;
	276	}
	277
	278	#endif /* CONFIG_OF */
e27d75d7	279
5aa57f0a GR	280	static struct iio_channel iio_channel_get_sys(const char name,
5aa57f0a GR	281	const char *channel_name)
e27d75d7 JC	282	{
	283	struct iio_map_internal c_i = NULL, c = NULL;
	284	struct iio_channel *channel;
3183bac1	285	int err;
e27d75d7 JC	286
	287	if (name == NULL && channel_name == NULL)
	288	return ERR_PTR(-ENODEV);
	289
	290	/* first find matching entry the channel map */
	291	mutex_lock(&iio_map_list_lock);
	292	list_for_each_entry(c_i, &iio_map_list, l) {
	293	if ((name && strcmp(name, c_i->map->consumer_dev_name) != 0) \|\|
	294	(channel_name &&
	295	strcmp(channel_name, c_i->map->consumer_channel) != 0))
	296	continue;
	297	c = c_i;
1875ffd2	298	iio_device_get(c->indio_dev);
e27d75d7 JC	299	break;
	300	}
	301	mutex_unlock(&iio_map_list_lock);
	302	if (c == NULL)
	303	return ERR_PTR(-ENODEV);
	304
2cc412b5	305	channel = kzalloc(sizeof(*channel), GFP_KERNEL);
3183bac1 KM	306	if (channel == NULL) {
3183bac1 KM	307	err = -ENOMEM;
801c4b5c	308	goto error_no_mem;
3183bac1	309	}
e27d75d7 JC	310
	311	channel->indio_dev = c->indio_dev;
	312
b2b79ffa	313	if (c->map->adc_channel_label) {
e27d75d7 JC	314	channel->channel =
	315	iio_chan_spec_from_name(channel->indio_dev,
	316	c->map->adc_channel_label);
	317
3183bac1 KM	318	if (channel->channel == NULL) {
3183bac1 KM	319	err = -EINVAL;
b2b79ffa	320	goto error_no_chan;
3183bac1	321	}
b2b79ffa KM	322	}
b2b79ffa KM	323
e27d75d7	324	return channel;
b2b79ffa KM	325
b2b79ffa KM	326	error_no_chan:
b2b79ffa	327	kfree(channel);
801c4b5c KM	328	error_no_mem:
801c4b5c KM	329	iio_device_put(c->indio_dev);
3183bac1	330	return ERR_PTR(err);
e27d75d7	331	}
5aa57f0a GR	332
	333	struct iio_channel iio_channel_get(struct device dev,
	334	const char *channel_name)
	335	{
	336	const char *name = dev ? dev_name(dev) : NULL;
17d82b47	337	struct iio_channel *channel;
5aa57f0a	338
17d82b47 GR	339	if (dev) {
	340	channel = of_iio_channel_get_by_name(dev->of_node,
	341	channel_name);
	342	if (channel != NULL)
	343	return channel;
	344	}
a2c12493	345
5aa57f0a GR	346	return iio_channel_get_sys(name, channel_name);
5aa57f0a GR	347	}
314be14b	348	EXPORT_SYMBOL_GPL(iio_channel_get);
e27d75d7	349
314be14b	350	void iio_channel_release(struct iio_channel *channel)
e27d75d7	351	{
d81dac3c DC	352	if (!channel)
d81dac3c DC	353	return;
1875ffd2	354	iio_device_put(channel->indio_dev);
e27d75d7 JC	355	kfree(channel);
e27d75d7 JC	356	}
314be14b	357	EXPORT_SYMBOL_GPL(iio_channel_release);
e27d75d7	358
8bf872d8 LD	359	static void devm_iio_channel_free(struct device dev, void res)
	360	{
	361	struct iio_channel channel = (struct iio_channel **)res;
	362
	363	iio_channel_release(channel);
	364	}
	365
	366	static int devm_iio_channel_match(struct device dev, void res, void *data)
	367	{
	368	struct iio_channel **r = res;
	369
	370	if (!r \|\| !*r) {
	371	WARN_ON(!r \|\| !*r);
	372	return 0;
	373	}
	374
	375	return *r == data;
	376	}
	377
	378	struct iio_channel devm_iio_channel_get(struct device dev,
	379	const char *channel_name)
	380	{
	381	struct iio_channel *ptr, channel;
	382
	383	ptr = devres_alloc(devm_iio_channel_free, sizeof(*ptr), GFP_KERNEL);
	384	if (!ptr)
	385	return ERR_PTR(-ENOMEM);
	386
	387	channel = iio_channel_get(dev, channel_name);
	388	if (IS_ERR(channel)) {
	389	devres_free(ptr);
	390	return channel;
	391	}
	392
	393	*ptr = channel;
	394	devres_add(dev, ptr);
	395
	396	return channel;
	397	}
	398	EXPORT_SYMBOL_GPL(devm_iio_channel_get);
	399
	400	void devm_iio_channel_release(struct device dev, struct iio_channel channel)
	401	{
	402	WARN_ON(devres_release(dev, devm_iio_channel_free,
	403	devm_iio_channel_match, channel));
	404	}
	405	EXPORT_SYMBOL_GPL(devm_iio_channel_release);
	406
ca7d98db	407	struct iio_channel iio_channel_get_all(struct device dev)
e27d75d7	408	{
ca7d98db	409	const char *name;
e27d75d7 JC	410	struct iio_channel *chans;
	411	struct iio_map_internal *c = NULL;
	412	int nummaps = 0;
	413	int mapind = 0;
	414	int i, ret;
	415
ca7d98db	416	if (dev == NULL)
e27d75d7	417	return ERR_PTR(-EINVAL);
17d82b47 GR	418
	419	chans = of_iio_channel_get_all(dev);
	420	if (chans)
	421	return chans;
	422
ca7d98db	423	name = dev_name(dev);
e27d75d7 JC	424
	425	mutex_lock(&iio_map_list_lock);
	426	/* first count the matching maps */
	427	list_for_each_entry(c, &iio_map_list, l)
	428	if (name && strcmp(name, c->map->consumer_dev_name) != 0)
	429	continue;
	430	else
	431	nummaps++;
	432
	433	if (nummaps == 0) {
	434	ret = -ENODEV;
	435	goto error_ret;
	436	}
	437
	438	/* NULL terminated array to save passing size */
	439	chans = kzalloc(sizeof(chans)(nummaps + 1), GFP_KERNEL);
	440	if (chans == NULL) {
	441	ret = -ENOMEM;
	442	goto error_ret;
	443	}
	444
	445	/* for each map fill in the chans element */
	446	list_for_each_entry(c, &iio_map_list, l) {
	447	if (name && strcmp(name, c->map->consumer_dev_name) != 0)
	448	continue;
	449	chans[mapind].indio_dev = c->indio_dev;
0464415d	450	chans[mapind].data = c->map->consumer_data;
e27d75d7 JC	451	chans[mapind].channel =
	452	iio_chan_spec_from_name(chans[mapind].indio_dev,
	453	c->map->adc_channel_label);
	454	if (chans[mapind].channel == NULL) {
	455	ret = -EINVAL;
e27d75d7 JC	456	goto error_free_chans;
e27d75d7 JC	457	}
1875ffd2	458	iio_device_get(chans[mapind].indio_dev);
e27d75d7 JC	459	mapind++;
e27d75d7 JC	460	}
e27d75d7 JC	461	if (mapind == 0) {
	462	ret = -ENODEV;
	463	goto error_free_chans;
	464	}
e59b9afe DC	465	mutex_unlock(&iio_map_list_lock);
e59b9afe DC	466
e27d75d7 JC	467	return chans;
	468
	469	error_free_chans:
	470	for (i = 0; i < nummaps; i++)
1875ffd2	471	iio_device_put(chans[i].indio_dev);
e27d75d7 JC	472	kfree(chans);
	473	error_ret:
	474	mutex_unlock(&iio_map_list_lock);
	475
	476	return ERR_PTR(ret);
	477	}
314be14b	478	EXPORT_SYMBOL_GPL(iio_channel_get_all);
e27d75d7	479
314be14b	480	void iio_channel_release_all(struct iio_channel *channels)
e27d75d7 JC	481	{
	482	struct iio_channel *chan = &channels[0];
	483
	484	while (chan->indio_dev) {
1875ffd2	485	iio_device_put(chan->indio_dev);
e27d75d7 JC	486	chan++;
	487	}
	488	kfree(channels);
	489	}
314be14b	490	EXPORT_SYMBOL_GPL(iio_channel_release_all);
e27d75d7	491
efc2c013 LD	492	static void devm_iio_channel_free_all(struct device dev, void res)
	493	{
	494	struct iio_channel channels = (struct iio_channel **)res;
	495
	496	iio_channel_release_all(channels);
	497	}
	498
	499	struct iio_channel devm_iio_channel_get_all(struct device dev)
	500	{
	501	struct iio_channel *ptr, channels;
	502
	503	ptr = devres_alloc(devm_iio_channel_free_all, sizeof(*ptr), GFP_KERNEL);
	504	if (!ptr)
	505	return ERR_PTR(-ENOMEM);
	506
	507	channels = iio_channel_get_all(dev);
	508	if (IS_ERR(channels)) {
	509	devres_free(ptr);
	510	return channels;
	511	}
	512
	513	*ptr = channels;
	514	devres_add(dev, ptr);
	515
	516	return channels;
	517	}
	518	EXPORT_SYMBOL_GPL(devm_iio_channel_get_all);
	519
	520	void devm_iio_channel_release_all(struct device *dev,
	521	struct iio_channel *channels)
	522	{
	523	WARN_ON(devres_release(dev, devm_iio_channel_free_all,
	524	devm_iio_channel_match, channels));
	525	}
	526	EXPORT_SYMBOL_GPL(devm_iio_channel_release_all);
	527
48e44ce0 LPC	528	static int iio_channel_read(struct iio_channel chan, int val, int *val2,
	529	enum iio_chan_info_enum info)
	530	{
	531	int unused;
9fbfb4b3 SP	532	int vals[INDIO_MAX_RAW_ELEMENTS];
	533	int ret;
	534	int val_len = 2;
48e44ce0 LPC	535
	536	if (val2 == NULL)
	537	val2 = &unused;
	538
fc0b8170	539	if (!iio_channel_has_info(chan->channel, info))
65de7654 FP	540	return -EINVAL;
65de7654 FP	541
9fbfb4b3 SP	542	if (chan->indio_dev->info->read_raw_multi) {
	543	ret = chan->indio_dev->info->read_raw_multi(chan->indio_dev,
	544	chan->channel, INDIO_MAX_RAW_ELEMENTS,
	545	vals, &val_len, info);
	546	*val = vals[0];
	547	*val2 = vals[1];
	548	} else
	549	ret = chan->indio_dev->info->read_raw(chan->indio_dev,
	550	chan->channel, val, val2, info);
	551
	552	return ret;
48e44ce0 LPC	553	}
48e44ce0 LPC	554
314be14b	555	int iio_read_channel_raw(struct iio_channel chan, int val)
e27d75d7	556	{
48e44ce0	557	int ret;
e27d75d7 JC	558
	559	mutex_lock(&chan->indio_dev->info_exist_lock);
	560	if (chan->indio_dev->info == NULL) {
	561	ret = -ENODEV;
	562	goto err_unlock;
	563	}
	564
48e44ce0	565	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
e27d75d7 JC	566	err_unlock:
	567	mutex_unlock(&chan->indio_dev->info_exist_lock);
	568
	569	return ret;
	570	}
314be14b	571	EXPORT_SYMBOL_GPL(iio_read_channel_raw);
e27d75d7	572
476d4af2 SR	573	int iio_read_channel_average_raw(struct iio_channel chan, int val)
	574	{
	575	int ret;
	576
	577	mutex_lock(&chan->indio_dev->info_exist_lock);
	578	if (chan->indio_dev->info == NULL) {
	579	ret = -ENODEV;
	580	goto err_unlock;
	581	}
	582
	583	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_AVERAGE_RAW);
	584	err_unlock:
	585	mutex_unlock(&chan->indio_dev->info_exist_lock);
	586
	587	return ret;
	588	}
	589	EXPORT_SYMBOL_GPL(iio_read_channel_average_raw);
	590
48e44ce0 LPC	591	static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
	592	int raw, int *processed, unsigned int scale)
	593	{
	594	int scale_type, scale_val, scale_val2, offset;
	595	s64 raw64 = raw;
	596	int ret;
	597
6c5d4c96	598	ret = iio_channel_read(chan, &offset, NULL, IIO_CHAN_INFO_OFFSET);
f91d1b63	599	if (ret >= 0)
48e44ce0 LPC	600	raw64 += offset;
	601
	602	scale_type = iio_channel_read(chan, &scale_val, &scale_val2,
	603	IIO_CHAN_INFO_SCALE);
	604	if (scale_type < 0)
	605	return scale_type;
	606
	607	switch (scale_type) {
	608	case IIO_VAL_INT:
	609	processed = raw64 scale_val;
	610	break;
	611	case IIO_VAL_INT_PLUS_MICRO:
	612	if (scale_val2 < 0)
	613	processed = -raw64 scale_val;
	614	else
	615	processed = raw64 scale_val;
	616	processed += div_s64(raw64 (s64)scale_val2 * scale,
	617	1000000LL);
	618	break;
	619	case IIO_VAL_INT_PLUS_NANO:
	620	if (scale_val2 < 0)
	621	processed = -raw64 scale_val;
	622	else
	623	processed = raw64 scale_val;
	624	processed += div_s64(raw64 (s64)scale_val2 * scale,
	625	1000000000LL);
	626	break;
	627	case IIO_VAL_FRACTIONAL:
	628	processed = div_s64(raw64 (s64)scale_val * scale,
	629	scale_val2);
	630	break;
103d9fb9 LPC	631	case IIO_VAL_FRACTIONAL_LOG2:
	632	processed = (raw64 (s64)scale_val * scale) >> scale_val2;
	633	break;
48e44ce0 LPC	634	default:
	635	return -EINVAL;
	636	}
	637
	638	return 0;
	639	}
	640
	641	int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
	642	int *processed, unsigned int scale)
	643	{
	644	int ret;
	645
	646	mutex_lock(&chan->indio_dev->info_exist_lock);
	647	if (chan->indio_dev->info == NULL) {
	648	ret = -ENODEV;
	649	goto err_unlock;
	650	}
	651
	652	ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,
	653	scale);
	654	err_unlock:
	655	mutex_unlock(&chan->indio_dev->info_exist_lock);
	656
	657	return ret;
	658	}
	659	EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
	660
	661	int iio_read_channel_processed(struct iio_channel chan, int val)
	662	{
	663	int ret;
	664
	665	mutex_lock(&chan->indio_dev->info_exist_lock);
	666	if (chan->indio_dev->info == NULL) {
	667	ret = -ENODEV;
	668	goto err_unlock;
	669	}
	670
	671	if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) {
	672	ret = iio_channel_read(chan, val, NULL,
	673	IIO_CHAN_INFO_PROCESSED);
	674	} else {
	675	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
	676	if (ret < 0)
	677	goto err_unlock;
	678	ret = iio_convert_raw_to_processed_unlocked(chan, *val, val, 1);
	679	}
	680
	681	err_unlock:
	682	mutex_unlock(&chan->indio_dev->info_exist_lock);
	683
	684	return ret;
	685	}
	686	EXPORT_SYMBOL_GPL(iio_read_channel_processed);
	687
314be14b	688	int iio_read_channel_scale(struct iio_channel chan, int val, int *val2)
e27d75d7 JC	689	{
	690	int ret;
	691
	692	mutex_lock(&chan->indio_dev->info_exist_lock);
	693	if (chan->indio_dev->info == NULL) {
	694	ret = -ENODEV;
	695	goto err_unlock;
	696	}
	697
48e44ce0	698	ret = iio_channel_read(chan, val, val2, IIO_CHAN_INFO_SCALE);
e27d75d7 JC	699	err_unlock:
	700	mutex_unlock(&chan->indio_dev->info_exist_lock);
	701
	702	return ret;
	703	}
314be14b	704	EXPORT_SYMBOL_GPL(iio_read_channel_scale);
e27d75d7	705
314be14b	706	int iio_get_channel_type(struct iio_channel chan, enum iio_chan_type type)
e27d75d7 JC	707	{
	708	int ret = 0;
	709	/* Need to verify underlying driver has not gone away */
	710
	711	mutex_lock(&chan->indio_dev->info_exist_lock);
	712	if (chan->indio_dev->info == NULL) {
	713	ret = -ENODEV;
	714	goto err_unlock;
	715	}
	716
	717	*type = chan->channel->type;
	718	err_unlock:
	719	mutex_unlock(&chan->indio_dev->info_exist_lock);
	720
	721	return ret;
	722	}
314be14b	723	EXPORT_SYMBOL_GPL(iio_get_channel_type);
f9380e71 DES	724
	725	static int iio_channel_write(struct iio_channel *chan, int val, int val2,
	726	enum iio_chan_info_enum info)
	727	{
	728	return chan->indio_dev->info->write_raw(chan->indio_dev,
	729	chan->channel, val, val2, info);
	730	}
	731
	732	int iio_write_channel_raw(struct iio_channel *chan, int val)
	733	{
	734	int ret;
	735
	736	mutex_lock(&chan->indio_dev->info_exist_lock);
	737	if (chan->indio_dev->info == NULL) {
	738	ret = -ENODEV;
	739	goto err_unlock;
	740	}
	741
	742	ret = iio_channel_write(chan, val, 0, IIO_CHAN_INFO_RAW);
	743	err_unlock:
	744	mutex_unlock(&chan->indio_dev->info_exist_lock);
	745
	746	return ret;
	747	}
	748	EXPORT_SYMBOL_GPL(iio_write_channel_raw);