cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

iio_simple_dummy.c (18516B)


      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");