staging:iio: allow channels to be set up using a table of iio_channel_spec structures. (1d892719) · Commits · 戴 / test

drivers/staging/iio/chrdev.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -91,6 +91,9 @@ struct iio_event_interface {
		void *private;
		char _name[35];
		char _attrname[20];

		struct list_head event_attr_list;
		struct list_head dev_attr_list;
		};

		/**

drivers/staging/iio/iio.h

+207 −1

Original line number	Diff line number	Diff line
		@@ -26,6 +26,161 @@

		struct iio_dev;

		/* naughty temporary hack to match these against the event version
		- need to flattern these together */
		enum iio_chan_type {
		/* Need this here for now to support buffer events
		* set to 0 to avoid changes to ring_generic.c */
		IIO_BUFFER = 0,

		/* real channel types */
		IIO_IN,
		IIO_ACCEL,
		IIO_IN_DIFF,
		IIO_GYRO,
		IIO_MAGN,
		IIO_LIGHT,
		IIO_INTENSITY,
		IIO_PROXIMITY,
		IIO_TEMP,
		IIO_INCLI,
		IIO_ROT,
		IIO_ANGL,
		IIO_TIMESTAMP,
		};

		#define IIO_MOD_X 0
		#define IIO_MOD_LIGHT_BOTH 0
		#define IIO_MOD_Y 1
		#define IIO_MOD_LIGHT_IR 1
		#define IIO_MOD_Z 2
		#define IIO_MOD_X_AND_Y 3
		#define IIO_MOD_X_ANX_Z 4
		#define IIO_MOD_Y_AND_Z 5
		#define IIO_MOD_X_AND_Y_AND_Z 6
		#define IIO_MOD_X_OR_Y 7
		#define IIO_MOD_X_OR_Z 8
		#define IIO_MOD_Y_OR_Z 9
		#define IIO_MOD_X_OR_Y_OR_Z 10

		/* Could add the raw attributes as well - allowing buffer only devices */
		enum iio_chan_info_enum {
		IIO_CHAN_INFO_SCALE_SHARED,
		IIO_CHAN_INFO_SCALE_SEPARATE,
		IIO_CHAN_INFO_OFFSET_SHARED,
		IIO_CHAN_INFO_OFFSET_SEPARATE,
		IIO_CHAN_INFO_CALIBSCALE_SHARED,
		IIO_CHAN_INFO_CALIBSCALE_SEPARATE,
		IIO_CHAN_INFO_CALIBBIAS_SHARED,
		IIO_CHAN_INFO_CALIBBIAS_SEPARATE
		};

		/**
		* struct iio_chan_spec - specification of a single channel
		* @type: What type of measurement is the channel making.
		* @channel: What number or name do we wish to asign the channel.
		* @channel2: If there is a second number for a differential
		* channel then this is it. If modified is set then the
		* value here specifies the modifier.
		* @address: Driver specific identifier.
		* @scan_index: Monotonic index to give ordering in scans when read
		* from a buffer.
		* @scan_type: Sign: 's' or 'u' to specify signed or unsigned
		* realbits: Number of valid bits of data
		* storage_bits: Realbits + padding
		* shift: Shift right by this before masking out
		* realbits.
		* @info_mask: What information is to be exported about this channel.
		* This includes calibbias, scale etc.
		* @event_mask: What events can this channel produce.
		* @extend_name: Allows labeling of channel attributes with an
		* informative name. Note this has no effect codes etc,
		* unlike modifiers.
		* @processed_val: Flag to specify the data access attribute should be
		* _input rather than _raw.
		* @modified: Does a modifier apply to this channel. What these are
		* depends on the channel type. Modifier is set in
		* channel2. Examples are IIO_MOD_X for axial sensors about
		* the 'x' axis.
		* @indexed: Specify the channel has a numerical index. If not,
		* the value in channel will be suppressed for attribute
		* but not for event codes. Typically set it to 0 when
		* the index is false.
		* @shared_handler: Single handler for the events registered.
		*/
		struct iio_chan_spec {
		enum iio_chan_type type;
		int channel;
		int channel2;
		unsigned long address;
		int scan_index;
		struct {
		char sign;
		u8 realbits;
		u8 storagebits;
		u8 shift;
		} scan_type;
		const long info_mask;
		const long event_mask;
		const char *extend_name;
		unsigned processed_val:1;
		unsigned modified:1;
		unsigned indexed:1;
		/* TODO: investigate pushing shared event handling out to
		* the drivers */
		struct iio_event_handler_list *shared_handler;
		};
		/* Meant for internal use only */
		void __iio_device_attr_deinit(struct device_attribute *dev_attr);
		int __iio_device_attr_init(struct device_attribute *dev_attr,
		const char *postfix,
		struct iio_chan_spec const *chan,
		ssize_t (readfunc)(struct device dev,
		struct device_attribute *attr,
		char *buf),
		ssize_t (writefunc)(struct device dev,
		struct device_attribute *attr,
		const char *buf,
		size_t len),
		bool generic);
		#define IIO_ST(si, rb, sb, sh) \
		{ .sign = si, .realbits = rb, .storagebits = sb, .shift = sh }

		#define IIO_CHAN(_type, _mod, _indexed, _proc, _name, _chan, _chan2, \
		_inf_mask, _address, _si, _stype, _event_mask, \
		_handler) \
		{ .type = _type, \
		.modified = _mod, \
		.indexed = _indexed, \
		.processed_val = _proc, \
		.extend_name = _name, \
		.channel = _chan, \
		.channel2 = _chan2, \
		.info_mask = _inf_mask, \
		.address = _address, \
		.scan_index = _si, \
		.scan_type = _stype, \
		.event_mask = _event_mask, \
		.shared_handler = _handler }

		#define IIO_CHAN_SOFT_TIMESTAMP(_si) \
		{ .type = IIO_TIMESTAMP, .channel = -1, \
		.scan_index = _si, .scan_type = IIO_ST('s', 64, 64, 0) }

		int __iio_add_chan_devattr(const char *postfix,
		const char *group,
		struct iio_chan_spec const *chan,
		ssize_t (func)(struct device dev,
		struct device_attribute *attr,
		char *buf),
		ssize_t (writefunc)(struct device dev,
		struct device_attribute *attr,
		const char *buf,
		size_t len),
		int mask,
		bool generic,
		struct device *dev,
		struct list_head *attr_list);
		/**
		* iio_get_time_ns() - utility function to get a time stamp for events etc
		**/
		@@ -70,7 +225,8 @@ void iio_remove_event_from_list(struct iio_event_handler_list *el,

		/* Vast majority of this is set by the industrialio subsystem on a
		* call to iio_device_register. */

		#define IIO_VAL_INT 1
		#define IIO_VAL_INT_PLUS_MICRO 2
		/**
		* struct iio_dev - industrial I/O device
		* @id: [INTERN] used to identify device internally
		@@ -93,6 +249,24 @@ void iio_remove_event_from_list(struct iio_event_handler_list *el,
		* @available_scan_masks: [DRIVER] optional array of allowed bitmasks
		* @trig: [INTERN] current device trigger (ring buffer modes)
		* @pollfunc: [DRIVER] function run on trigger being received
		* @channels: [DRIVER] channel specification structure table
		* @num_channels: [DRIVER] number of chanels specified in @channels.
		* @channel_attr_list: [INTERN] keep track of automatically created channel
		* attributes.
		* @name: [DRIVER] name of the device.
		* @read_raw: [DRIVER] function to request a value from the device.
		* mask specifies which value. Note 0 means a reading of
		* the channel in question. Return value will specify the
		* type of value returned by the device. val and val2 will
		* contain the elements making up the returned value.
		* @write_raw: [DRIVER] function to write a value to the device.
		* Parameters are the same as for read_raw.
		* @read_event_config: [DRIVER] find out if the event is enabled.
		* @write_event_config: [DRIVER] set if the event is enabled.
		* @read_event_value: [DRIVER] read a value associated with the event. Meaning
		* is event dependant. event_code specifies which event.
		* @write_event_value: [DRIVER] write the value associate with the event.
		* Meaning is event dependent.
		**/
		struct iio_dev {
		int id;
		@@ -116,6 +290,38 @@ struct iio_dev {
		u32 *available_scan_masks;
		struct iio_trigger *trig;
		struct iio_poll_func *pollfunc;

		struct iio_chan_spec const *channels;
		int num_channels;
		struct list_head channel_attr_list;

		char name; /device name - IMPLEMENT */
		int (read_raw)(struct iio_dev indio_dev,
		struct iio_chan_spec const *chan,
		int *val,
		int *val2,
		long mask);

		int (write_raw)(struct iio_dev indio_dev,
		struct iio_chan_spec const *chan,
		int val,
		int val2,
		long mask);

		int (read_event_config)(struct iio_dev indio_dev,
		int event_code);

		int (write_event_config)(struct iio_dev indio_dev,
		int event_code,
		struct iio_event_handler_list *listel,
		int state);

		int (read_event_value)(struct iio_dev indio_dev,
		int event_code,
		int *val);
		int (write_event_value)(struct iio_dev indio_dev,
		int event_code,
		int val);
		};

		/**

drivers/staging/iio/industrialio-core.c

+712 −26

File changed.

Preview size limit exceeded, changes collapsed.

drivers/staging/iio/industrialio-ring.c

+181 −7

Original line number	Diff line number	Diff line
		@@ -233,9 +233,162 @@ void iio_ring_buffer_init(struct iio_ring_buffer *ring,
		}
		EXPORT_SYMBOL(iio_ring_buffer_init);

		int iio_ring_buffer_register(struct iio_ring_buffer *ring, int id)
		static ssize_t iio_show_scan_index(struct device *dev,
		struct device_attribute *attr,
		char *buf)
		{
		struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
		return sprintf(buf, "%u\n", this_attr->c->scan_index);
		}

		static ssize_t iio_show_fixed_type(struct device *dev,
		struct device_attribute *attr,
		char *buf)
		{
		struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
		return sprintf(buf, "%c%d/%d>>%u\n",
		this_attr->c->scan_type.sign,
		this_attr->c->scan_type.realbits,
		this_attr->c->scan_type.storagebits,
		this_attr->c->scan_type.shift);
		}

		static int __iio_add_chan_scan_elattr(const char *postfix,
		const char *group,
		const struct iio_chan_spec *chan,
		struct device *dev,
		struct list_head *attr_list)
		{
		int ret;
		struct iio_scan_el *scan_el;

		scan_el = kzalloc(sizeof *scan_el, GFP_KERNEL);
		if (scan_el == NULL) {
		ret = -ENOMEM;
		goto error_ret;
		}
		if (chan->type != IIO_TIMESTAMP)
		ret = __iio_device_attr_init(&scan_el->dev_attr, postfix, chan,
		iio_scan_el_show,
		iio_scan_el_store, 0);
		else /*
		* Timestamp handled separately because it simplifies a lot of
		* drivers by ensuring they don't have to know its magic index
		*/
		ret = __iio_device_attr_init(&scan_el->dev_attr, postfix, chan,
		iio_scan_el_ts_show,
		iio_scan_el_ts_store, 0);
		if (ret)
		goto error_free_scan_el;

		scan_el->number = chan->scan_index;

		ret = sysfs_add_file_to_group(&dev->kobj,
		&scan_el->dev_attr.attr,
		group);
		if (ret < 0)
		goto error_device_attr_deinit;

		list_add(&scan_el->l, attr_list);

		return 0;
		error_device_attr_deinit:
		__iio_device_attr_deinit(&scan_el->dev_attr);
		error_free_scan_el:
		kfree(scan_el);
		error_ret:
		return ret;
		}

		static int iio_ring_add_channel_sysfs(struct iio_ring_buffer *ring,
		const struct iio_chan_spec *chan)
		{
		int ret;

		ret = __iio_add_chan_devattr("index", "scan_elements",
		chan,
		&iio_show_scan_index,
		NULL,
		0,
		0,
		&ring->dev,
		&ring->scan_el_dev_attr_list);
		if (ret)
		goto error_ret;

		ret = __iio_add_chan_devattr("type", "scan_elements",
		chan,
		&iio_show_fixed_type,
		NULL,
		0,
		0,
		&ring->dev,
		&ring->scan_el_dev_attr_list);

		if (ret)
		goto error_ret;

		ret = __iio_add_chan_scan_elattr("en", "scan_elements",
		chan, &ring->dev,
		&ring->scan_el_en_attr_list);

		error_ret:
		return ret;
		}

		static void iio_ring_remove_and_free_scan_el_attr(struct iio_ring_buffer *ring,
		struct iio_scan_el *p)
		{
		sysfs_remove_file_from_group(&ring->dev.kobj,
		&p->dev_attr.attr, "scan_elements");
		kfree(p->dev_attr.attr.name);
		kfree(p);
		}

		static void iio_ring_remove_and_free_scan_dev_attr(struct iio_ring_buffer *ring,
		struct iio_dev_attr *p)
		{
		sysfs_remove_file_from_group(&ring->dev.kobj,
		&p->dev_attr.attr, "scan_elements");
		kfree(p->dev_attr.attr.name);
		kfree(p);
		}

		static struct attribute *iio_scan_el_dummy_attrs[] = {
		NULL
		};

		static struct attribute_group iio_scan_el_dummy_group = {
		.name = "scan_elements",
		.attrs = iio_scan_el_dummy_attrs
		};

		static void __iio_ring_attr_cleanup(struct iio_ring_buffer *ring)
		{
		struct iio_dev_attr p, n;
		struct iio_scan_el q, m;
		int anydynamic = !(list_empty(&ring->scan_el_dev_attr_list) &&
		list_empty(&ring->scan_el_en_attr_list));
		list_for_each_entry_safe(p, n,
		&ring->scan_el_dev_attr_list, l)
		iio_ring_remove_and_free_scan_dev_attr(ring, p);
		list_for_each_entry_safe(q, m,
		&ring->scan_el_en_attr_list, l)
		iio_ring_remove_and_free_scan_el_attr(ring, q);

		if (ring->scan_el_attrs)
		sysfs_remove_group(&ring->dev.kobj,
		ring->scan_el_attrs);
		else if (anydynamic)
		sysfs_remove_group(&ring->dev.kobj,
		&iio_scan_el_dummy_group);
		}

		int iio_ring_buffer_register_ex(struct iio_ring_buffer *ring, int id,
		const struct iio_chan_spec *channels,
		int num_channels)
		{
		int ret, i;

		ring->id = id;

		@@ -268,9 +421,28 @@ int iio_ring_buffer_register(struct iio_ring_buffer *ring, int id)
		"Failed to add sysfs scan elements\n");
		goto error_free_ring_buffer_event_chrdev;
		}
		} else if (channels) {
		ret = sysfs_create_group(&ring->dev.kobj,
		&iio_scan_el_dummy_group);
		if (ret)
		goto error_free_ring_buffer_event_chrdev;
		}

		return ret;

		INIT_LIST_HEAD(&ring->scan_el_dev_attr_list);
		INIT_LIST_HEAD(&ring->scan_el_en_attr_list);
		if (channels) {
		/* new magic */
		for (i = 0; i < num_channels; i++) {
		ret = iio_ring_add_channel_sysfs(ring, &channels[i]);
		if (ret < 0)
		goto error_cleanup_dynamic;
		}
		}

		return 0;
		error_cleanup_dynamic:
		__iio_ring_attr_cleanup(ring);
		error_free_ring_buffer_event_chrdev:
		__iio_free_ring_buffer_event_chrdev(ring);
		error_remove_device:
		@@ -278,14 +450,17 @@ error_remove_device:
		error_ret:
		return ret;
		}
		EXPORT_SYMBOL(iio_ring_buffer_register_ex);

		int iio_ring_buffer_register(struct iio_ring_buffer *ring, int id)
		{
		return iio_ring_buffer_register_ex(ring, id, NULL, 0);
		}
		EXPORT_SYMBOL(iio_ring_buffer_register);

		void iio_ring_buffer_unregister(struct iio_ring_buffer *ring)
		{
		if (ring->scan_el_attrs)
		sysfs_remove_group(&ring->dev.kobj,
		ring->scan_el_attrs);

		__iio_ring_attr_cleanup(ring);
		__iio_free_ring_buffer_access_chrdev(ring);
		__iio_free_ring_buffer_event_chrdev(ring);
		device_del(&ring->dev);
		@@ -540,4 +715,3 @@ error_ret:
		return ret ? ret : len;
		}
		EXPORT_SYMBOL(iio_scan_el_ts_store);

