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


/* Assumes the exact same array (e.g. memory locations)
 * used at unregistration as used at registration rather than
 * more complex checking of contents.
 */
int iio_map_array_unregister(struct iio_dev *indio_dev,
			     struct iio_map *maps)
{
	int i = 0, ret = 0;
	bool found_it;
	struct iio_map_internal *mapi;

	if (maps == NULL)
		return 0;

	mutex_lock(&iio_map_list_lock);
	while (maps[i].consumer_dev_name != NULL) {
		found_it = false;
		list_for_each_entry(mapi, &iio_map_list, l)
			if (&maps[i] == mapi->map) {
				list_del(&mapi->l);
				kfree(mapi);
				found_it = true;
				break;
			}
		if (found_it == false) {
			ret = -ENODEV;
			goto error_ret;
		}
		i++;
	}
error_ret:
	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;
}


struct iio_channel *iio_channel_get(const char *name, const char *channel_name)
{
	struct iio_map_internal *c_i = NULL, *c = NULL;
	struct iio_channel *channel;

	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)
		return ERR_PTR(-ENOMEM);

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

	return channel;

error_no_chan:
	iio_device_put(c->indio_dev);
	kfree(channel);
	return ERR_PTR(-EINVAL);
}
EXPORT_SYMBOL_GPL(iio_channel_get);

void iio_channel_release(struct iio_channel *channel)
{
	iio_device_put(channel->indio_dev);
	kfree(channel);
}
EXPORT_SYMBOL_GPL(iio_channel_release);

struct iio_channel *iio_channel_get_all(const char *name)
{
	struct iio_channel *chans;
	struct iio_map_internal *c = NULL;
	int nummaps = 0;
	int mapind = 0;
	int i, ret;

	if (name == NULL)
		return ERR_PTR(-EINVAL);

	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].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 int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
	enum iio_chan_info_enum info)
{
	int unused;

	if (val2 == NULL)
		val2 = &unused;

	return chan->indio_dev->info->read_raw(chan->indio_dev, chan->channel,
						val, val2, info);
}

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

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_SCALE);
	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;
	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);
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>
	13
06458e27	14	#include <linux/iio/iio.h>
e27d75d7	15	#include "iio_core.h"
06458e27 JC	16	#include <linux/iio/machine.h>
	17	#include <linux/iio/driver.h>
	18	#include <linux/iio/consumer.h>
e27d75d7 JC	19
	20	struct iio_map_internal {
	21	struct iio_dev *indio_dev;
	22	struct iio_map *map;
	23	struct list_head l;
	24	};
	25
	26	static LIST_HEAD(iio_map_list);
	27	static DEFINE_MUTEX(iio_map_list_lock);
	28
	29	int iio_map_array_register(struct iio_dev indio_dev, struct iio_map maps)
	30	{
	31	int i = 0, ret = 0;
	32	struct iio_map_internal *mapi;
	33
	34	if (maps == NULL)
	35	return 0;
	36
	37	mutex_lock(&iio_map_list_lock);
	38	while (maps[i].consumer_dev_name != NULL) {
	39	mapi = kzalloc(sizeof(*mapi), GFP_KERNEL);
	40	if (mapi == NULL) {
	41	ret = -ENOMEM;
	42	goto error_ret;
	43	}
	44	mapi->map = &maps[i];
	45	mapi->indio_dev = indio_dev;
	46	list_add(&mapi->l, &iio_map_list);
	47	i++;
	48	}
	49	error_ret:
	50	mutex_unlock(&iio_map_list_lock);
	51
	52	return ret;
	53	}
	54	EXPORT_SYMBOL_GPL(iio_map_array_register);
	55
	56
	57	/* Assumes the exact same array (e.g. memory locations)
	58	* used at unregistration as used at registration rather than
	59	* more complex checking of contents.
	60	*/
	61	int iio_map_array_unregister(struct iio_dev *indio_dev,
	62	struct iio_map *maps)
	63	{
	64	int i = 0, ret = 0;
	65	bool found_it;
	66	struct iio_map_internal *mapi;
	67
	68	if (maps == NULL)
	69	return 0;
	70
	71	mutex_lock(&iio_map_list_lock);
	72	while (maps[i].consumer_dev_name != NULL) {
	73	found_it = false;
	74	list_for_each_entry(mapi, &iio_map_list, l)
	75	if (&maps[i] == mapi->map) {
	76	list_del(&mapi->l);
	77	kfree(mapi);
	78	found_it = true;
	79	break;
	80	}
	81	if (found_it == false) {
	82	ret = -ENODEV;
83	goto error_ret;
84	}
218f4d43	85	i++;
e27d75d7 JC	86	}
	87	error_ret:
	88	mutex_unlock(&iio_map_list_lock);
	89
	90	return ret;
	91	}
	92	EXPORT_SYMBOL_GPL(iio_map_array_unregister);
	93
	94	static const struct iio_chan_spec
