iio: Move IIO Dummy Driver out of staging

This patch moves the reference IIO dummy driver from drivers/staging/iio
into a separate folder, drivers/iio/dummy and adds the proper Kconfig
and Makefile for it.

A new config menu entry called IIO dummy driver has also been added
in the Industrial I/O support menu, corresponding to this driver.

Signed-off-by: Cristina Opriceana <cristina.opriceana@gmail.com>
Signed-off-by: Jonathan Cameron <jic23@kernel.org>

8 files changed, 32 insertions, 1652 deletions

diff --git a/drivers/staging/iio/Kconfig b/drivers/staging/iio/Kconfig
index 6d5b38d69578..85de1985df8e 100644
--- a/drivers/staging/iio/Kconfig
+++ b/drivers/staging/iio/Kconfig
@@ -17,32 +17,32 @@ source "drivers/staging/iio/meter/Kconfig"
 source "drivers/staging/iio/resolver/Kconfig"
 source "drivers/staging/iio/trigger/Kconfig"
 
-config IIO_DUMMY_EVGEN
-       tristate
-
-config IIO_SIMPLE_DUMMY
-       tristate "An example driver with no hardware requirements"
-       help
-	 Driver intended mainly as documentation for how to write
-	 a driver. May also be useful for testing userspace code
-	 without hardware.
-
-if IIO_SIMPLE_DUMMY
-
-config IIO_SIMPLE_DUMMY_EVENTS
-       bool "Event generation support"
-       select IIO_DUMMY_EVGEN
-       help
-         Add some dummy events to the simple dummy driver.
-
-config IIO_SIMPLE_DUMMY_BUFFER
-	bool "Buffered capture support"
-	select IIO_BUFFER
-	select IIO_TRIGGER
-	select IIO_KFIFO_BUF
-	help
-	  Add buffered data capture to the simple dummy driver.
-
-endif # IIO_SIMPLE_DUMMY
+#config IIO_DUMMY_EVGEN
+#       tristate
+#
+#config IIO_SIMPLE_DUMMY
+#       tristate "An example driver with no hardware requirements"
+#       help
+#	 Driver intended mainly as documentation for how to write
+#	 a driver. May also be useful for testing userspace code
+#	 without hardware.
+
+#if IIO_SIMPLE_DUMMY
+
+#config IIO_SIMPLE_DUMMY_EVENTS
+#       bool "Event generation support"
+#       select IIO_DUMMY_EVGEN
+#      help
+#        Add some dummy events to the simple dummy driver.
+
+#config IIO_SIMPLE_DUMMY_BUFFER
+#	bool "Buffered capture support"
+#	select IIO_BUFFER
+# select IIO_TRIGGER
+#	select IIO_KFIFO_BUF
+#	help
+#	  Add buffered data capture to the simple dummy driver.
+
+#endif # IIO_SIMPLE_DUMMY
 
 endmenu
diff --git a/drivers/staging/iio/Makefile b/drivers/staging/iio/Makefile
index d87106135b27..355824ab733b 100644
--- a/drivers/staging/iio/Makefile
+++ b/drivers/staging/iio/Makefile
@@ -2,12 +2,12 @@
 # Makefile for the industrial I/O core.
 #
 
-obj-$(CONFIG_IIO_SIMPLE_DUMMY) += iio_dummy.o
-iio_dummy-y := iio_simple_dummy.o
-iio_dummy-$(CONFIG_IIO_SIMPLE_DUMMY_EVENTS) += iio_simple_dummy_events.o
-iio_dummy-$(CONFIG_IIO_SIMPLE_DUMMY_BUFFER) += iio_simple_dummy_buffer.o
+#obj-$(CONFIG_IIO_SIMPLE_DUMMY) += iio_dummy.o
+#iio_dummy-y := iio_simple_dummy.o
+#iio_dummy-$(CONFIG_IIO_SIMPLE_DUMMY_EVENTS) += iio_simple_dummy_events.o
+#iio_dummy-$(CONFIG_IIO_SIMPLE_DUMMY_BUFFER) += iio_simple_dummy_buffer.o
 
-obj-$(CONFIG_IIO_DUMMY_EVGEN) += iio_dummy_evgen.o
+#obj-$(CONFIG_IIO_DUMMY_EVGEN) += iio_dummy_evgen.o
 
 obj-y += accel/
 obj-y += adc/