drivers/staging/iio/ring_generic.h

+20 −0

Original line number	Diff line number	Diff line
		@@ -140,6 +140,8 @@ struct iio_ring_buffer {
		int (predisable)(struct iio_dev );
		int (postdisable)(struct iio_dev );

		struct list_head scan_el_dev_attr_list;
		struct list_head scan_el_en_attr_list;
		};

		/**
		@@ -177,6 +179,7 @@ struct iio_scan_el {
		struct device_attribute dev_attr;
		unsigned int number;
		unsigned int label;
		struct list_head l;

		int (set_state)(struct iio_scan_el scanel,
		struct iio_dev *dev_info,
		@@ -430,6 +433,14 @@ static inline void iio_put_ring_buffer(struct iio_ring_buffer *ring)
		**/
		int iio_ring_buffer_register(struct iio_ring_buffer *ring, int id);

		/** iio_ring_buffer_register_ex() - register the buffer with IIO core
		* @ring: the buffer to be registered
		* @id: the id of the buffer (typically 0)
		**/
		int iio_ring_buffer_register_ex(struct iio_ring_buffer *ring, int id,
		const struct iio_chan_spec *channels,
		int num_channels);

		/**
		* iio_ring_buffer_unregister() - unregister the buffer from IIO core
		* @ring: the buffer to be unregistered
		@@ -481,6 +492,15 @@ static inline int iio_ring_buffer_register(struct iio_ring_buffer *ring, int id)
		{
		return 0;
		};

		static inline int iio_ring_buffer_register_ex(struct iio_ring_buffer *ring,
		int id,
		struct iio_chan_spec *channels,
		int num_channels)
		{
		return 0;
		}

		static inline void iio_ring_buffer_unregister(struct iio_ring_buffer *ring)
		{};

Admin message