xref: /openbmc/linux/drivers/iio/inkern.c (revision e23feb16)
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 #include <linux/of.h>
14 
15 #include <linux/iio/iio.h>
16 #include "iio_core.h"
17 #include <linux/iio/machine.h>
18 #include <linux/iio/driver.h>
19 #include <linux/iio/consumer.h>
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 
58 /*
59  * Remove all map entries associated with the given iio device
60  */
61 int iio_map_array_unregister(struct iio_dev *indio_dev)
62 {
63 	int ret = -ENODEV;
64 	struct iio_map_internal *mapi;
65 	struct list_head *pos, *tmp;
66 
67 	mutex_lock(&iio_map_list_lock);
68 	list_for_each_safe(pos, tmp, &iio_map_list) {
69 		mapi = list_entry(pos, struct iio_map_internal, l);
70 		if (indio_dev == mapi->indio_dev) {
71 			list_del(&mapi->l);
72 			kfree(mapi);
73 			ret = 0;
74 		}
75 	}
76 	mutex_unlock(&iio_map_list_lock);
77 	return ret;
78 }
79 EXPORT_SYMBOL_GPL(iio_map_array_unregister);
80 
81 static const struct iio_chan_spec
82 *iio_chan_spec_from_name(const struct iio_dev *indio_dev, const char *name)
83 {
84 	int i;
85 	const struct iio_chan_spec *chan = NULL;
86 
87 	for (i = 0; i < indio_dev->num_channels; i++)
88 		if (indio_dev->channels[i].datasheet_name &&
89 		    strcmp(name, indio_dev->channels[i].datasheet_name) == 0) {
90 			chan = &indio_dev->channels[i];
91 			break;
92 		}
93 	return chan;
94 }
95 
96 #ifdef CONFIG_OF
97 
98 static int iio_dev_node_match(struct device *dev, void *data)
99 {
100 	return dev->of_node == data && dev->type == &iio_device_type;
101 }
102 
103 static int __of_iio_channel_get(struct iio_channel *channel,
104 				struct device_node *np, int index)
105 {
106 	struct device *idev;
107 	struct iio_dev *indio_dev;
108 	int err;
109 	struct of_phandle_args iiospec;
110 
111 	err = of_parse_phandle_with_args(np, "io-channels",
112 					 "#io-channel-cells",
113 					 index, &iiospec);
114 	if (err)
115 		return err;
116 
117 	idev = bus_find_device(&iio_bus_type, NULL, iiospec.np,
118 			       iio_dev_node_match);
119 	of_node_put(iiospec.np);
120 	if (idev == NULL)
121 		return -EPROBE_DEFER;
122 
123 	indio_dev = dev_to_iio_dev(idev);
124 	channel->indio_dev = indio_dev;
125 	index = iiospec.args_count ? iiospec.args[0] : 0;
126 	if (index >= indio_dev->num_channels) {
127 		err = -EINVAL;
128 		goto err_put;
129 	}
130 	channel->channel = &indio_dev->channels[index];
131 
132 	return 0;
133 
134 err_put:
135 	iio_device_put(indio_dev);
136 	return err;
137 }
138 
139 static struct iio_channel *of_iio_channel_get(struct device_node *np, int index)
140 {
141 	struct iio_channel *channel;
142 	int err;
143 
144 	if (index < 0)
145 		return ERR_PTR(-EINVAL);
146 
147 	channel = kzalloc(sizeof(*channel), GFP_KERNEL);
148 	if (channel == NULL)
149 		return ERR_PTR(-ENOMEM);
150 
151 	err = __of_iio_channel_get(channel, np, index);
152 	if (err)
153 		goto err_free_channel;
154 
155 	return channel;
156 
157 err_free_channel:
158 	kfree(channel);
159 	return ERR_PTR(err);
160 }
161 
162 static struct iio_channel *of_iio_channel_get_by_name(struct device_node *np,
163 						      const char *name)
164 {
165 	struct iio_channel *chan = NULL;
166 
167 	/* Walk up the tree of devices looking for a matching iio channel */
168 	while (np) {
169 		int index = 0;
170 
171 		/*
172 		 * For named iio channels, first look up the name in the
173 		 * "io-channel-names" property.  If it cannot be found, the
174 		 * index will be an error code, and of_iio_channel_get()
175 		 * will fail.
176 		 */
177 		if (name)
178 			index = of_property_match_string(np, "io-channel-names",
179 							 name);
180 		chan = of_iio_channel_get(np, index);
181 		if (!IS_ERR(chan))
182 			break;
183 		else if (name && index >= 0) {
184 			pr_err("ERROR: could not get IIO channel %s:%s(%i)\n",
185 				np->full_name, name ? name : "", index);
186 			return chan;
187 		}
188 
189 		/*
190 		 * No matching IIO channel found on this node.
191 		 * If the parent node has a "io-channel-ranges" property,
192 		 * then we can try one of its channels.
193 		 */
194 		np = np->parent;
195 		if (np && !of_get_property(np, "io-channel-ranges", NULL))
196 			break;
197 	}
198 	return chan;
199 }
200 
201 static struct iio_channel *of_iio_channel_get_all(struct device *dev)
202 {
203 	struct iio_channel *chans;
204 	int i, mapind, nummaps = 0;
205 	int ret;
206 
207 	do {
208 		ret = of_parse_phandle_with_args(dev->of_node,
209 						 "io-channels",
210 						 "#io-channel-cells",
211 						 nummaps, NULL);
212 		if (ret < 0)
213 			break;
214 	} while (++nummaps);
215 
216 	if (nummaps == 0)	/* no error, return NULL to search map table */
217 		return NULL;
218 
219 	/* NULL terminated array to save passing size */
220 	chans = kcalloc(nummaps + 1, sizeof(*chans), GFP_KERNEL);
221 	if (chans == NULL)
222 		return ERR_PTR(-ENOMEM);
223 
224 	/* Search for OF matches */
225 	for (mapind = 0; mapind < nummaps; mapind++) {
226 		ret = __of_iio_channel_get(&chans[mapind], dev->of_node,
227 					   mapind);
228 		if (ret)
229 			goto error_free_chans;
230 	}
231 	return chans;
232 
233 error_free_chans:
234 	for (i = 0; i < mapind; i++)
235 		iio_device_put(chans[i].indio_dev);
236 	kfree(chans);
237 	return ERR_PTR(ret);
238 }
239 
240 #else /* CONFIG_OF */
241 
242 static inline struct iio_channel *
243 of_iio_channel_get_by_name(struct device_node *np, const char *name)
244 {
245 	return NULL;
246 }
247 
248 static inline struct iio_channel *of_iio_channel_get_all(struct device *dev)
249 {
250 	return NULL;
251 }
252 
253 #endif /* CONFIG_OF */
254 
255 static struct iio_channel *iio_channel_get_sys(const char *name,
256 					       const char *channel_name)
257 {
258 	struct iio_map_internal *c_i = NULL, *c = NULL;
259 	struct iio_channel *channel;
260 	int err;
261 
262 	if (name == NULL && channel_name == NULL)
263 		return ERR_PTR(-ENODEV);
264 
265 	/* first find matching entry the channel map */
266 	mutex_lock(&iio_map_list_lock);
267 	list_for_each_entry(c_i, &iio_map_list, l) {
268 		if ((name && strcmp(name, c_i->map->consumer_dev_name) != 0) ||
269 		    (channel_name &&
270 		     strcmp(channel_name, c_i->map->consumer_channel) != 0))
271 			continue;
272 		c = c_i;
273 		iio_device_get(c->indio_dev);
274 		break;
275 	}
276 	mutex_unlock(&iio_map_list_lock);
277 	if (c == NULL)
278 		return ERR_PTR(-ENODEV);
279 
280 	channel = kzalloc(sizeof(*channel), GFP_KERNEL);
281 	if (channel == NULL) {
282 		err = -ENOMEM;
283 		goto error_no_mem;
284 	}
285 
286 	channel->indio_dev = c->indio_dev;
287 
288 	if (c->map->adc_channel_label) {
289 		channel->channel =
290 			iio_chan_spec_from_name(channel->indio_dev,
291 						c->map->adc_channel_label);
292 
293 		if (channel->channel == NULL) {
294 			err = -EINVAL;
295 			goto error_no_chan;
296 		}
297 	}
298 
299 	return channel;
300 
301 error_no_chan:
302 	kfree(channel);
303 error_no_mem:
304 	iio_device_put(c->indio_dev);
305 	return ERR_PTR(err);
306 }
307 
308 struct iio_channel *iio_channel_get(struct device *dev,
309 				    const char *channel_name)
310 {
311 	const char *name = dev ? dev_name(dev) : NULL;
312 	struct iio_channel *channel;
313 
314 	if (dev) {
315 		channel = of_iio_channel_get_by_name(dev->of_node,
316 						     channel_name);
317 		if (channel != NULL)
318 			return channel;
319 	}
320 	return iio_channel_get_sys(name, channel_name);
321 }
322 EXPORT_SYMBOL_GPL(iio_channel_get);
323 
324 void iio_channel_release(struct iio_channel *channel)
325 {
326 	iio_device_put(channel->indio_dev);
327 	kfree(channel);
328 }
329 EXPORT_SYMBOL_GPL(iio_channel_release);
330 
331 struct iio_channel *iio_channel_get_all(struct device *dev)
332 {
333 	const char *name;
334 	struct iio_channel *chans;
335 	struct iio_map_internal *c = NULL;
336 	int nummaps = 0;
337 	int mapind = 0;
338 	int i, ret;
339 
340 	if (dev == NULL)
341 		return ERR_PTR(-EINVAL);
342 
343 	chans = of_iio_channel_get_all(dev);
344 	if (chans)
345 		return chans;
346 
347 	name = dev_name(dev);
348 
349 	mutex_lock(&iio_map_list_lock);
350 	/* first count the matching maps */
351 	list_for_each_entry(c, &iio_map_list, l)
352 		if (name && strcmp(name, c->map->consumer_dev_name) != 0)
353 			continue;
354 		else
355 			nummaps++;
356 
357 	if (nummaps == 0) {
358 		ret = -ENODEV;
359 		goto error_ret;
360 	}
361 
362 	/* NULL terminated array to save passing size */
363 	chans = kzalloc(sizeof(*chans)*(nummaps + 1), GFP_KERNEL);
364 	if (chans == NULL) {
365 		ret = -ENOMEM;
366 		goto error_ret;
367 	}
368 
369 	/* for each map fill in the chans element */
370 	list_for_each_entry(c, &iio_map_list, l) {
371 		if (name && strcmp(name, c->map->consumer_dev_name) != 0)
372 			continue;
373 		chans[mapind].indio_dev = c->indio_dev;
374 		chans[mapind].data = c->map->consumer_data;
375 		chans[mapind].channel =
376 			iio_chan_spec_from_name(chans[mapind].indio_dev,
377 						c->map->adc_channel_label);
378 		if (chans[mapind].channel == NULL) {
379 			ret = -EINVAL;
380 			goto error_free_chans;
381 		}
382 		iio_device_get(chans[mapind].indio_dev);
383 		mapind++;
384 	}
385 	if (mapind == 0) {
386 		ret = -ENODEV;
387 		goto error_free_chans;
388 	}
389 	mutex_unlock(&iio_map_list_lock);
390 
391 	return chans;
392 
393 error_free_chans:
394 	for (i = 0; i < nummaps; i++)
395 		iio_device_put(chans[i].indio_dev);
396 	kfree(chans);
397 error_ret:
398 	mutex_unlock(&iio_map_list_lock);
399 
400 	return ERR_PTR(ret);
401 }
402 EXPORT_SYMBOL_GPL(iio_channel_get_all);
403 
404 void iio_channel_release_all(struct iio_channel *channels)
405 {
406 	struct iio_channel *chan = &channels[0];
407 
408 	while (chan->indio_dev) {
409 		iio_device_put(chan->indio_dev);
410 		chan++;
411 	}
412 	kfree(channels);
413 }
414 EXPORT_SYMBOL_GPL(iio_channel_release_all);
415 
416 static int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
417 	enum iio_chan_info_enum info)
418 {
419 	int unused;
420 
421 	if (val2 == NULL)
422 		val2 = &unused;
423 
424 	return chan->indio_dev->info->read_raw(chan->indio_dev, chan->channel,
425 						val, val2, info);
426 }
427 
428 int iio_read_channel_raw(struct iio_channel *chan, int *val)
429 {
430 	int ret;
431 
432 	mutex_lock(&chan->indio_dev->info_exist_lock);
433 	if (chan->indio_dev->info == NULL) {
434 		ret = -ENODEV;
435 		goto err_unlock;
436 	}
437 
438 	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
439 err_unlock:
440 	mutex_unlock(&chan->indio_dev->info_exist_lock);
441 
442 	return ret;
443 }
444 EXPORT_SYMBOL_GPL(iio_read_channel_raw);
445 
446 static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
447 	int raw, int *processed, unsigned int scale)
448 {
449 	int scale_type, scale_val, scale_val2, offset;
450 	s64 raw64 = raw;
451 	int ret;
452 
453 	ret = iio_channel_read(chan, &offset, NULL, IIO_CHAN_INFO_OFFSET);
454 	if (ret >= 0)
455 		raw64 += offset;
456 
457 	scale_type = iio_channel_read(chan, &scale_val, &scale_val2,
458 					IIO_CHAN_INFO_SCALE);
459 	if (scale_type < 0)
460 		return scale_type;
461 
462 	switch (scale_type) {
463 	case IIO_VAL_INT:
464 		*processed = raw64 * scale_val;
465 		break;
466 	case IIO_VAL_INT_PLUS_MICRO:
467 		if (scale_val2 < 0)
468 			*processed = -raw64 * scale_val;
469 		else
470 			*processed = raw64 * scale_val;
471 		*processed += div_s64(raw64 * (s64)scale_val2 * scale,
472 				      1000000LL);
473 		break;
474 	case IIO_VAL_INT_PLUS_NANO:
475 		if (scale_val2 < 0)
476 			*processed = -raw64 * scale_val;
477 		else
478 			*processed = raw64 * scale_val;
479 		*processed += div_s64(raw64 * (s64)scale_val2 * scale,
480 				      1000000000LL);
481 		break;
482 	case IIO_VAL_FRACTIONAL:
483 		*processed = div_s64(raw64 * (s64)scale_val * scale,
484 				     scale_val2);
485 		break;
486 	case IIO_VAL_FRACTIONAL_LOG2:
487 		*processed = (raw64 * (s64)scale_val * scale) >> scale_val2;
488 		break;
489 	default:
490 		return -EINVAL;
491 	}
492 
493 	return 0;
494 }
495 
496 int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
497 	int *processed, unsigned int scale)
498 {
499 	int ret;
500 
501 	mutex_lock(&chan->indio_dev->info_exist_lock);
502 	if (chan->indio_dev->info == NULL) {
503 		ret = -ENODEV;
504 		goto err_unlock;
505 	}
506 
507 	ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,
508 							scale);
509 err_unlock:
510 	mutex_unlock(&chan->indio_dev->info_exist_lock);
511 
512 	return ret;
513 }
514 EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
515 
516 int iio_read_channel_processed(struct iio_channel *chan, int *val)
517 {
518 	int ret;
519 
520 	mutex_lock(&chan->indio_dev->info_exist_lock);
521 	if (chan->indio_dev->info == NULL) {
522 		ret = -ENODEV;
523 		goto err_unlock;
524 	}
525 
526 	if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) {
527 		ret = iio_channel_read(chan, val, NULL,
528 				       IIO_CHAN_INFO_PROCESSED);
529 	} else {
530 		ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
531 		if (ret < 0)
532 			goto err_unlock;
533 		ret = iio_convert_raw_to_processed_unlocked(chan, *val, val, 1);
534 	}
535 
536 err_unlock:
537 	mutex_unlock(&chan->indio_dev->info_exist_lock);
538 
539 	return ret;
540 }
541 EXPORT_SYMBOL_GPL(iio_read_channel_processed);
542 
543 int iio_read_channel_scale(struct iio_channel *chan, int *val, int *val2)
544 {
545 	int ret;
546 
547 	mutex_lock(&chan->indio_dev->info_exist_lock);
548 	if (chan->indio_dev->info == NULL) {
549 		ret = -ENODEV;
550 		goto err_unlock;
551 	}
552 
553 	ret = iio_channel_read(chan, val, val2, IIO_CHAN_INFO_SCALE);
554 err_unlock:
555 	mutex_unlock(&chan->indio_dev->info_exist_lock);
556 
557 	return ret;
558 }
559 EXPORT_SYMBOL_GPL(iio_read_channel_scale);
560 
561 int iio_get_channel_type(struct iio_channel *chan, enum iio_chan_type *type)
562 {
563 	int ret = 0;
564 	/* Need to verify underlying driver has not gone away */
565 
566 	mutex_lock(&chan->indio_dev->info_exist_lock);
567 	if (chan->indio_dev->info == NULL) {
568 		ret = -ENODEV;
569 		goto err_unlock;
570 	}
571 
572 	*type = chan->channel->type;
573 err_unlock:
574 	mutex_unlock(&chan->indio_dev->info_exist_lock);
575 
576 	return ret;
577 }
578 EXPORT_SYMBOL_GPL(iio_get_channel_type);
579