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

};



/**