drivers/iio/inkern.c - kernel/msm-4.9 - Gitiles

 /* 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) {
 			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;
 	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);
 }
 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].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 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;
 	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);
	/* 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) {
	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;
	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);
	}
	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].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 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;
	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);