Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1d892719 authored by Jonathan Cameron's avatar Jonathan Cameron Committed by Greg Kroah-Hartman
Browse files

staging:iio: allow channels to be set up using a table of iio_channel_spec structures. 



V8: Add missing address in IIO_CHAN macro. Spotted by Michael Hennerich.
V7: Document additions to iio_dev structure.
V6: Fixup the docs for iio_chan_spec structure.
V5: Actually have the macro handle the _input type channels (oops)
V4: Add ability to do, _input and modified channel naming in a coherent fashion.
    Scrap all the messy IIO_CHAN_* macros and move to only one.

V3: Added more types - intensity and light.

V2: Various fixes - some thanks to Arnd.
    Bug fix for unregistering of event attr group
    Changed iio_read_channel_info to have two part value - use for
    raw value read as well.
    constify the channelspec structures
    raw write support for calibbias and similar
    Additional strings for buidling attribute names.

Signed-off-by: default avatarJonathan Cameron <jic23@cam.ac.uk>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 32890b98

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)

{};