1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (c) 2011 Jonathan Cameron |
4 | * |
5 | * A reference industrial I/O driver to illustrate the functionality available. |
6 | * |
7 | * There are numerous real drivers to illustrate the finer points. |
8 | * The purpose of this driver is to provide a driver with far more comments |
9 | * and explanatory notes than any 'real' driver would have. |
10 | * Anyone starting out writing an IIO driver should first make sure they |
11 | * understand all of this driver except those bits specifically marked |
12 | * as being present to allow us to 'fake' the presence of hardware. |
13 | */ |
14 | #include <linux/kernel.h> |
15 | #include <linux/slab.h> |
16 | #include <linux/module.h> |
17 | #include <linux/string.h> |
18 | |
19 | #include <linux/iio/iio.h> |
20 | #include <linux/iio/sysfs.h> |
21 | #include <linux/iio/events.h> |
22 | #include <linux/iio/buffer.h> |
23 | #include <linux/iio/sw_device.h> |
24 | #include "iio_simple_dummy.h" |
25 | |
26 | static const struct config_item_type iio_dummy_type = { |
27 | .ct_owner = THIS_MODULE, |
28 | }; |
29 | |
30 | /** |
31 | * struct iio_dummy_accel_calibscale - realworld to register mapping |
32 | * @val: first value in read_raw - here integer part. |
33 | * @val2: second value in read_raw etc - here micro part. |
34 | * @regval: register value - magic device specific numbers. |
35 | */ |
36 | struct iio_dummy_accel_calibscale { |
37 | int val; |
38 | int val2; |
39 | int regval; /* what would be written to hardware */ |
40 | }; |
41 | |
42 | static const struct iio_dummy_accel_calibscale dummy_scales[] = { |
43 | { 0, 100, 0x8 }, /* 0.000100 */ |
44 | { 0, 133, 0x7 }, /* 0.000133 */ |
45 | { 733, 13, 0x9 }, /* 733.000013 */ |
46 | }; |
47 | |
48 | #ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS |
49 | |
50 | /* |
51 | * simple event - triggered when value rises above |
52 | * a threshold |
53 | */ |
54 | static const struct iio_event_spec iio_dummy_event = { |
55 | .type = IIO_EV_TYPE_THRESH, |
56 | .dir = IIO_EV_DIR_RISING, |
57 | .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE), |
58 | }; |
59 | |
60 | /* |
61 | * simple step detect event - triggered when a step is detected |
62 | */ |
63 | static const struct iio_event_spec step_detect_event = { |
64 | .type = IIO_EV_TYPE_CHANGE, |
65 | .dir = IIO_EV_DIR_NONE, |
66 | .mask_separate = BIT(IIO_EV_INFO_ENABLE), |
67 | }; |
68 | |
69 | /* |
70 | * simple transition event - triggered when the reported running confidence |
71 | * value rises above a threshold value |
72 | */ |
73 | static const struct iio_event_spec iio_running_event = { |
74 | .type = IIO_EV_TYPE_THRESH, |
75 | .dir = IIO_EV_DIR_RISING, |
76 | .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE), |
77 | }; |
78 | |
79 | /* |
80 | * simple transition event - triggered when the reported walking confidence |
81 | * value falls under a threshold value |
82 | */ |
83 | static const struct iio_event_spec iio_walking_event = { |
84 | .type = IIO_EV_TYPE_THRESH, |
85 | .dir = IIO_EV_DIR_FALLING, |
86 | .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE), |
87 | }; |
88 | #endif |
89 | |
90 | /* |
91 | * iio_dummy_channels - Description of available channels |
92 | * |
93 | * This array of structures tells the IIO core about what the device |
94 | * actually provides for a given channel. |
95 | */ |
96 | static const struct iio_chan_spec iio_dummy_channels[] = { |
97 | /* indexed ADC channel in_voltage0_raw etc */ |
98 | { |
99 | .type = IIO_VOLTAGE, |
100 | /* Channel has a numeric index of 0 */ |
101 | .indexed = 1, |
102 | .channel = 0, |
103 | /* What other information is available? */ |
104 | .info_mask_separate = |
105 | /* |
106 | * in_voltage0_raw |
107 | * Raw (unscaled no bias removal etc) measurement |
108 | * from the device. |
109 | */ |
110 | BIT(IIO_CHAN_INFO_RAW) | |
111 | /* |
112 | * in_voltage0_offset |
113 | * Offset for userspace to apply prior to scale |
114 | * when converting to standard units (microvolts) |
115 | */ |
116 | BIT(IIO_CHAN_INFO_OFFSET) | |
117 | /* |
118 | * in_voltage0_scale |
119 | * Multipler for userspace to apply post offset |
120 | * when converting to standard units (microvolts) |
121 | */ |
122 | BIT(IIO_CHAN_INFO_SCALE), |
123 | /* |
124 | * sampling_frequency |
125 | * The frequency in Hz at which the channels are sampled |
126 | */ |
127 | .info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ), |
128 | /* The ordering of elements in the buffer via an enum */ |
129 | .scan_index = DUMMY_INDEX_VOLTAGE_0, |
130 | .scan_type = { /* Description of storage in buffer */ |
131 | .sign = 'u', /* unsigned */ |
132 | .realbits = 13, /* 13 bits */ |
133 | .storagebits = 16, /* 16 bits used for storage */ |
134 | .shift = 0, /* zero shift */ |
135 | }, |
136 | #ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS |
137 | .event_spec = &iio_dummy_event, |
138 | .num_event_specs = 1, |
139 | #endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */ |
140 | }, |
141 | /* Differential ADC channel in_voltage1-voltage2_raw etc*/ |
142 | { |
143 | .type = IIO_VOLTAGE, |
144 | .differential = 1, |
145 | /* |
146 | * Indexing for differential channels uses channel |
147 | * for the positive part, channel2 for the negative. |
148 | */ |
149 | .indexed = 1, |
150 | .channel = 1, |
151 | .channel2 = 2, |
152 | /* |
153 | * in_voltage1-voltage2_raw |
154 | * Raw (unscaled no bias removal etc) measurement |
155 | * from the device. |
156 | */ |
157 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
158 | /* |
159 | * in_voltage-voltage_scale |
160 | * Shared version of scale - shared by differential |
161 | * input channels of type IIO_VOLTAGE. |
162 | */ |
163 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), |
164 | /* |
165 | * sampling_frequency |
166 | * The frequency in Hz at which the channels are sampled |
167 | */ |
168 | .scan_index = DUMMY_INDEX_DIFFVOLTAGE_1M2, |
169 | .scan_type = { /* Description of storage in buffer */ |
170 | .sign = 's', /* signed */ |
171 | .realbits = 12, /* 12 bits */ |
172 | .storagebits = 16, /* 16 bits used for storage */ |
173 | .shift = 0, /* zero shift */ |
174 | }, |
175 | }, |
176 | /* Differential ADC channel in_voltage3-voltage4_raw etc*/ |
177 | { |
178 | .type = IIO_VOLTAGE, |
179 | .differential = 1, |
180 | .indexed = 1, |
181 | .channel = 3, |
182 | .channel2 = 4, |
183 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
184 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), |
185 | .info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ), |
186 | .scan_index = DUMMY_INDEX_DIFFVOLTAGE_3M4, |
187 | .scan_type = { |
188 | .sign = 's', |
189 | .realbits = 11, |
190 | .storagebits = 16, |
191 | .shift = 0, |
192 | }, |
193 | }, |
194 | /* |
195 | * 'modified' (i.e. axis specified) acceleration channel |
196 | * in_accel_z_raw |
197 | */ |
198 | { |
199 | .type = IIO_ACCEL, |
200 | .modified = 1, |
201 | /* Channel 2 is use for modifiers */ |
202 | .channel2 = IIO_MOD_X, |
203 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | |
204 | /* |
205 | * Internal bias and gain correction values. Applied |
206 | * by the hardware or driver prior to userspace |
207 | * seeing the readings. Typically part of hardware |
208 | * calibration. |
209 | */ |
210 | BIT(IIO_CHAN_INFO_CALIBSCALE) | |
211 | BIT(IIO_CHAN_INFO_CALIBBIAS), |
212 | .info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ), |
213 | .scan_index = DUMMY_INDEX_ACCELX, |
214 | .scan_type = { /* Description of storage in buffer */ |
215 | .sign = 's', /* signed */ |
216 | .realbits = 16, /* 16 bits */ |
217 | .storagebits = 16, /* 16 bits used for storage */ |
218 | .shift = 0, /* zero shift */ |
219 | }, |
220 | }, |
221 | /* |
222 | * Convenience macro for timestamps. 4 is the index in |
223 | * the buffer. |
224 | */ |
225 | IIO_CHAN_SOFT_TIMESTAMP(4), |
226 | /* DAC channel out_voltage0_raw */ |
227 | { |
228 | .type = IIO_VOLTAGE, |
229 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
230 | .scan_index = -1, /* No buffer support */ |
231 | .output = 1, |
232 | .indexed = 1, |
233 | .channel = 0, |
234 | }, |
235 | { |
236 | .type = IIO_STEPS, |
237 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_ENABLE) | |
238 | BIT(IIO_CHAN_INFO_CALIBHEIGHT), |
239 | .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), |
240 | .scan_index = -1, /* No buffer support */ |
241 | #ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS |
242 | .event_spec = &step_detect_event, |
243 | .num_event_specs = 1, |
244 | #endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */ |
245 | }, |
246 | { |
247 | .type = IIO_ACTIVITY, |
248 | .modified = 1, |
249 | .channel2 = IIO_MOD_RUNNING, |
250 | .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), |
251 | .scan_index = -1, /* No buffer support */ |
252 | #ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS |
253 | .event_spec = &iio_running_event, |
254 | .num_event_specs = 1, |
255 | #endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */ |
256 | }, |
257 | { |
258 | .type = IIO_ACTIVITY, |
259 | .modified = 1, |
260 | .channel2 = IIO_MOD_WALKING, |
261 | .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), |
262 | .scan_index = -1, /* No buffer support */ |
263 | #ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS |
264 | .event_spec = &iio_walking_event, |
265 | .num_event_specs = 1, |
266 | #endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */ |
267 | }, |
268 | }; |
269 | |
270 | /** |
271 | * iio_dummy_read_raw() - data read function. |
272 | * @indio_dev: the struct iio_dev associated with this device instance |
273 | * @chan: the channel whose data is to be read |
274 | * @val: first element of returned value (typically INT) |
275 | * @val2: second element of returned value (typically MICRO) |
276 | * @mask: what we actually want to read as per the info_mask_* |
277 | * in iio_chan_spec. |
278 | */ |
279 | static int iio_dummy_read_raw(struct iio_dev *indio_dev, |
280 | struct iio_chan_spec const *chan, |
281 | int *val, |
282 | int *val2, |
283 | long mask) |
284 | { |
285 | struct iio_dummy_state *st = iio_priv(indio_dev); |
286 | int ret = -EINVAL; |
287 | |
288 | mutex_lock(&st->lock); |
289 | switch (mask) { |
290 | case IIO_CHAN_INFO_RAW: /* magic value - channel value read */ |
291 | switch (chan->type) { |
292 | case IIO_VOLTAGE: |
293 | if (chan->output) { |
294 | /* Set integer part to cached value */ |
295 | *val = st->dac_val; |
296 | ret = IIO_VAL_INT; |
297 | } else if (chan->differential) { |
298 | if (chan->channel == 1) |
299 | *val = st->differential_adc_val[0]; |
300 | else |
301 | *val = st->differential_adc_val[1]; |
302 | ret = IIO_VAL_INT; |
303 | } else { |
304 | *val = st->single_ended_adc_val; |
305 | ret = IIO_VAL_INT; |
306 | } |
307 | break; |
308 | case IIO_ACCEL: |
309 | *val = st->accel_val; |
310 | ret = IIO_VAL_INT; |
311 | break; |
312 | default: |
313 | break; |
314 | } |
315 | break; |
316 | case IIO_CHAN_INFO_PROCESSED: |
317 | switch (chan->type) { |
318 | case IIO_STEPS: |
319 | *val = st->steps; |
320 | ret = IIO_VAL_INT; |
321 | break; |
322 | case IIO_ACTIVITY: |
323 | switch (chan->channel2) { |
324 | case IIO_MOD_RUNNING: |
325 | *val = st->activity_running; |
326 | ret = IIO_VAL_INT; |
327 | break; |
328 | case IIO_MOD_WALKING: |
329 | *val = st->activity_walking; |
330 | ret = IIO_VAL_INT; |
331 | break; |
332 | default: |
333 | break; |
334 | } |
335 | break; |
336 | default: |
337 | break; |
338 | } |
339 | break; |
340 | case IIO_CHAN_INFO_OFFSET: |
341 | /* only single ended adc -> 7 */ |
342 | *val = 7; |
343 | ret = IIO_VAL_INT; |
344 | break; |
345 | case IIO_CHAN_INFO_SCALE: |
346 | switch (chan->type) { |
347 | case IIO_VOLTAGE: |
348 | switch (chan->differential) { |
349 | case 0: |
350 | /* only single ended adc -> 0.001333 */ |
351 | *val = 0; |
352 | *val2 = 1333; |
353 | ret = IIO_VAL_INT_PLUS_MICRO; |
354 | break; |
355 | case 1: |
356 | /* all differential adc -> 0.000001344 */ |
357 | *val = 0; |
358 | *val2 = 1344; |
359 | ret = IIO_VAL_INT_PLUS_NANO; |
360 | } |
361 | break; |
362 | default: |
363 | break; |
364 | } |
365 | break; |
366 | case IIO_CHAN_INFO_CALIBBIAS: |
367 | /* only the acceleration axis - read from cache */ |
368 | *val = st->accel_calibbias; |
369 | ret = IIO_VAL_INT; |
370 | break; |
371 | case IIO_CHAN_INFO_CALIBSCALE: |
372 | *val = st->accel_calibscale->val; |
373 | *val2 = st->accel_calibscale->val2; |
374 | ret = IIO_VAL_INT_PLUS_MICRO; |
375 | break; |
376 | case IIO_CHAN_INFO_SAMP_FREQ: |
377 | *val = 3; |
378 | *val2 = 33; |
379 | ret = IIO_VAL_INT_PLUS_NANO; |
380 | break; |
381 | case IIO_CHAN_INFO_ENABLE: |
382 | switch (chan->type) { |
383 | case IIO_STEPS: |
384 | *val = st->steps_enabled; |
385 | ret = IIO_VAL_INT; |
386 | break; |
387 | default: |
388 | break; |
389 | } |
390 | break; |
391 | case IIO_CHAN_INFO_CALIBHEIGHT: |
392 | switch (chan->type) { |
393 | case IIO_STEPS: |
394 | *val = st->height; |
395 | ret = IIO_VAL_INT; |
396 | break; |
397 | default: |
398 | break; |
399 | } |
400 | break; |
401 | |
402 | default: |
403 | break; |
404 | } |
405 | mutex_unlock(lock: &st->lock); |
406 | return ret; |
407 | } |
408 | |
409 | /** |
410 | * iio_dummy_write_raw() - data write function. |
411 | * @indio_dev: the struct iio_dev associated with this device instance |
412 | * @chan: the channel whose data is to be written |
413 | * @val: first element of value to set (typically INT) |
414 | * @val2: second element of value to set (typically MICRO) |
415 | * @mask: what we actually want to write as per the info_mask_* |
416 | * in iio_chan_spec. |
417 | * |
418 | * Note that all raw writes are assumed IIO_VAL_INT and info mask elements |
419 | * are assumed to be IIO_INT_PLUS_MICRO unless the callback write_raw_get_fmt |
420 | * in struct iio_info is provided by the driver. |
421 | */ |
422 | static int iio_dummy_write_raw(struct iio_dev *indio_dev, |
423 | struct iio_chan_spec const *chan, |
424 | int val, |
425 | int val2, |
426 | long mask) |
427 | { |
428 | int i; |
429 | int ret = 0; |
430 | struct iio_dummy_state *st = iio_priv(indio_dev); |
431 | |
432 | switch (mask) { |
433 | case IIO_CHAN_INFO_RAW: |
434 | switch (chan->type) { |
435 | case IIO_VOLTAGE: |
436 | if (chan->output == 0) |
437 | return -EINVAL; |
438 | |
439 | /* Locking not required as writing single value */ |
440 | mutex_lock(&st->lock); |
441 | st->dac_val = val; |
442 | mutex_unlock(lock: &st->lock); |
443 | return 0; |
444 | default: |
445 | return -EINVAL; |
446 | } |
447 | case IIO_CHAN_INFO_PROCESSED: |
448 | switch (chan->type) { |
449 | case IIO_STEPS: |
450 | mutex_lock(&st->lock); |
451 | st->steps = val; |
452 | mutex_unlock(lock: &st->lock); |
453 | return 0; |
454 | case IIO_ACTIVITY: |
455 | if (val < 0) |
456 | val = 0; |
457 | if (val > 100) |
458 | val = 100; |
459 | switch (chan->channel2) { |
460 | case IIO_MOD_RUNNING: |
461 | st->activity_running = val; |
462 | return 0; |
463 | case IIO_MOD_WALKING: |
464 | st->activity_walking = val; |
465 | return 0; |
466 | default: |
467 | return -EINVAL; |
468 | } |
469 | break; |
470 | default: |
471 | return -EINVAL; |
472 | } |
473 | case IIO_CHAN_INFO_CALIBSCALE: |
474 | mutex_lock(&st->lock); |
475 | /* Compare against table - hard matching here */ |
476 | for (i = 0; i < ARRAY_SIZE(dummy_scales); i++) |
477 | if (val == dummy_scales[i].val && |
478 | val2 == dummy_scales[i].val2) |
479 | break; |
480 | if (i == ARRAY_SIZE(dummy_scales)) |
481 | ret = -EINVAL; |
482 | else |
483 | st->accel_calibscale = &dummy_scales[i]; |
484 | mutex_unlock(lock: &st->lock); |
485 | return ret; |
486 | case IIO_CHAN_INFO_CALIBBIAS: |
487 | mutex_lock(&st->lock); |
488 | st->accel_calibbias = val; |
489 | mutex_unlock(lock: &st->lock); |
490 | return 0; |
491 | case IIO_CHAN_INFO_ENABLE: |
492 | switch (chan->type) { |
493 | case IIO_STEPS: |
494 | mutex_lock(&st->lock); |
495 | st->steps_enabled = val; |
496 | mutex_unlock(lock: &st->lock); |
497 | return 0; |
498 | default: |
499 | return -EINVAL; |
500 | } |
501 | case IIO_CHAN_INFO_CALIBHEIGHT: |
502 | switch (chan->type) { |
503 | case IIO_STEPS: |
504 | st->height = val; |
505 | return 0; |
506 | default: |
507 | return -EINVAL; |
508 | } |
509 | |
510 | default: |
511 | return -EINVAL; |
512 | } |
513 | } |
514 | |
515 | /* |
516 | * Device type specific information. |
517 | */ |
518 | static const struct iio_info iio_dummy_info = { |
519 | .read_raw = &iio_dummy_read_raw, |
520 | .write_raw = &iio_dummy_write_raw, |
521 | #ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS |
522 | .read_event_config = &iio_simple_dummy_read_event_config, |
523 | .write_event_config = &iio_simple_dummy_write_event_config, |
524 | .read_event_value = &iio_simple_dummy_read_event_value, |
525 | .write_event_value = &iio_simple_dummy_write_event_value, |
526 | #endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */ |
527 | }; |
528 | |
529 | /** |
530 | * iio_dummy_init_device() - device instance specific init |
531 | * @indio_dev: the iio device structure |
532 | * |
533 | * Most drivers have one of these to set up default values, |
534 | * reset the device to known state etc. |
535 | */ |
536 | static int iio_dummy_init_device(struct iio_dev *indio_dev) |
537 | { |
538 | struct iio_dummy_state *st = iio_priv(indio_dev); |
539 | |
540 | st->dac_val = 0; |
541 | st->single_ended_adc_val = 73; |
542 | st->differential_adc_val[0] = 33; |
543 | st->differential_adc_val[1] = -34; |
544 | st->accel_val = 34; |
545 | st->accel_calibbias = -7; |
546 | st->accel_calibscale = &dummy_scales[0]; |
547 | st->steps = 47; |
548 | st->activity_running = 98; |
549 | st->activity_walking = 4; |
550 | |
551 | return 0; |
552 | } |
553 | |
554 | /** |
555 | * iio_dummy_probe() - device instance probe |
556 | * @name: name of this instance. |
557 | * |
558 | * Arguments are bus type specific. |
559 | * I2C: iio_dummy_probe(struct i2c_client *client, |
560 | * const struct i2c_device_id *id) |
561 | * SPI: iio_dummy_probe(struct spi_device *spi) |
562 | */ |
563 | static struct iio_sw_device *iio_dummy_probe(const char *name) |
564 | { |
565 | int ret; |
566 | struct iio_dev *indio_dev; |
567 | struct iio_dummy_state *st; |
568 | struct iio_sw_device *swd; |
569 | struct device *parent = NULL; |
570 | |
571 | /* |
572 | * With hardware: Set the parent device. |
573 | * parent = &spi->dev; |
574 | * parent = &client->dev; |
575 | */ |
576 | |
577 | swd = kzalloc(size: sizeof(*swd), GFP_KERNEL); |
578 | if (!swd) |
579 | return ERR_PTR(error: -ENOMEM); |
580 | |
581 | /* |
582 | * Allocate an IIO device. |
583 | * |
584 | * This structure contains all generic state |
585 | * information about the device instance. |
586 | * It also has a region (accessed by iio_priv() |
587 | * for chip specific state information. |
588 | */ |
589 | indio_dev = iio_device_alloc(parent, sizeof_priv: sizeof(*st)); |
590 | if (!indio_dev) { |
591 | ret = -ENOMEM; |
592 | goto error_free_swd; |
593 | } |
594 | |
595 | st = iio_priv(indio_dev); |
596 | mutex_init(&st->lock); |
597 | |
598 | iio_dummy_init_device(indio_dev); |
599 | |
600 | /* |
601 | * Make the iio_dev struct available to remove function. |
602 | * Bus equivalents |
603 | * i2c_set_clientdata(client, indio_dev); |
604 | * spi_set_drvdata(spi, indio_dev); |
605 | */ |
606 | swd->device = indio_dev; |
607 | |
608 | /* |
609 | * Set the device name. |
610 | * |
611 | * This is typically a part number and obtained from the module |
612 | * id table. |
613 | * e.g. for i2c and spi: |
614 | * indio_dev->name = id->name; |
615 | * indio_dev->name = spi_get_device_id(spi)->name; |
616 | */ |
617 | indio_dev->name = kstrdup(s: name, GFP_KERNEL); |
618 | if (!indio_dev->name) { |
619 | ret = -ENOMEM; |
620 | goto error_free_device; |
621 | } |
622 | |
623 | /* Provide description of available channels */ |
624 | indio_dev->channels = iio_dummy_channels; |
625 | indio_dev->num_channels = ARRAY_SIZE(iio_dummy_channels); |
626 | |
627 | /* |
628 | * Provide device type specific interface functions and |
629 | * constant data. |
630 | */ |
631 | indio_dev->info = &iio_dummy_info; |
632 | |
633 | /* Specify that device provides sysfs type interfaces */ |
634 | indio_dev->modes = INDIO_DIRECT_MODE; |
635 | |
636 | ret = iio_simple_dummy_events_register(indio_dev); |
637 | if (ret < 0) |
638 | goto error_free_name; |
639 | |
640 | ret = iio_simple_dummy_configure_buffer(indio_dev); |
641 | if (ret < 0) |
642 | goto error_unregister_events; |
643 | |
644 | ret = iio_device_register(indio_dev); |
645 | if (ret < 0) |
646 | goto error_unconfigure_buffer; |
647 | |
648 | iio_swd_group_init_type_name(d: swd, name, type: &iio_dummy_type); |
649 | |
650 | return swd; |
651 | error_unconfigure_buffer: |
652 | iio_simple_dummy_unconfigure_buffer(indio_dev); |
653 | error_unregister_events: |
654 | iio_simple_dummy_events_unregister(indio_dev); |
655 | error_free_name: |
656 | kfree(objp: indio_dev->name); |
657 | error_free_device: |
658 | iio_device_free(indio_dev); |
659 | error_free_swd: |
660 | kfree(objp: swd); |
661 | return ERR_PTR(error: ret); |
662 | } |
663 | |
664 | /** |
665 | * iio_dummy_remove() - device instance removal function |
666 | * @swd: pointer to software IIO device abstraction |
667 | * |
668 | * Parameters follow those of iio_dummy_probe for buses. |
669 | */ |
670 | static int iio_dummy_remove(struct iio_sw_device *swd) |
671 | { |
672 | /* |
673 | * Get a pointer to the device instance iio_dev structure |
674 | * from the bus subsystem. E.g. |
675 | * struct iio_dev *indio_dev = i2c_get_clientdata(client); |
676 | * struct iio_dev *indio_dev = spi_get_drvdata(spi); |
677 | */ |
678 | struct iio_dev *indio_dev = swd->device; |
679 | |
680 | /* Unregister the device */ |
681 | iio_device_unregister(indio_dev); |
682 | |
683 | /* Device specific code to power down etc */ |
684 | |
685 | /* Buffered capture related cleanup */ |
686 | iio_simple_dummy_unconfigure_buffer(indio_dev); |
687 | |
688 | iio_simple_dummy_events_unregister(indio_dev); |
689 | |
690 | /* Free all structures */ |
691 | kfree(objp: indio_dev->name); |
692 | iio_device_free(indio_dev); |
693 | |
694 | return 0; |
695 | } |
696 | |
697 | /* |
698 | * module_iio_sw_device_driver() - device driver registration |
699 | * |
700 | * Varies depending on bus type of the device. As there is no device |
701 | * here, call probe directly. For information on device registration |
702 | * i2c: |
703 | * Documentation/i2c/writing-clients.rst |
704 | * spi: |
705 | * Documentation/spi/spi-summary.rst |
706 | */ |
707 | static const struct iio_sw_device_ops iio_dummy_device_ops = { |
708 | .probe = iio_dummy_probe, |
709 | .remove = iio_dummy_remove, |
710 | }; |
711 | |
712 | static struct iio_sw_device_type iio_dummy_device = { |
713 | .name = "dummy" , |
714 | .owner = THIS_MODULE, |
715 | .ops = &iio_dummy_device_ops, |
716 | }; |
717 | |
718 | module_iio_sw_device_driver(iio_dummy_device); |
719 | |
720 | MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>" ); |
721 | MODULE_DESCRIPTION("IIO dummy driver" ); |
722 | MODULE_LICENSE("GPL v2" ); |
723 | |