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(&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(&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  */
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(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  */
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