]>
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> | |
17d82b47 | 13 | #include <linux/of.h> |
e27d75d7 | 14 | |
06458e27 | 15 | #include <linux/iio/iio.h> |
e27d75d7 | 16 | #include "iio_core.h" |
06458e27 JC |
17 | #include <linux/iio/machine.h> |
18 | #include <linux/iio/driver.h> | |
19 | #include <linux/iio/consumer.h> | |
e27d75d7 JC |
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 | ||
6cb2afd7 GR |
58 | /* |
59 | * Remove all map entries associated with the given iio device | |
e27d75d7 | 60 | */ |
6cb2afd7 | 61 | int iio_map_array_unregister(struct iio_dev *indio_dev) |
e27d75d7 | 62 | { |
6cb2afd7 | 63 | int ret = -ENODEV; |
e27d75d7 | 64 | struct iio_map_internal *mapi; |
6cb2afd7 | 65 | struct list_head *pos, *tmp; |
e27d75d7 JC |
66 | |
67 | mutex_lock(&iio_map_list_lock); | |
6cb2afd7 GR |
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; | |
e27d75d7 JC |
74 | } |
75 | } | |
e27d75d7 | 76 | mutex_unlock(&iio_map_list_lock); |
e27d75d7 JC |
77 | return ret; |
78 | } | |
79 | EXPORT_SYMBOL_GPL(iio_map_array_unregister); | |
80 | ||
81 | static const struct iio_chan_spec | |
314be14b | 82 | *iio_chan_spec_from_name(const struct iio_dev *indio_dev, const char *name) |
e27d75d7 JC |
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 | ||
17d82b47 GR |
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) { | |
e916b80d | 127 | err = -EINVAL; |
17d82b47 GR |
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); | |
872687f6 | 181 | if (!IS_ERR(chan) || PTR_ERR(chan) == -EPROBE_DEFER) |
17d82b47 GR |
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); | |
a2c12493 | 186 | return NULL; |
17d82b47 GR |
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)) | |
a2c12493 | 196 | return NULL; |
17d82b47 | 197 | } |
a2c12493 | 198 | |
17d82b47 GR |
199 | return chan; |
200 | } | |
201 | ||
202 | static struct iio_channel *of_iio_channel_get_all(struct device *dev) | |
203 | { | |
204 | struct iio_channel *chans; | |
205 | int i, mapind, nummaps = 0; | |
206 | int ret; | |
207 | ||
208 | do { | |
209 | ret = of_parse_phandle_with_args(dev->of_node, | |
210 | "io-channels", | |
211 | "#io-channel-cells", | |
212 | nummaps, NULL); | |
213 | if (ret < 0) | |
214 | break; | |
215 | } while (++nummaps); | |
216 | ||
217 | if (nummaps == 0) /* no error, return NULL to search map table */ | |
218 | return NULL; | |
219 | ||
220 | /* NULL terminated array to save passing size */ | |
221 | chans = kcalloc(nummaps + 1, sizeof(*chans), GFP_KERNEL); | |
222 | if (chans == NULL) | |
223 | return ERR_PTR(-ENOMEM); | |
224 | ||
225 | /* Search for OF matches */ | |
226 | for (mapind = 0; mapind < nummaps; mapind++) { | |
227 | ret = __of_iio_channel_get(&chans[mapind], dev->of_node, | |
228 | mapind); | |
229 | if (ret) | |
230 | goto error_free_chans; | |
231 | } | |
232 | return chans; | |
233 | ||
234 | error_free_chans: | |
235 | for (i = 0; i < mapind; i++) | |
236 | iio_device_put(chans[i].indio_dev); | |
237 | kfree(chans); | |
238 | return ERR_PTR(ret); | |
239 | } | |
240 | ||
241 | #else /* CONFIG_OF */ | |
242 | ||
243 | static inline struct iio_channel * | |
244 | of_iio_channel_get_by_name(struct device_node *np, const char *name) | |
245 | { | |
246 | return NULL; | |
247 | } | |
248 | ||
249 | static inline struct iio_channel *of_iio_channel_get_all(struct device *dev) | |
250 | { | |
251 | return NULL; | |
252 | } | |
253 | ||
254 | #endif /* CONFIG_OF */ | |
e27d75d7 | 255 | |
5aa57f0a GR |
256 | static struct iio_channel *iio_channel_get_sys(const char *name, |
257 | const char *channel_name) | |
e27d75d7 JC |
258 | { |
259 | struct iio_map_internal *c_i = NULL, *c = NULL; | |
260 | struct iio_channel *channel; | |
3183bac1 | 261 | int err; |
e27d75d7 JC |
262 | |
263 | if (name == NULL && channel_name == NULL) | |
264 | return ERR_PTR(-ENODEV); | |
265 | ||
266 | /* first find matching entry the channel map */ | |
267 | mutex_lock(&iio_map_list_lock); | |
268 | list_for_each_entry(c_i, &iio_map_list, l) { | |
269 | if ((name && strcmp(name, c_i->map->consumer_dev_name) != 0) || | |
270 | (channel_name && | |
271 | strcmp(channel_name, c_i->map->consumer_channel) != 0)) | |
272 | continue; | |
273 | c = c_i; | |
1875ffd2 | 274 | iio_device_get(c->indio_dev); |
e27d75d7 JC |
275 | break; |
276 | } | |
277 | mutex_unlock(&iio_map_list_lock); | |
278 | if (c == NULL) | |
279 | return ERR_PTR(-ENODEV); | |
280 | ||
2cc412b5 | 281 | channel = kzalloc(sizeof(*channel), GFP_KERNEL); |
3183bac1 KM |
282 | if (channel == NULL) { |
283 | err = -ENOMEM; | |
801c4b5c | 284 | goto error_no_mem; |
3183bac1 | 285 | } |
e27d75d7 JC |
286 | |
287 | channel->indio_dev = c->indio_dev; | |
288 | ||
b2b79ffa | 289 | if (c->map->adc_channel_label) { |
e27d75d7 JC |
290 | channel->channel = |
291 | iio_chan_spec_from_name(channel->indio_dev, | |
292 | c->map->adc_channel_label); | |
293 | ||
3183bac1 KM |
294 | if (channel->channel == NULL) { |
295 | err = -EINVAL; | |
b2b79ffa | 296 | goto error_no_chan; |
3183bac1 | 297 | } |
b2b79ffa KM |
298 | } |
299 | ||
e27d75d7 | 300 | return channel; |
b2b79ffa KM |
301 | |
302 | error_no_chan: | |
b2b79ffa | 303 | kfree(channel); |
801c4b5c KM |
304 | error_no_mem: |
305 | iio_device_put(c->indio_dev); | |
3183bac1 | 306 | return ERR_PTR(err); |
e27d75d7 | 307 | } |
5aa57f0a GR |
308 | |
309 | struct iio_channel *iio_channel_get(struct device *dev, | |
310 | const char *channel_name) | |
311 | { | |
312 | const char *name = dev ? dev_name(dev) : NULL; | |
17d82b47 | 313 | struct iio_channel *channel; |
5aa57f0a | 314 | |
17d82b47 GR |
315 | if (dev) { |
316 | channel = of_iio_channel_get_by_name(dev->of_node, | |
317 | channel_name); | |
318 | if (channel != NULL) | |
319 | return channel; | |
320 | } | |
a2c12493 | 321 | |
5aa57f0a GR |
322 | return iio_channel_get_sys(name, channel_name); |
323 | } | |
314be14b | 324 | EXPORT_SYMBOL_GPL(iio_channel_get); |
e27d75d7 | 325 | |
314be14b | 326 | void iio_channel_release(struct iio_channel *channel) |
e27d75d7 | 327 | { |
1875ffd2 | 328 | iio_device_put(channel->indio_dev); |
e27d75d7 JC |
329 | kfree(channel); |
330 | } | |
314be14b | 331 | EXPORT_SYMBOL_GPL(iio_channel_release); |
e27d75d7 | 332 | |
ca7d98db | 333 | struct iio_channel *iio_channel_get_all(struct device *dev) |
e27d75d7 | 334 | { |
ca7d98db | 335 | const char *name; |
e27d75d7 JC |
336 | struct iio_channel *chans; |
337 | struct iio_map_internal *c = NULL; | |
338 | int nummaps = 0; | |
339 | int mapind = 0; | |
340 | int i, ret; | |
341 | ||
ca7d98db | 342 | if (dev == NULL) |
e27d75d7 | 343 | return ERR_PTR(-EINVAL); |
17d82b47 GR |
344 | |
345 | chans = of_iio_channel_get_all(dev); | |
346 | if (chans) | |
347 | return chans; | |
348 | ||
ca7d98db | 349 | name = dev_name(dev); |
e27d75d7 JC |
350 | |
351 | mutex_lock(&iio_map_list_lock); | |
352 | /* first count the matching maps */ | |
353 | list_for_each_entry(c, &iio_map_list, l) | |
354 | if (name && strcmp(name, c->map->consumer_dev_name) != 0) | |
355 | continue; | |
356 | else | |
357 | nummaps++; | |
358 | ||
359 | if (nummaps == 0) { | |
360 | ret = -ENODEV; | |
361 | goto error_ret; | |
362 | } | |
363 | ||
364 | /* NULL terminated array to save passing size */ | |
365 | chans = kzalloc(sizeof(*chans)*(nummaps + 1), GFP_KERNEL); | |
366 | if (chans == NULL) { | |
367 | ret = -ENOMEM; | |
368 | goto error_ret; | |
369 | } | |
370 | ||
371 | /* for each map fill in the chans element */ | |
372 | list_for_each_entry(c, &iio_map_list, l) { | |
373 | if (name && strcmp(name, c->map->consumer_dev_name) != 0) | |
374 | continue; | |
375 | chans[mapind].indio_dev = c->indio_dev; | |
0464415d | 376 | chans[mapind].data = c->map->consumer_data; |
e27d75d7 JC |
377 | chans[mapind].channel = |
378 | iio_chan_spec_from_name(chans[mapind].indio_dev, | |
379 | c->map->adc_channel_label); | |
380 | if (chans[mapind].channel == NULL) { | |
381 | ret = -EINVAL; | |
e27d75d7 JC |
382 | goto error_free_chans; |
383 | } | |
1875ffd2 | 384 | iio_device_get(chans[mapind].indio_dev); |
e27d75d7 JC |
385 | mapind++; |
386 | } | |
e27d75d7 JC |
387 | if (mapind == 0) { |
388 | ret = -ENODEV; | |
389 | goto error_free_chans; | |
390 | } | |
e59b9afe DC |
391 | mutex_unlock(&iio_map_list_lock); |
392 | ||
e27d75d7 JC |
393 | return chans; |
394 | ||
395 | error_free_chans: | |
396 | for (i = 0; i < nummaps; i++) | |
1875ffd2 | 397 | iio_device_put(chans[i].indio_dev); |
e27d75d7 JC |
398 | kfree(chans); |
399 | error_ret: | |
400 | mutex_unlock(&iio_map_list_lock); | |
401 | ||
402 | return ERR_PTR(ret); | |
403 | } | |
314be14b | 404 | EXPORT_SYMBOL_GPL(iio_channel_get_all); |
e27d75d7 | 405 | |
314be14b | 406 | void iio_channel_release_all(struct iio_channel *channels) |
e27d75d7 JC |
407 | { |
408 | struct iio_channel *chan = &channels[0]; | |
409 | ||
410 | while (chan->indio_dev) { | |
1875ffd2 | 411 | iio_device_put(chan->indio_dev); |
e27d75d7 JC |
412 | chan++; |
413 | } | |
414 | kfree(channels); | |
415 | } | |
314be14b | 416 | EXPORT_SYMBOL_GPL(iio_channel_release_all); |
e27d75d7 | 417 | |
48e44ce0 LPC |
418 | static int iio_channel_read(struct iio_channel *chan, int *val, int *val2, |
419 | enum iio_chan_info_enum info) | |
420 | { | |
421 | int unused; | |
9fbfb4b3 SP |
422 | int vals[INDIO_MAX_RAW_ELEMENTS]; |
423 | int ret; | |
424 | int val_len = 2; | |
48e44ce0 LPC |
425 | |
426 | if (val2 == NULL) | |
427 | val2 = &unused; | |
428 | ||
9fbfb4b3 SP |
429 | if (chan->indio_dev->info->read_raw_multi) { |
430 | ret = chan->indio_dev->info->read_raw_multi(chan->indio_dev, | |
431 | chan->channel, INDIO_MAX_RAW_ELEMENTS, | |
432 | vals, &val_len, info); | |
433 | *val = vals[0]; | |
434 | *val2 = vals[1]; | |
435 | } else | |
436 | ret = chan->indio_dev->info->read_raw(chan->indio_dev, | |
437 | chan->channel, val, val2, info); | |
438 | ||
439 | return ret; | |
48e44ce0 LPC |
440 | } |
441 | ||
314be14b | 442 | int iio_read_channel_raw(struct iio_channel *chan, int *val) |
e27d75d7 | 443 | { |
48e44ce0 | 444 | int ret; |
e27d75d7 JC |
445 | |
446 | mutex_lock(&chan->indio_dev->info_exist_lock); | |
447 | if (chan->indio_dev->info == NULL) { | |
448 | ret = -ENODEV; | |
449 | goto err_unlock; | |
450 | } | |
451 | ||
48e44ce0 | 452 | ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW); |
e27d75d7 JC |
453 | err_unlock: |
454 | mutex_unlock(&chan->indio_dev->info_exist_lock); | |
455 | ||
456 | return ret; | |
457 | } | |
314be14b | 458 | EXPORT_SYMBOL_GPL(iio_read_channel_raw); |
e27d75d7 | 459 | |
476d4af2 SR |
460 | int iio_read_channel_average_raw(struct iio_channel *chan, int *val) |
461 | { | |
462 | int ret; | |
463 | ||
464 | mutex_lock(&chan->indio_dev->info_exist_lock); | |
465 | if (chan->indio_dev->info == NULL) { | |
466 | ret = -ENODEV; | |
467 | goto err_unlock; | |
468 | } | |
469 | ||
470 | ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_AVERAGE_RAW); | |
471 | err_unlock: | |
472 | mutex_unlock(&chan->indio_dev->info_exist_lock); | |
473 | ||
474 | return ret; | |
475 | } | |
476 | EXPORT_SYMBOL_GPL(iio_read_channel_average_raw); | |
477 | ||
48e44ce0 LPC |
478 | static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan, |
479 | int raw, int *processed, unsigned int scale) | |
480 | { | |
481 | int scale_type, scale_val, scale_val2, offset; | |
482 | s64 raw64 = raw; | |
483 | int ret; | |
484 | ||
6c5d4c96 | 485 | ret = iio_channel_read(chan, &offset, NULL, IIO_CHAN_INFO_OFFSET); |
f91d1b63 | 486 | if (ret >= 0) |
48e44ce0 LPC |
487 | raw64 += offset; |
488 | ||
489 | scale_type = iio_channel_read(chan, &scale_val, &scale_val2, | |
490 | IIO_CHAN_INFO_SCALE); | |
491 | if (scale_type < 0) | |
492 | return scale_type; | |
493 | ||
494 | switch (scale_type) { | |
495 | case IIO_VAL_INT: | |
496 | *processed = raw64 * scale_val; | |
497 | break; | |
498 | case IIO_VAL_INT_PLUS_MICRO: | |
499 | if (scale_val2 < 0) | |
500 | *processed = -raw64 * scale_val; | |
501 | else | |
502 | *processed = raw64 * scale_val; | |
503 | *processed += div_s64(raw64 * (s64)scale_val2 * scale, | |
504 | 1000000LL); | |
505 | break; | |
506 | case IIO_VAL_INT_PLUS_NANO: | |
507 | if (scale_val2 < 0) | |
508 | *processed = -raw64 * scale_val; | |
509 | else | |
510 | *processed = raw64 * scale_val; | |
511 | *processed += div_s64(raw64 * (s64)scale_val2 * scale, | |
512 | 1000000000LL); | |
513 | break; | |
514 | case IIO_VAL_FRACTIONAL: | |
515 | *processed = div_s64(raw64 * (s64)scale_val * scale, | |
516 | scale_val2); | |
517 | break; | |
103d9fb9 LPC |
518 | case IIO_VAL_FRACTIONAL_LOG2: |
519 | *processed = (raw64 * (s64)scale_val * scale) >> scale_val2; | |
520 | break; | |
48e44ce0 LPC |
521 | default: |
522 | return -EINVAL; | |
523 | } | |
524 | ||
525 | return 0; | |
526 | } | |
527 | ||
528 | int iio_convert_raw_to_processed(struct iio_channel *chan, int raw, | |
529 | int *processed, unsigned int scale) | |
530 | { | |
531 | int ret; | |
532 | ||
533 | mutex_lock(&chan->indio_dev->info_exist_lock); | |
534 | if (chan->indio_dev->info == NULL) { | |
535 | ret = -ENODEV; | |
536 | goto err_unlock; | |
537 | } | |
538 | ||
539 | ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed, | |
540 | scale); | |
541 | err_unlock: | |
542 | mutex_unlock(&chan->indio_dev->info_exist_lock); | |
543 | ||
544 | return ret; | |
545 | } | |
546 | EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed); | |
547 | ||
548 | int iio_read_channel_processed(struct iio_channel *chan, int *val) | |
549 | { | |
550 | int ret; | |
551 | ||
552 | mutex_lock(&chan->indio_dev->info_exist_lock); | |
553 | if (chan->indio_dev->info == NULL) { | |
554 | ret = -ENODEV; | |
555 | goto err_unlock; | |
556 | } | |
557 | ||
558 | if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) { | |
559 | ret = iio_channel_read(chan, val, NULL, | |
560 | IIO_CHAN_INFO_PROCESSED); | |
561 | } else { | |
562 | ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW); | |
563 | if (ret < 0) | |
564 | goto err_unlock; | |
565 | ret = iio_convert_raw_to_processed_unlocked(chan, *val, val, 1); | |
566 | } | |
567 | ||
568 | err_unlock: | |
569 | mutex_unlock(&chan->indio_dev->info_exist_lock); | |
570 | ||
571 | return ret; | |
572 | } | |
573 | EXPORT_SYMBOL_GPL(iio_read_channel_processed); | |
574 | ||
314be14b | 575 | int iio_read_channel_scale(struct iio_channel *chan, int *val, int *val2) |
e27d75d7 JC |
576 | { |
577 | int ret; | |
578 | ||
579 | mutex_lock(&chan->indio_dev->info_exist_lock); | |
580 | if (chan->indio_dev->info == NULL) { | |
581 | ret = -ENODEV; | |
582 | goto err_unlock; | |
583 | } | |
584 | ||
48e44ce0 | 585 | ret = iio_channel_read(chan, val, val2, IIO_CHAN_INFO_SCALE); |
e27d75d7 JC |
586 | err_unlock: |
587 | mutex_unlock(&chan->indio_dev->info_exist_lock); | |
588 | ||
589 | return ret; | |
590 | } | |
314be14b | 591 | EXPORT_SYMBOL_GPL(iio_read_channel_scale); |
e27d75d7 | 592 | |
314be14b | 593 | int iio_get_channel_type(struct iio_channel *chan, enum iio_chan_type *type) |
e27d75d7 JC |
594 | { |
595 | int ret = 0; | |
596 | /* Need to verify underlying driver has not gone away */ | |
597 | ||
598 | mutex_lock(&chan->indio_dev->info_exist_lock); | |
599 | if (chan->indio_dev->info == NULL) { | |
600 | ret = -ENODEV; | |
601 | goto err_unlock; | |
602 | } | |
603 | ||
604 | *type = chan->channel->type; | |
605 | err_unlock: | |
606 | mutex_unlock(&chan->indio_dev->info_exist_lock); | |
607 | ||
608 | return ret; | |
609 | } | |
314be14b | 610 | EXPORT_SYMBOL_GPL(iio_get_channel_type); |