314be14b	95	iio_chan_spec_from_name(const struct iio_dev indio_dev, const char *name)
e27d75d7 JC	96	{
	97	int i;
	98	const struct iio_chan_spec *chan = NULL;
	99
	100	for (i = 0; i < indio_dev->num_channels; i++)
	101	if (indio_dev->channels[i].datasheet_name &&
	102	strcmp(name, indio_dev->channels[i].datasheet_name) == 0) {
	103	chan = &indio_dev->channels[i];
	104	break;
	105	}
	106	return chan;
	107	}
	108
	109
314be14b	110	struct iio_channel iio_channel_get(const char name, const char *channel_name)
e27d75d7 JC	111	{
	112	struct iio_map_internal c_i = NULL, c = NULL;
	113	struct iio_channel *channel;
	114
	115	if (name == NULL && channel_name == NULL)
	116	return ERR_PTR(-ENODEV);
	117
	118	/* first find matching entry the channel map */
	119	mutex_lock(&iio_map_list_lock);
	120	list_for_each_entry(c_i, &iio_map_list, l) {
	121	if ((name && strcmp(name, c_i->map->consumer_dev_name) != 0) \|\|
	122	(channel_name &&
	123	strcmp(channel_name, c_i->map->consumer_channel) != 0))
	124	continue;
	125	c = c_i;
1875ffd2	126	iio_device_get(c->indio_dev);
e27d75d7 JC	127	break;
	128	}
	129	mutex_unlock(&iio_map_list_lock);
	130	if (c == NULL)
	131	return ERR_PTR(-ENODEV);
	132
2cc412b5	133	channel = kzalloc(sizeof(*channel), GFP_KERNEL);
e27d75d7 JC	134	if (channel == NULL)
	135	return ERR_PTR(-ENOMEM);
	136
	137	channel->indio_dev = c->indio_dev;
	138
b2b79ffa	139	if (c->map->adc_channel_label) {
e27d75d7 JC	140	channel->channel =
	141	iio_chan_spec_from_name(channel->indio_dev,
	142	c->map->adc_channel_label);
	143
b2b79ffa KM	144	if (channel->channel == NULL)
	145	goto error_no_chan;
	146	}
	147
e27d75d7	148	return channel;
b2b79ffa KM	149
	150	error_no_chan:
	151	iio_device_put(c->indio_dev);
	152	kfree(channel);
	153	return ERR_PTR(-EINVAL);
e27d75d7	154	}
314be14b	155	EXPORT_SYMBOL_GPL(iio_channel_get);
e27d75d7	156
314be14b	157	void iio_channel_release(struct iio_channel *channel)
e27d75d7	158	{
1875ffd2	159	iio_device_put(channel->indio_dev);
e27d75d7 JC	160	kfree(channel);
e27d75d7 JC	161	}
314be14b	162	EXPORT_SYMBOL_GPL(iio_channel_release);
e27d75d7	163
314be14b	164	struct iio_channel iio_channel_get_all(const char name)
e27d75d7 JC	165	{
	166	struct iio_channel *chans;
	167	struct iio_map_internal *c = NULL;
	168	int nummaps = 0;
	169	int mapind = 0;
	170	int i, ret;
	171
	172	if (name == NULL)
	173	return ERR_PTR(-EINVAL);
	174
	175	mutex_lock(&iio_map_list_lock);
	176	/* first count the matching maps */
	177	list_for_each_entry(c, &iio_map_list, l)
	178	if (name && strcmp(name, c->map->consumer_dev_name) != 0)
	179	continue;
	180	else
	181	nummaps++;
	182
	183	if (nummaps == 0) {
	184	ret = -ENODEV;
	185	goto error_ret;
	186	}
	187
	188	/* NULL terminated array to save passing size */
	189	chans = kzalloc(sizeof(chans)(nummaps + 1), GFP_KERNEL);
	190	if (chans == NULL) {
	191	ret = -ENOMEM;
	192	goto error_ret;
	193	}
	194
	195	/* for each map fill in the chans element */
	196	list_for_each_entry(c, &iio_map_list, l) {
	197	if (name && strcmp(name, c->map->consumer_dev_name) != 0)
	198	continue;
	199	chans[mapind].indio_dev = c->indio_dev;
	200	chans[mapind].channel =
	201	iio_chan_spec_from_name(chans[mapind].indio_dev,
	202	c->map->adc_channel_label);
	203	if (chans[mapind].channel == NULL) {
	204	ret = -EINVAL;
e27d75d7 JC	205	goto error_free_chans;
e27d75d7 JC	206	}
1875ffd2	207	iio_device_get(chans[mapind].indio_dev);
e27d75d7 JC	208	mapind++;
e27d75d7 JC	209	}
e27d75d7 JC	210	if (mapind == 0) {
	211	ret = -ENODEV;
	212	goto error_free_chans;
	213	}
e59b9afe DC	214	mutex_unlock(&iio_map_list_lock);
e59b9afe DC	215
e27d75d7 JC	216	return chans;
	217
	218	error_free_chans:
	219	for (i = 0; i < nummaps; i++)
1875ffd2	220	iio_device_put(chans[i].indio_dev);
e27d75d7 JC	221	kfree(chans);
	222	error_ret:
	223	mutex_unlock(&iio_map_list_lock);
	224
	225	return ERR_PTR(ret);
	226	}
