1 /* The industrial I/O core in kernel channel mapping
3 * Copyright (c) 2011 Jonathan Cameron
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.
10 #include <linux/export.h>
11 #include <linux/slab.h>
12 #include <linux/mutex.h>
14 #include <linux/iio/iio.h>
16 #include <linux/iio/machine.h>
17 #include <linux/iio/driver.h>
18 #include <linux/iio/consumer.h>
20 struct iio_map_internal {
21 struct iio_dev *indio_dev;
26 static LIST_HEAD(iio_map_list);
27 static DEFINE_MUTEX(iio_map_list_lock);
29 int iio_map_array_register(struct iio_dev *indio_dev, struct iio_map *maps)
32 struct iio_map_internal *mapi;
37 mutex_lock(&iio_map_list_lock);
38 while (maps[i].consumer_dev_name != NULL) {
39 mapi = kzalloc(sizeof(*mapi), GFP_KERNEL);
45 mapi->indio_dev = indio_dev;
46 list_add(&mapi->l, &iio_map_list);
50 mutex_unlock(&iio_map_list_lock);
54 EXPORT_SYMBOL_GPL(iio_map_array_register);
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.
61 int iio_map_array_unregister(struct iio_dev *indio_dev,
66 struct iio_map_internal *mapi;
71 mutex_lock(&iio_map_list_lock);
72 while (maps[i].consumer_dev_name != NULL) {
74 list_for_each_entry(mapi, &iio_map_list, l)
75 if (&maps[i] == mapi->map) {
88 mutex_unlock(&iio_map_list_lock);
92 EXPORT_SYMBOL_GPL(iio_map_array_unregister);
94 static const struct iio_chan_spec
95 *iio_chan_spec_from_name(const struct iio_dev *indio_dev, const char *name)
98 const struct iio_chan_spec *chan = NULL;
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];
110 struct iio_channel *iio_channel_get(const char *name, const char *channel_name)
112 struct iio_map_internal *c_i = NULL, *c = NULL;
113 struct iio_channel *channel;
116 if (name == NULL && channel_name == NULL)
117 return ERR_PTR(-ENODEV);
119 /* first find matching entry the channel map */
120 mutex_lock(&iio_map_list_lock);
121 list_for_each_entry(c_i, &iio_map_list, l) {
122 if ((name && strcmp(name, c_i->map->consumer_dev_name) != 0) ||
124 strcmp(channel_name, c_i->map->consumer_channel) != 0))
127 iio_device_get(c->indio_dev);
130 mutex_unlock(&iio_map_list_lock);
132 return ERR_PTR(-ENODEV);
134 channel = kzalloc(sizeof(*channel), GFP_KERNEL);
135 if (channel == NULL) {
140 channel->indio_dev = c->indio_dev;
142 if (c->map->adc_channel_label) {
144 iio_chan_spec_from_name(channel->indio_dev,
145 c->map->adc_channel_label);
147 if (channel->channel == NULL) {
158 iio_device_put(c->indio_dev);
161 EXPORT_SYMBOL_GPL(iio_channel_get);
163 void iio_channel_release(struct iio_channel *channel)
165 iio_device_put(channel->indio_dev);
168 EXPORT_SYMBOL_GPL(iio_channel_release);
170 struct iio_channel *iio_channel_get_all(const char *name)
172 struct iio_channel *chans;
173 struct iio_map_internal *c = NULL;
179 return ERR_PTR(-EINVAL);
181 mutex_lock(&iio_map_list_lock);
182 /* first count the matching maps */
183 list_for_each_entry(c, &iio_map_list, l)
184 if (name && strcmp(name, c->map->consumer_dev_name) != 0)
194 /* NULL terminated array to save passing size */
195 chans = kzalloc(sizeof(*chans)*(nummaps + 1), GFP_KERNEL);
201 /* for each map fill in the chans element */
202 list_for_each_entry(c, &iio_map_list, l) {
203 if (name && strcmp(name, c->map->consumer_dev_name) != 0)
205 chans[mapind].indio_dev = c->indio_dev;
206 chans[mapind].data = c->map->consumer_data;
207 chans[mapind].channel =
208 iio_chan_spec_from_name(chans[mapind].indio_dev,
209 c->map->adc_channel_label);
210 if (chans[mapind].channel == NULL) {
212 goto error_free_chans;
214 iio_device_get(chans[mapind].indio_dev);
219 goto error_free_chans;
221 mutex_unlock(&iio_map_list_lock);
226 for (i = 0; i < nummaps; i++)
227 iio_device_put(chans[i].indio_dev);
230 mutex_unlock(&iio_map_list_lock);
234 EXPORT_SYMBOL_GPL(iio_channel_get_all);
236 void iio_channel_release_all(struct iio_channel *channels)
238 struct iio_channel *chan = &channels[0];
240 while (chan->indio_dev) {
241 iio_device_put(chan->indio_dev);
246 EXPORT_SYMBOL_GPL(iio_channel_release_all);
248 static int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
249 enum iio_chan_info_enum info)
256 return chan->indio_dev->info->read_raw(chan->indio_dev, chan->channel,
260 int iio_read_channel_raw(struct iio_channel *chan, int *val)
264 mutex_lock(&chan->indio_dev->info_exist_lock);
265 if (chan->indio_dev->info == NULL) {
270 ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
272 mutex_unlock(&chan->indio_dev->info_exist_lock);
276 EXPORT_SYMBOL_GPL(iio_read_channel_raw);
278 static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
279 int raw, int *processed, unsigned int scale)
281 int scale_type, scale_val, scale_val2, offset;
285 ret = iio_channel_read(chan, &offset, NULL, IIO_CHAN_INFO_SCALE);
289 scale_type = iio_channel_read(chan, &scale_val, &scale_val2,
290 IIO_CHAN_INFO_SCALE);
294 switch (scale_type) {
296 *processed = raw64 * scale_val;
298 case IIO_VAL_INT_PLUS_MICRO:
300 *processed = -raw64 * scale_val;
302 *processed = raw64 * scale_val;
303 *processed += div_s64(raw64 * (s64)scale_val2 * scale,
306 case IIO_VAL_INT_PLUS_NANO:
308 *processed = -raw64 * scale_val;
310 *processed = raw64 * scale_val;
311 *processed += div_s64(raw64 * (s64)scale_val2 * scale,
314 case IIO_VAL_FRACTIONAL:
315 *processed = div_s64(raw64 * (s64)scale_val * scale,
318 case IIO_VAL_FRACTIONAL_LOG2:
319 *processed = (raw64 * (s64)scale_val * scale) >> scale_val2;
328 int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
329 int *processed, unsigned int scale)
333 mutex_lock(&chan->indio_dev->info_exist_lock);
334 if (chan->indio_dev->info == NULL) {
339 ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,
342 mutex_unlock(&chan->indio_dev->info_exist_lock);
346 EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
348 int iio_read_channel_processed(struct iio_channel *chan, int *val)
352 mutex_lock(&chan->indio_dev->info_exist_lock);
353 if (chan->indio_dev->info == NULL) {
358 if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) {
359 ret = iio_channel_read(chan, val, NULL,
360 IIO_CHAN_INFO_PROCESSED);
362 ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
365 ret = iio_convert_raw_to_processed_unlocked(chan, *val, val, 1);
369 mutex_unlock(&chan->indio_dev->info_exist_lock);
373 EXPORT_SYMBOL_GPL(iio_read_channel_processed);
375 int iio_read_channel_scale(struct iio_channel *chan, int *val, int *val2)
379 mutex_lock(&chan->indio_dev->info_exist_lock);
380 if (chan->indio_dev->info == NULL) {
385 ret = iio_channel_read(chan, val, val2, IIO_CHAN_INFO_SCALE);
387 mutex_unlock(&chan->indio_dev->info_exist_lock);
391 EXPORT_SYMBOL_GPL(iio_read_channel_scale);
393 int iio_get_channel_type(struct iio_channel *chan, enum iio_chan_type *type)
396 /* Need to verify underlying driver has not gone away */
398 mutex_lock(&chan->indio_dev->info_exist_lock);
399 if (chan->indio_dev->info == NULL) {
404 *type = chan->channel->type;
406 mutex_unlock(&chan->indio_dev->info_exist_lock);
410 EXPORT_SYMBOL_GPL(iio_get_channel_type);