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