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
26static 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 */
36struct iio_dummy_accel_calibscale {
37	int val;
38	int val2;
39	int regval; /* what would be written to hardware */
40};
41
42static 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 */
54static 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 */
63static 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 */
73static 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 */
83static 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 */
96static 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 */
279static 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 */
422static 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 */
518static 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 */
536static 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 */
563static 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;
651error_unconfigure_buffer:
652	iio_simple_dummy_unconfigure_buffer(indio_dev);
653error_unregister_events:
654	iio_simple_dummy_events_unregister(indio_dev);
655error_free_name:
656	kfree(indio_dev->name);
657error_free_device:
658	iio_device_free(indio_dev);
659error_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 */
670static 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 */
707static const struct iio_sw_device_ops iio_dummy_device_ops = {
708	.probe = iio_dummy_probe,
709	.remove = iio_dummy_remove,
710};
711
712static struct iio_sw_device_type iio_dummy_device = {
713	.name = "dummy",
714	.owner = THIS_MODULE,
715	.ops = &iio_dummy_device_ops,
716};
717
718module_iio_sw_device_driver(iio_dummy_device);
719
720MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
721MODULE_DESCRIPTION("IIO dummy driver");
722MODULE_LICENSE("GPL v2");
723