314be14b	227	EXPORT_SYMBOL_GPL(iio_channel_get_all);
e27d75d7	228
314be14b	229	void iio_channel_release_all(struct iio_channel *channels)
e27d75d7 JC	230	{
	231	struct iio_channel *chan = &channels[0];
	232
	233	while (chan->indio_dev) {
1875ffd2	234	iio_device_put(chan->indio_dev);
e27d75d7 JC	235	chan++;
	236	}
	237	kfree(channels);
	238	}
314be14b	239	EXPORT_SYMBOL_GPL(iio_channel_release_all);
e27d75d7	240
48e44ce0 LPC	241	static int iio_channel_read(struct iio_channel chan, int val, int *val2,
	242	enum iio_chan_info_enum info)
	243	{
	244	int unused;
	245
	246	if (val2 == NULL)
	247	val2 = &unused;
	248
	249	return chan->indio_dev->info->read_raw(chan->indio_dev, chan->channel,
	250	val, val2, info);
	251	}
	252
314be14b	253	int iio_read_channel_raw(struct iio_channel chan, int val)
e27d75d7	254	{
48e44ce0	255	int ret;
e27d75d7 JC	256
	257	mutex_lock(&chan->indio_dev->info_exist_lock);
	258	if (chan->indio_dev->info == NULL) {
	259	ret = -ENODEV;
	260	goto err_unlock;
	261	}
	262
48e44ce0	263	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
e27d75d7 JC	264	err_unlock:
	265	mutex_unlock(&chan->indio_dev->info_exist_lock);
	266
	267	return ret;
	268	}
