xref: /openbmc/linux/drivers/iio/inkern.c (revision d2999e1b)
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 	int vals[INDIO_MAX_RAW_ELEMENTS];
421 	int ret;
422 	int val_len = 2;
423 
424 	if (val2 == NULL)
425 		val2 = &unused;
426 
427 	if (chan->indio_dev->info->read_raw_multi) {
428 		ret = chan->indio_dev->info->read_raw_multi(chan->indio_dev,
429 					chan->channel, INDIO_MAX_RAW_ELEMENTS,
430 					vals, &val_len, info);
431 		*val = vals[0];
432 		*val2 = vals[1];
433 	} else
434 		ret = chan->indio_dev->info->read_raw(chan->indio_dev,
435 					chan->channel, val, val2, info);
436 
437 	return ret;
438 }
439 
440 int iio_read_channel_raw(struct iio_channel *chan, int *val)
441 {
442 	int ret;
443 
444 	mutex_lock(&chan->indio_dev->info_exist_lock);
445 	if (chan->indio_dev->info == NULL) {
446 		ret = -ENODEV;
447 		goto err_unlock;
448 	}
449 
450 	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
451 err_unlock:
452 	mutex_unlock(&chan->indio_dev->info_exist_lock);
453 
454 	return ret;
455 }
456 EXPORT_SYMBOL_GPL(iio_read_channel_raw);
457 
458 int iio_read_channel_average_raw(struct iio_channel *chan, int *val)
459 {
460 	int ret;
461 
462 	mutex_lock(&chan->indio_dev->info_exist_lock);
463 	if (chan->indio_dev->info == NULL) {
464 		ret = -ENODEV;
465 		goto err_unlock;
466 	}
467 
468 	ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_AVERAGE_RAW);
469 err_unlock:
470 	mutex_unlock(&chan->indio_dev->info_exist_lock);
471 
472 	return ret;
473 }
474 EXPORT_SYMBOL_GPL(iio_read_channel_average_raw);
475 
476 static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
477 	int raw, int *processed, unsigned int scale)
478 {
479 	int scale_type, scale_val, scale_val2, offset;
480 	s64 raw64 = raw;
481 	int ret;
482 
483 	ret = iio_channel_read(chan, &offset, NULL, IIO_CHAN_INFO_OFFSET);
484 	if (ret >= 0)
485 		raw64 += offset;
486 
487 	scale_type = iio_channel_read(chan, &scale_val, &scale_val2,
488 					IIO_CHAN_INFO_SCALE);
489 	if (scale_type < 0)
490 		return scale_type;
491 
492 	switch (scale_type) {
493 	case IIO_VAL_INT:
494 		*processed = raw64 * scale_val;
495 		break;
496 	case IIO_VAL_INT_PLUS_MICRO:
497 		if (scale_val2 < 0)
498 			*processed = -raw64 * scale_val;
499 		else
500 			*processed = raw64 * scale_val;
501 		*processed += div_s64(raw64 * (s64)scale_val2 * scale,
502 				      1000000LL);
503 		break;
504 	case IIO_VAL_INT_PLUS_NANO:
505 		if (scale_val2 < 0)
506 			*processed = -raw64 * scale_val;
507 		else
508 			*processed = raw64 * scale_val;
509 		*processed += div_s64(raw64 * (s64)scale_val2 * scale,
510 				      1000000000LL);
511 		break;
512 	case IIO_VAL_FRACTIONAL:
513 		*processed = div_s64(raw64 * (s64)scale_val * scale,
514 				     scale_val2);
515 		break;
516 	case IIO_VAL_FRACTIONAL_LOG2:
517 		*processed = (raw64 * (s64)scale_val * scale) >> scale_val2;
518 		break;
519 	default:
520 		return -EINVAL;
521 	}
522 
523 	return 0;
524 }
525 
526 int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
527 	int *processed, unsigned int scale)
528 {
529 	int ret;
530 
531 	mutex_lock(&chan->indio_dev->info_exist_lock);
532 	if (chan->indio_dev->info == NULL) {
533 		ret = -ENODEV;
534 		goto err_unlock;
535 	}
536 
537 	ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,
538 							scale);
539 err_unlock:
540 	mutex_unlock(&chan->indio_dev->info_exist_lock);
541 
542 	return ret;
543 }
544 EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
545 
546 int iio_read_channel_processed(struct iio_channel *chan, int *val)
547 {
548 	int ret;
549 
550 	mutex_lock(&chan->indio_dev->info_exist_lock);
551 	if (chan->indio_dev->info == NULL) {
552 		ret = -ENODEV;
553 		goto err_unlock;
554 	}
555 
556 	if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) {
557 		ret = iio_channel_read(chan, val, NULL,
558 				       IIO_CHAN_INFO_PROCESSED);
559 	} else {
560 		ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
561 		if (ret < 0)
562 			goto err_unlock;
563 		ret = iio_convert_raw_to_processed_unlocked(chan, *val, val, 1);
564 	}
565 
566 err_unlock:
567 	mutex_unlock(&chan->indio_dev->info_exist_lock);
568 
569 	return ret;
570 }
571 EXPORT_SYMBOL_GPL(iio_read_channel_processed);
572 
573 int iio_read_channel_scale(struct iio_channel *chan, int *val, int *val2)
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, val2, IIO_CHAN_INFO_SCALE);
584 err_unlock:
585 	mutex_unlock(&chan->indio_dev->info_exist_lock);
586 
587 	return ret;
588 }
589 EXPORT_SYMBOL_GPL(iio_read_channel_scale);
590 
591 int iio_get_channel_type(struct iio_channel *chan, enum iio_chan_type *type)
592 {
593 	int ret = 0;
594 	/* Need to verify underlying driver has not gone away */
595 
596 	mutex_lock(&chan->indio_dev->info_exist_lock);
597 	if (chan->indio_dev->info == NULL) {
598 		ret = -ENODEV;
599 		goto err_unlock;
600 	}
601 
602 	*type = chan->channel->type;
603 err_unlock:
604 	mutex_unlock(&chan->indio_dev->info_exist_lock);
605 
606 	return ret;
607 }
608 EXPORT_SYMBOL_GPL(iio_get_channel_type);
609