diff --git a/drivers/staging/iio/iio_dummy_evgen.c b/drivers/staging/iio/iio_dummy_evgen.c
deleted file mode 100644
index 9e83f348df51..000000000000
--- a/drivers/staging/iio/iio_dummy_evgen.c
+++ /dev/null
@@ -1,262 +0,0 @@
-/**
- * Copyright (c) 2011 Jonathan Cameron
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 as published by
- * the Free Software Foundation.
- *
- * Companion module to the iio simple dummy example driver.
- * The purpose of this is to generate 'fake' event interrupts thus
- * allowing that driver's code to be as close as possible to that of
- * a normal driver talking to hardware.  The approach used here
- * is not intended to be general and just happens to work for this
- * particular use case.
- */
-
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/mutex.h>
-#include <linux/module.h>
-#include <linux/sysfs.h>
-
-#include "iio_dummy_evgen.h"
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include <linux/irq_work.h>
-
-/* Fiddly bit of faking and irq without hardware */
-#define IIO_EVENTGEN_NO 10
-
-/**
- * struct iio_dummy_handle_irq - helper struct to simulate interrupt generation
- * @work: irq_work used to run handlers from hardirq context
- * @irq: fake irq line number to trigger an interrupt
- */
-struct iio_dummy_handle_irq {
-	struct irq_work work;
-	int irq;
-};
-
-/**
- * struct iio_dummy_evgen - evgen state
- * @chip: irq chip we are faking
- * @base: base of irq range
- * @enabled: mask of which irqs are enabled
- * @inuse: mask of which irqs are connected
- * @regs: irq regs we are faking
- * @lock: protect the evgen state
- * @handler: helper for a 'hardware-like' interrupt simulation
- */
-struct iio_dummy_eventgen {
-	struct irq_chip chip;
-	int base;
-	bool enabled[IIO_EVENTGEN_NO];
-	bool inuse[IIO_EVENTGEN_NO];
-	struct iio_dummy_regs regs[IIO_EVENTGEN_NO];
-	struct mutex lock;
-	struct iio_dummy_handle_irq handler;
-};
-
-/* We can only ever have one instance of this 'device' */
-static struct iio_dummy_eventgen *iio_evgen;
-static const char *iio_evgen_name = "iio_dummy_evgen";
-
-static void iio_dummy_event_irqmask(struct irq_data *d)
-{
-	struct irq_chip *chip = irq_data_get_irq_chip(d);
-	struct iio_dummy_eventgen *evgen =
-		container_of(chip, struct iio_dummy_eventgen, chip);
-
-	evgen->enabled[d->irq - evgen->base] = false;
-}
-
-static void iio_dummy_event_irqunmask(struct irq_data *d)
-{
-	struct irq_chip *chip = irq_data_get_irq_chip(d);
-	struct iio_dummy_eventgen *evgen =
-		container_of(chip, struct iio_dummy_eventgen, chip);
-
-	evgen->enabled[d->irq - evgen->base] = true;
-}
-
-static void iio_dummy_work_handler(struct irq_work *work)
-{
-	struct iio_dummy_handle_irq *irq_handler;
-
-	irq_handler = container_of(work, struct iio_dummy_handle_irq, work);
-	handle_simple_irq(irq_to_desc(irq_handler->irq));
-}
-
-static int iio_dummy_evgen_create(void)
-{
-	int ret, i;
-
-	iio_evgen = kzalloc(sizeof(*iio_evgen), GFP_KERNEL);
-	if (!iio_evgen)
-		return -ENOMEM;
-
-	iio_evgen->base = irq_alloc_descs(-1, 0, IIO_EVENTGEN_NO, 0);
-	if (iio_evgen->base < 0) {
-		ret = iio_evgen->base;
-		kfree(iio_evgen);
-		return ret;
-	}
-	iio_evgen->chip.name = iio_evgen_name;
-	iio_evgen->chip.irq_mask = &iio_dummy_event_irqmask;
-	iio_evgen->chip.irq_unmask = &iio_dummy_event_irqunmask;
-	for (i = 0; i < IIO_EVENTGEN_NO; i++) {
-		irq_set_chip(iio_evgen->base + i, &iio_evgen->chip);
-		irq_set_handler(iio_evgen->base + i, &handle_simple_irq);
-		irq_modify_status(iio_evgen->base + i,
-				  IRQ_NOREQUEST | IRQ_NOAUTOEN,
-				  IRQ_NOPROBE);
-	}
-	init_irq_work(&iio_evgen->handler.work, iio_dummy_work_handler);
-	mutex_init(&iio_evgen->lock);
-	return 0;
-}
-
-/**
- * iio_dummy_evgen_get_irq() - get an evgen provided irq for a device
- *
- * This function will give a free allocated irq to a client device.
- * That irq can then be caused to 'fire' by using the associated sysfs file.
- */
-int iio_dummy_evgen_get_irq(void)
-{
-	int i, ret = 0;
-
-	if (!iio_evgen)
-		return -ENODEV;
-
-	mutex_lock(&iio_evgen->lock);
-	for (i = 0; i < IIO_EVENTGEN_NO; i++)
-		if (!iio_evgen->inuse[i]) {
-			ret = iio_evgen->base + i;
-			iio_evgen->inuse[i] = true;
-			break;
-		}
-	mutex_unlock(&iio_evgen->lock);
-	if (i == IIO_EVENTGEN_NO)
-		return -ENOMEM;
-	return ret;
-}
-EXPORT_SYMBOL_GPL(iio_dummy_evgen_get_irq);
-
-/**
- * iio_dummy_evgen_release_irq() - give the irq back.
- * @irq: irq being returned to the pool
- *
- * Used by client driver instances to give the irqs back when they disconnect
- */
-void iio_dummy_evgen_release_irq(int irq)
-{
-	mutex_lock(&iio_evgen->lock);
-	iio_evgen->inuse[irq - iio_evgen->base] = false;
-	mutex_unlock(&iio_evgen->lock);
-}
-EXPORT_SYMBOL_GPL(iio_dummy_evgen_release_irq);
-
-struct iio_dummy_regs *iio_dummy_evgen_get_regs(int irq)
-{
-	return &iio_evgen->regs[irq - iio_evgen->base];
-}
-EXPORT_SYMBOL_GPL(iio_dummy_evgen_get_regs);
-
-static void iio_dummy_evgen_free(void)
-{
-	irq_free_descs(iio_evgen->base, IIO_EVENTGEN_NO);
-	kfree(iio_evgen);
-}
-
-static void iio_evgen_release(struct device *dev)
-{
-	iio_dummy_evgen_free();
-}
-
-static ssize_t iio_evgen_poke(struct device *dev,
-			      struct device_attribute *attr,
-			      const char *buf,
-			      size_t len)
-{
-	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-	unsigned long event;
-	int ret;
-
-	ret = kstrtoul(buf, 10, &event);
-	if (ret)
-		return ret;
-
-	iio_evgen->regs[this_attr->address].reg_id   = this_attr->address;
-	iio_evgen->regs[this_attr->address].reg_data = event;
-
-	iio_evgen->handler.irq = iio_evgen->base + this_attr->address;
-	if (iio_evgen->enabled[this_attr->address])
-		irq_work_queue(&iio_evgen->handler.work);
-
-	return len;
-}
-
-static IIO_DEVICE_ATTR(poke_ev0, S_IWUSR, NULL, &iio_evgen_poke, 0);
-static IIO_DEVICE_ATTR(poke_ev1, S_IWUSR, NULL, &iio_evgen_poke, 1);
-static IIO_DEVICE_ATTR(poke_ev2, S_IWUSR, NULL, &iio_evgen_poke, 2);
-static IIO_DEVICE_ATTR(poke_ev3, S_IWUSR, NULL, &iio_evgen_poke, 3);
-static IIO_DEVICE_ATTR(poke_ev4, S_IWUSR, NULL, &iio_evgen_poke, 4);
-static IIO_DEVICE_ATTR(poke_ev5, S_IWUSR, NULL, &iio_evgen_poke, 5);
-static IIO_DEVICE_ATTR(poke_ev6, S_IWUSR, NULL, &iio_evgen_poke, 6);
-static IIO_DEVICE_ATTR(poke_ev7, S_IWUSR, NULL, &iio_evgen_poke, 7);
-static IIO_DEVICE_ATTR(poke_ev8, S_IWUSR, NULL, &iio_evgen_poke, 8);
-static IIO_DEVICE_ATTR(poke_ev9, S_IWUSR, NULL, &iio_evgen_poke, 9);
-
-static struct attribute *iio_evgen_attrs[] = {
-	&iio_dev_attr_poke_ev0.dev_attr.attr,
-	&iio_dev_attr_poke_ev1.dev_attr.attr,
-	&iio_dev_attr_poke_ev2.dev_attr.attr,
-	&iio_dev_attr_poke_ev3.dev_attr.attr,
-	&iio_dev_attr_poke_ev4.dev_attr.attr,
-	&iio_dev_attr_poke_ev5.dev_attr.attr,
-	&iio_dev_attr_poke_ev6.dev_attr.attr,
-	&iio_dev_attr_poke_ev7.dev_attr.attr,
-	&iio_dev_attr_poke_ev8.dev_attr.attr,
-	&iio_dev_attr_poke_ev9.dev_attr.attr,
-	NULL,
-};
-
-static const struct attribute_group iio_evgen_group = {
-	.attrs = iio_evgen_attrs,
-};
-
-static const struct attribute_group *iio_evgen_groups[] = {
-	&iio_evgen_group,
-	NULL
-};
-
-static struct device iio_evgen_dev = {
-	.bus = &iio_bus_type,
-	.groups = iio_evgen_groups,
-	.release = &iio_evgen_release,
-};
-
-static __init int iio_dummy_evgen_init(void)
-{
-	int ret = iio_dummy_evgen_create();
-
-	if (ret < 0)
-		return ret;
-	device_initialize(&iio_evgen_dev);
-	dev_set_name(&iio_evgen_dev, "iio_evgen");
-	return device_add(&iio_evgen_dev);
-}
-module_init(iio_dummy_evgen_init);
-
-static __exit void iio_dummy_evgen_exit(void)
-{
-	device_unregister(&iio_evgen_dev);
-}
-module_exit(iio_dummy_evgen_exit);
-
-MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
-MODULE_DESCRIPTION("IIO dummy driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/staging/iio/iio_dummy_evgen.h b/drivers/staging/iio/iio_dummy_evgen.h
deleted file mode 100644
index d044b946e74a..000000000000
--- a/drivers/staging/iio/iio_dummy_evgen.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef _IIO_DUMMY_EVGEN_H_
-#define _IIO_DUMMY_EVGEN_H_
-
-struct iio_dummy_regs {
-	u32 reg_id;
-	u32 reg_data;
-};
-
-struct iio_dummy_regs *iio_dummy_evgen_get_regs(int irq);
-int iio_dummy_evgen_get_irq(void);
-void iio_dummy_evgen_release_irq(int irq);
-
-#endif /* _IIO_DUMMY_EVGEN_H_ */
diff --git a/drivers/staging/iio/iio_simple_dummy.c b/drivers/staging/iio/iio_simple_dummy.c
deleted file mode 100644
index 381f90ff468a..000000000000
--- a/drivers/staging/iio/iio_simple_dummy.c
+++ /dev/null
@@ -1,748 +0,0 @@
-/**
- * Copyright (c) 2011 Jonathan Cameron
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 as published by
- * the Free Software Foundation.
- *
- * A reference industrial I/O driver to illustrate the functionality available.
- *
- * There are numerous real drivers to illustrate the finer points.
- * The purpose of this driver is to provide a driver with far more comments
- * and explanatory notes than any 'real' driver would have.
- * Anyone starting out writing an IIO driver should first make sure they
- * understand all of this driver except those bits specifically marked
- * as being present to allow us to 'fake' the presence of hardware.
- */
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include <linux/iio/events.h>
-#include <linux/iio/buffer.h>
-#include "iio_simple_dummy.h"
-
-/*
- * A few elements needed to fake a bus for this driver
- * Note instances parameter controls how many of these
- * dummy devices are registered.
- */
-static unsigned instances = 1;
-module_param(instances, uint, 0);
-
-/* Pointer array used to fake bus elements */
-static struct iio_dev **iio_dummy_devs;
-
-/* Fake a name for the part number, usually obtained from the id table */
-static const char *iio_dummy_part_number = "iio_dummy_part_no";
-
-/**
- * struct iio_dummy_accel_calibscale - realworld to register mapping
- * @val: first value in read_raw - here integer part.
- * @val2: second value in read_raw etc - here micro part.
- * @regval: register value - magic device specific numbers.
- */
-struct iio_dummy_accel_calibscale {
-	int val;
-	int val2;
-	int regval; /* what would be written to hardware */
-};
-
-static const struct iio_dummy_accel_calibscale dummy_scales[] = {
-	{ 0, 100, 0x8 }, /* 0.000100 */
-	{ 0, 133, 0x7 }, /* 0.000133 */
-	{ 733, 13, 0x9 }, /* 733.000013 */
-};
-
-#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS
-
-/*
- * simple event - triggered when value rises above
- * a threshold
- */
-static const struct iio_event_spec iio_dummy_event = {
-	.type = IIO_EV_TYPE_THRESH,
-	.dir = IIO_EV_DIR_RISING,
-	.mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
-};
-
-/*
- * simple step detect event - triggered when a step is detected
- */
-static const struct iio_event_spec step_detect_event = {
-	.type = IIO_EV_TYPE_CHANGE,
-	.dir = IIO_EV_DIR_NONE,
-	.mask_separate = BIT(IIO_EV_INFO_ENABLE),
-};
-
-/*
- * simple transition event - triggered when the reported running confidence
- * value rises above a threshold value
- */
-static const struct iio_event_spec iio_running_event = {
-	.type = IIO_EV_TYPE_THRESH,
-	.dir = IIO_EV_DIR_RISING,
-	.mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
-};
-
-/*
- * simple transition event - triggered when the reported walking confidence
- * value falls under a threshold value
- */
-static const struct iio_event_spec iio_walking_event = {
-	.type = IIO_EV_TYPE_THRESH,
-	.dir = IIO_EV_DIR_FALLING,
-	.mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
-};
-#endif
-
-/*
- * iio_dummy_channels - Description of available channels
- *
- * This array of structures tells the IIO core about what the device
- * actually provides for a given channel.
- */
-static const struct iio_chan_spec iio_dummy_channels[] = {
-	/* indexed ADC channel in_voltage0_raw etc */
-	{
-		.type = IIO_VOLTAGE,
-		/* Channel has a numeric index of 0 */
-		.indexed = 1,
-		.channel = 0,
-		/* What other information is available? */
-		.info_mask_separate =
-		/*
-		 * in_voltage0_raw
-		 * Raw (unscaled no bias removal etc) measurement
-		 * from the device.
-		 */
-		BIT(IIO_CHAN_INFO_RAW) |
-		/*
-		 * in_voltage0_offset
-		 * Offset for userspace to apply prior to scale
-		 * when converting to standard units (microvolts)
-		 */
-		BIT(IIO_CHAN_INFO_OFFSET) |
-		/*
-		 * in_voltage0_scale
-		 * Multipler for userspace to apply post offset
-		 * when converting to standard units (microvolts)
-		 */
-		BIT(IIO_CHAN_INFO_SCALE),
-		/*
-		 * sampling_frequency
-		 * The frequency in Hz at which the channels are sampled
-		 */
-		.info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ),
-		/* The ordering of elements in the buffer via an enum */
-		.scan_index = voltage0,
-		.scan_type = { /* Description of storage in buffer */
-			.sign = 'u', /* unsigned */
-			.realbits = 13, /* 13 bits */
-			.storagebits = 16, /* 16 bits used for storage */
-			.shift = 0, /* zero shift */
-		},
-#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS
-		.event_spec = &iio_dummy_event,
-		.num_event_specs = 1,
-#endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */
-	},
-	/* Differential ADC channel in_voltage1-voltage2_raw etc*/
-	{
-		.type = IIO_VOLTAGE,
-		.differential = 1,
-		/*
-		 * Indexing for differential channels uses channel
-		 * for the positive part, channel2 for the negative.
-		 */
-		.indexed = 1,
-		.channel = 1,
-		.channel2 = 2,
-		/*
-		 * in_voltage1-voltage2_raw
-		 * Raw (unscaled no bias removal etc) measurement
-		 * from the device.
-		 */
-		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
-		/*
-		 * in_voltage-voltage_scale
-		 * Shared version of scale - shared by differential
-		 * input channels of type IIO_VOLTAGE.
-		 */
-		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
-		/*
-		 * sampling_frequency
-		 * The frequency in Hz at which the channels are sampled
-		 */
-		.scan_index = diffvoltage1m2,
-		.scan_type = { /* Description of storage in buffer */
-			.sign = 's', /* signed */
-			.realbits = 12, /* 12 bits */
-			.storagebits = 16, /* 16 bits used for storage */
-			.shift = 0, /* zero shift */
-		},
-	},
-	/* Differential ADC channel in_voltage3-voltage4_raw etc*/
-	{
-		.type = IIO_VOLTAGE,
-		.differential = 1,
-		.indexed = 1,
-		.channel = 3,
-		.channel2 = 4,
-		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
-		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
-		.info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ),
-		.scan_index = diffvoltage3m4,
-		.scan_type = {
-			.sign = 's',
-			.realbits = 11,
-			.storagebits = 16,
-			.shift = 0,
-		},
-	},
-	/*
-	 * 'modified' (i.e. axis specified) acceleration channel
-	 * in_accel_z_raw
-	 */
-	{
-		.type = IIO_ACCEL,
-		.modified = 1,
-		/* Channel 2 is use for modifiers */
-		.channel2 = IIO_MOD_X,
-		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
-		/*
-		 * Internal bias and gain correction values. Applied
-		 * by the hardware or driver prior to userspace
-		 * seeing the readings. Typically part of hardware
-		 * calibration.
-		 */
-		BIT(IIO_CHAN_INFO_CALIBSCALE) |
-		BIT(IIO_CHAN_INFO_CALIBBIAS),
-		.info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ),
-		.scan_index = accelx,
-		.scan_type = { /* Description of storage in buffer */
-			.sign = 's', /* signed */
-			.realbits = 16, /* 16 bits */
-			.storagebits = 16, /* 16 bits used for storage */
-			.shift = 0, /* zero shift */
-		},
-	},
-	/*
-	 * Convenience macro for timestamps. 4 is the index in
-	 * the buffer.
-	 */
-	IIO_CHAN_SOFT_TIMESTAMP(4),
-	/* DAC channel out_voltage0_raw */
-	{
-		.type = IIO_VOLTAGE,
-		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
-		.scan_index = -1, /* No buffer support */
-		.output = 1,
-		.indexed = 1,
-		.channel = 0,
-	},
-	{
-		.type = IIO_STEPS,
-		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_ENABLE) |
-			BIT(IIO_CHAN_INFO_CALIBHEIGHT),
-		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
-		.scan_index = -1, /* No buffer support */
-#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS
-		.event_spec = &step_detect_event,
-		.num_event_specs = 1,
-#endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */
-	},
-	{
-		.type = IIO_ACTIVITY,
-		.modified = 1,
-		.channel2 = IIO_MOD_RUNNING,
-		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
-		.scan_index = -1, /* No buffer support */
-#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS
-		.event_spec = &iio_running_event,
-		.num_event_specs = 1,
-#endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */
-	},
-	{
-		.type = IIO_ACTIVITY,
-		.modified = 1,
-		.channel2 = IIO_MOD_WALKING,
-		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
-		.scan_index = -1, /* No buffer support */
-#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS
-		.event_spec = &iio_walking_event,
-		.num_event_specs = 1,
-#endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */
-	},
-};
-
-/**
- * iio_dummy_read_raw() - data read function.
- * @indio_dev:	the struct iio_dev associated with this device instance
- * @chan:	the channel whose data is to be read
- * @val:	first element of returned value (typically INT)
- * @val2:	second element of returned value (typically MICRO)
- * @mask:	what we actually want to read as per the info_mask_*
- *		in iio_chan_spec.
- */
-static int iio_dummy_read_raw(struct iio_dev *indio_dev,
-			      struct iio_chan_spec const *chan,
-			      int *val,
-			      int *val2,
-			      long mask)
-{
-	struct iio_dummy_state *st = iio_priv(indio_dev);
-	int ret = -EINVAL;
-
-	mutex_lock(&st->lock);
-	switch (mask) {
-	case IIO_CHAN_INFO_RAW: /* magic value - channel value read */
-		switch (chan->type) {
-		case IIO_VOLTAGE:
-			if (chan->output) {
-				/* Set integer part to cached value */
-				*val = st->dac_val;
-				ret = IIO_VAL_INT;
-			} else if (chan->differential) {
-				if (chan->channel == 1)
-					*val = st->differential_adc_val[0];
-				else
-					*val = st->differential_adc_val[1];
-				ret = IIO_VAL_INT;
-			} else {
-				*val = st->single_ended_adc_val;
-				ret = IIO_VAL_INT;
-			}
-			break;
-		case IIO_ACCEL:
-			*val = st->accel_val;
-			ret = IIO_VAL_INT;
-			break;
-		default:
-			break;
-		}
-		break;
-	case IIO_CHAN_INFO_PROCESSED:
-		switch (chan->type) {
-		case IIO_STEPS:
-			*val = st->steps;
-			ret = IIO_VAL_INT;
-			break;
-		case IIO_ACTIVITY:
-			switch (chan->channel2) {
-			case IIO_MOD_RUNNING:
-				*val = st->activity_running;
-				ret = IIO_VAL_INT;
-				break;
-			case IIO_MOD_WALKING:
-				*val = st->activity_walking;
-				ret = IIO_VAL_INT;
-				break;
-			default:
-				break;
-			}
-			break;
-		default:
-			break;
-		}
-		break;
-	case IIO_CHAN_INFO_OFFSET:
-		/* only single ended adc -> 7 */
-		*val = 7;
-		ret = IIO_VAL_INT;
-		break;
-	case IIO_CHAN_INFO_SCALE:
-		switch (chan->type) {
-		case IIO_VOLTAGE:
-			switch (chan->differential) {
-			case 0:
-				/* only single ended adc -> 0.001333 */
-				*val = 0;
-				*val2 = 1333;
-				ret = IIO_VAL_INT_PLUS_MICRO;
-				break;
-			case 1:
-				/* all differential adc channels ->
-				 * 0.000001344 */
-				*val = 0;
-				*val2 = 1344;
-				ret = IIO_VAL_INT_PLUS_NANO;
-			}
-			break;
-		default:
-			break;
-		}
-		break;
-	case IIO_CHAN_INFO_CALIBBIAS:
-		/* only the acceleration axis - read from cache */
-		*val = st->accel_calibbias;
-		ret = IIO_VAL_INT;
-		break;
-	case IIO_CHAN_INFO_CALIBSCALE:
-		*val = st->accel_calibscale->val;
-		*val2 = st->accel_calibscale->val2;
-		ret = IIO_VAL_INT_PLUS_MICRO;
-		break;
-	case IIO_CHAN_INFO_SAMP_FREQ:
-		*val = 3;
-		*val2 = 33;
-		ret = IIO_VAL_INT_PLUS_NANO;
-		break;
-	case IIO_CHAN_INFO_ENABLE:
-		switch (chan->type) {
-		case IIO_STEPS:
-			*val = st->steps_enabled;
-			ret = IIO_VAL_INT;
-			break;
-		default:
-			break;
-		}
-		break;
-	case IIO_CHAN_INFO_CALIBHEIGHT:
-		switch (chan->type) {
-		case IIO_STEPS:
-			*val = st->height;
-			ret = IIO_VAL_INT;
-			break;
-		default:
-			break;
-		}
-		break;
-
-	default:
-		break;
-	}
-	mutex_unlock(&st->lock);
-	return ret;
-}
-
-/**
- * iio_dummy_write_raw() - data write function.
- * @indio_dev:	the struct iio_dev associated with this device instance
- * @chan:	the channel whose data is to be written
- * @val:	first element of value to set (typically INT)
- * @val2:	second element of value to set (typically MICRO)
- * @mask:	what we actually want to write as per the info_mask_*
- *		in iio_chan_spec.
- *
- * Note that all raw writes are assumed IIO_VAL_INT and info mask elements
- * are assumed to be IIO_INT_PLUS_MICRO unless the callback write_raw_get_fmt
- * in struct iio_info is provided by the driver.
- */
-static int iio_dummy_write_raw(struct iio_dev *indio_dev,
-			       struct iio_chan_spec const *chan,
-			       int val,
-			       int val2,
-			       long mask)
-{
-	int i;
-	int ret = 0;
-	struct iio_dummy_state *st = iio_priv(indio_dev);
-
-	switch (mask) {
-	case IIO_CHAN_INFO_RAW:
-		switch (chan->type) {
-		case IIO_VOLTAGE:
-			if (chan->output == 0)
-				return -EINVAL;
-
-			/* Locking not required as writing single value */
-			mutex_lock(&st->lock);
-			st->dac_val = val;
-			mutex_unlock(&st->lock);
-			return 0;
-		default:
-			return -EINVAL;
-		}
-	case IIO_CHAN_INFO_PROCESSED:
-		switch (chan->type) {
-		case IIO_STEPS:
-			mutex_lock(&st->lock);
-			st->steps = val;
-			mutex_unlock(&st->lock);
-			return 0;
-		case IIO_ACTIVITY:
-			if (val < 0)
-				val = 0;
-			if (val > 100)
-				val = 100;
-			switch (chan->channel2) {
-			case IIO_MOD_RUNNING:
-				st->activity_running = val;
-				return 0;
-			case IIO_MOD_WALKING:
-				st->activity_walking = val;
-				return 0;
-			default:
-				return -EINVAL;
-			}
-			break;
-		default:
-			return -EINVAL;
-		}
-	case IIO_CHAN_INFO_CALIBSCALE:
-		mutex_lock(&st->lock);
-		/* Compare against table - hard matching here */
-		for (i = 0; i < ARRAY_SIZE(dummy_scales); i++)
-			if (val == dummy_scales[i].val &&
-			    val2 == dummy_scales[i].val2)
-				break;
-		if (i == ARRAY_SIZE(dummy_scales))
-			ret = -EINVAL;
-		else
-			st->accel_calibscale = &dummy_scales[i];
-		mutex_unlock(&st->lock);
-		return ret;
-	case IIO_CHAN_INFO_CALIBBIAS:
-		mutex_lock(&st->lock);
-		st->accel_calibbias = val;
-		mutex_unlock(&st->lock);
-		return 0;
-	case IIO_CHAN_INFO_ENABLE:
-		switch (chan->type) {
-		case IIO_STEPS:
-			mutex_lock(&st->lock);
-			st->steps_enabled = val;
-			mutex_unlock(&st->lock);
-			return 0;
-		default:
-			return -EINVAL;
-		}
-	case IIO_CHAN_INFO_CALIBHEIGHT:
-		switch (chan->type) {
-		case IIO_STEPS:
-			st->height = val;
-			return 0;
-		default:
-			return -EINVAL;
-		}
-
-	default:
-		return -EINVAL;
-	}
-}
-
-/*
- * Device type specific information.
- */
-static const struct iio_info iio_dummy_info = {
-	.driver_module = THIS_MODULE,
-	.read_raw = &iio_dummy_read_raw,
-	.write_raw = &iio_dummy_write_raw,
-#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS
-	.read_event_config = &iio_simple_dummy_read_event_config,
-	.write_event_config = &iio_simple_dummy_write_event_config,
-	.read_event_value = &iio_simple_dummy_read_event_value,
-	.write_event_value = &iio_simple_dummy_write_event_value,
-#endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */
-};
-
-/**
- * iio_dummy_init_device() - device instance specific init
- * @indio_dev: the iio device structure
- *
- * Most drivers have one of these to set up default values,
- * reset the device to known state etc.
- */
-static int iio_dummy_init_device(struct iio_dev *indio_dev)
-{
-	struct iio_dummy_state *st = iio_priv(indio_dev);
-
-	st->dac_val = 0;
-	st->single_ended_adc_val = 73;
-	st->differential_adc_val[0] = 33;
-	st->differential_adc_val[1] = -34;
-	st->accel_val = 34;
-	st->accel_calibbias = -7;
-	st->accel_calibscale = &dummy_scales[0];
-	st->steps = 47;
-	st->activity_running = 98;
-	st->activity_walking = 4;
-
-	return 0;
-}
-
-/**
- * iio_dummy_probe() - device instance probe
- * @index: an id number for this instance.
- *
- * Arguments are bus type specific.
- * I2C: iio_dummy_probe(struct i2c_client *client,
- *                      const struct i2c_device_id *id)
- * SPI: iio_dummy_probe(struct spi_device *spi)
- */
-static int iio_dummy_probe(int index)
-{
-	int ret;
-	struct iio_dev *indio_dev;
-	struct iio_dummy_state *st;
-
-	/*
-	 * Allocate an IIO device.
-	 *
-	 * This structure contains all generic state
-	 * information about the device instance.
-	 * It also has a region (accessed by iio_priv()
-	 * for chip specific state information.
-	 */
-	indio_dev = iio_device_alloc(sizeof(*st));
-	if (!indio_dev) {
-		ret = -ENOMEM;
-		goto error_ret;
-	}
-
-	st = iio_priv(indio_dev);
-	mutex_init(&st->lock);
-
-	iio_dummy_init_device(indio_dev);
-	/*
-	 * With hardware: Set the parent device.
-	 * indio_dev->dev.parent = &spi->dev;
-	 * indio_dev->dev.parent = &client->dev;
-	 */
-
-	 /*
-	 * Make the iio_dev struct available to remove function.
-	 * Bus equivalents
-	 * i2c_set_clientdata(client, indio_dev);
-	 * spi_set_drvdata(spi, indio_dev);
-	 */
-	iio_dummy_devs[index] = indio_dev;
-
-	/*
-	 * Set the device name.
-	 *
-	 * This is typically a part number and obtained from the module
-	 * id table.
-	 * e.g. for i2c and spi:
-	 *    indio_dev->name = id->name;
-	 *    indio_dev->name = spi_get_device_id(spi)->name;
-	 */
-	indio_dev->name = iio_dummy_part_number;
-
-	/* Provide description of available channels */
-	indio_dev->channels = iio_dummy_channels;
-	indio_dev->num_channels = ARRAY_SIZE(iio_dummy_channels);
-
-	/*
-	 * Provide device type specific interface functions and
-	 * constant data.
-	 */
-	indio_dev->info = &iio_dummy_info;
-
-	/* Specify that device provides sysfs type interfaces */
-	indio_dev->modes = INDIO_DIRECT_MODE;
-
-	ret = iio_simple_dummy_events_register(indio_dev);
-	if (ret < 0)
-		goto error_free_device;
-
-	ret = iio_simple_dummy_configure_buffer(indio_dev);
-	if (ret < 0)
-		goto error_unregister_events;
-
-	ret = iio_device_register(indio_dev);
-	if (ret < 0)
-		goto error_unconfigure_buffer;
-
-	return 0;
-error_unconfigure_buffer:
-	iio_simple_dummy_unconfigure_buffer(indio_dev);
-error_unregister_events:
-	iio_simple_dummy_events_unregister(indio_dev);
-error_free_device:
-	iio_device_free(indio_dev);
-error_ret:
-	return ret;
-}
-
-/**
- * iio_dummy_remove() - device instance removal function
- * @index: device index.
- *
- * Parameters follow those of iio_dummy_probe for buses.
- */
-static void iio_dummy_remove(int index)
-{
-	/*
-	 * Get a pointer to the device instance iio_dev structure
-	 * from the bus subsystem. E.g.
-	 * struct iio_dev *indio_dev = i2c_get_clientdata(client);
-	 * struct iio_dev *indio_dev = spi_get_drvdata(spi);
-	 */
-	struct iio_dev *indio_dev = iio_dummy_devs[index];
-
-	/* Unregister the device */
-	iio_device_unregister(indio_dev);
-
-	/* Device specific code to power down etc */
-
-	/* Buffered capture related cleanup */
-	iio_simple_dummy_unconfigure_buffer(indio_dev);
-
-	iio_simple_dummy_events_unregister(indio_dev);
-
-	/* Free all structures */
-	iio_device_free(indio_dev);
-}
-
-/**
- * iio_dummy_init() -  device driver registration
- *
- * Varies depending on bus type of the device. As there is no device
- * here, call probe directly. For information on device registration
- * i2c:
- * Documentation/i2c/writing-clients
- * spi:
- * Documentation/spi/spi-summary
- */
-static __init int iio_dummy_init(void)
-{
-	int i, ret;
-
-	if (instances > 10) {
-		instances = 1;
-		return -EINVAL;
-	}
-
-	/* Fake a bus */
-	iio_dummy_devs = kcalloc(instances, sizeof(*iio_dummy_devs),
-				 GFP_KERNEL);