314be14b	269	EXPORT_SYMBOL_GPL(iio_read_channel_raw);
e27d75d7	270
48e44ce0 LPC	271	static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
	272	int raw, int *processed, unsigned int scale)
	273	{
	274	int scale_type, scale_val, scale_val2, offset;
	275	s64 raw64 = raw;
	276	int ret;
	277
	278	ret = iio_channel_read(chan, &offset, NULL, IIO_CHAN_INFO_SCALE);
	279	if (ret == 0)
	280	raw64 += offset;
	281
	282	scale_type = iio_channel_read(chan, &scale_val, &scale_val2,
	283	IIO_CHAN_INFO_SCALE);
	284	if (scale_type < 0)
	285	return scale_type;
	286
	287	switch (scale_type) {
	288	case IIO_VAL_INT:
	289	processed = raw64 scale_val;
	290	break;
	291	case IIO_VAL_INT_PLUS_MICRO:
	292	if (scale_val2 < 0)
	293	processed = -raw64 scale_val;
	294	else
	295	processed = raw64 scale_val;
	296	processed += div_s64(raw64 (s64)scale_val2 * scale,
	297	1000000LL);
	298	break;
	299	case IIO_VAL_INT_PLUS_NANO:
	300	if (scale_val2 < 0)
	301	processed = -raw64 scale_val;
	302	else
	303	processed = raw64 scale_val;
	304	processed += div_s64(raw64 (s64)scale_val2 * scale,
	305	1000000000LL);
	306	break;
	307	case IIO_VAL_FRACTIONAL:
	308	processed = div_s64(raw64 (s64)scale_val * scale,
	309	scale_val2);
	310	break;
	311	default:
	312	return -EINVAL;
	313	}
	314
	315	return 0;
	316	}
	317
	318	int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
	319	int *processed, unsigned int scale)
	320	{
	321	int ret;
	322
	323	mutex_lock(&chan->indio_dev->info_exist_lock);
	324	if (chan->indio_dev->info == NULL) {
	325	ret = -ENODEV;
	326	goto err_unlock;
	327	}
	328
	329	ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,
	330	scale);
	331	err_unlock:
	332	mutex_unlock(&chan->indio_dev->info_exist_lock);
	333
	334	return ret;
335	}
336	EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
337
338	int iio_read_channel_processed(struct iio_channel chan, int val)
339	{
340	int ret;
341
342	mutex_lock(&chan->indio_dev->info_exist_lock);
343	if (chan->indio_dev->info == NULL) {
344	ret = -ENODEV;
345	goto err_unlock;
346	}
347
348	if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) {
349	ret = iio_channel_read(chan, val, NULL,
350	IIO_CHAN_INFO_PROCESSED);
351	} else {
352	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
353	if (ret < 0)
354	goto err_unlock;
355	ret = iio_convert_raw_to_processed_unlocked(chan, *val, val, 1);
356	}
357
358	err_unlock:
359	mutex_unlock(&chan->indio_dev->info_exist_lock);
360
361	return ret;
362	}
363	EXPORT_SYMBOL_GPL(iio_read_channel_processed);
364
314be14b	365	int iio_read_channel_scale(struct iio_channel chan, int val, int *val2)
e27d75d7 JC	366	{
	367	int ret;
	368
	369	mutex_lock(&chan->indio_dev->info_exist_lock);
	370	if (chan->indio_dev->info == NULL) {
	371	ret = -ENODEV;
	372	goto err_unlock;
	373	}
	374
48e44ce0	375	ret = iio_channel_read(chan, val, val2, IIO_CHAN_INFO_SCALE);
e27d75d7 JC	376	err_unlock:
	377	mutex_unlock(&chan->indio_dev->info_exist_lock);
	378
	379	return ret;
	380	}
314be14b	381	EXPORT_SYMBOL_GPL(iio_read_channel_scale);
e27d75d7	382
314be14b	383	int iio_get_channel_type(struct iio_channel chan, enum iio_chan_type type)
e27d75d7 JC	384	{
	385	int ret = 0;
	386	/* Need to verify underlying driver has not gone away */
	387
	388	mutex_lock(&chan->indio_dev->info_exist_lock);
	389	if (chan->indio_dev->info == NULL) {
	390	ret = -ENODEV;
	391	goto err_unlock;
	392	}
	393
	394	*type = chan->channel->type;
	395	err_unlock:
	396	mutex_unlock(&chan->indio_dev->info_exist_lock);
	397
	398	return ret;
	399	}
314be14b	400	EXPORT_SYMBOL_GPL(iio_get_channel_type);