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 */
iio_dummy_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)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(&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 */
iio_dummy_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)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(&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(&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(&st->lock);
485 return ret;
486 case IIO_CHAN_INFO_CALIBBIAS:
487 mutex_lock(&st->lock);
488 st->accel_calibbias = val;
489 mutex_unlock(&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(&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 */
iio_dummy_init_device(struct iio_dev * indio_dev)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 */
iio_dummy_probe(const char * name)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(sizeof(*swd), GFP_KERNEL);
578 if (!swd)
579 return ERR_PTR(-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(*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(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(swd, name, &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(indio_dev->name);
657 error_free_device:
658 iio_device_free(indio_dev);
659 error_free_swd:
660 kfree(swd);
661 return ERR_PTR(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 */
iio_dummy_remove(struct iio_sw_device * swd)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(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
