[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / iio / sysfs.h

/* The industrial I/O core
 *
 *Copyright (c) 2008 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.
 *
 * General attributes
 */

#ifndef _INDUSTRIAL_IO_SYSFS_H_
#define _INDUSTRIAL_IO_SYSFS_H_

#include "iio.h"

/**
 * struct iio_event_attr - event control attribute
 * @dev_attr:	underlying device attribute
 * @mask:	mask for the event when detecting
 * @listel:	list header to allow addition to list of event handlers
*/
struct iio_event_attr {
	struct device_attribute dev_attr;
	int mask;
	struct iio_event_handler_list *listel;
};

#define to_iio_event_attr(_dev_attr) \
	container_of(_dev_attr, struct iio_event_attr, dev_attr)

/**
 * struct iio_chrdev_minor_attr - simple attribute to allow reading of chrdev
 *				minor number
 * @dev_attr:	underlying device attribute
 * @minor:	the minor number
 */
struct iio_chrdev_minor_attr {
	struct device_attribute dev_attr;
	int minor;
};

void
__init_iio_chrdev_minor_attr(struct iio_chrdev_minor_attr *minor_attr,
			   const char *name,
			   struct module *owner,
			   int id);


#define to_iio_chrdev_minor_attr(_dev_attr) \
	container_of(_dev_attr, struct iio_chrdev_minor_attr, dev_attr);

/**
 * struct iio_dev_attr - iio specific device attribute
 * @dev_attr:	underlying device attribute
 * @address:	associated register address
 * @val2:	secondary attribute value
 */
struct iio_dev_attr {
	struct device_attribute dev_attr;
	int address;
	int val2;
};

#define to_iio_dev_attr(_dev_attr)				\
	container_of(_dev_attr, struct iio_dev_attr, dev_attr)

ssize_t iio_read_const_attr(struct device *dev,
			    struct device_attribute *attr,
			    char *len);

/**
 * struct iio_const_attr - constant device specific attribute
 *                         often used for things like available modes
 * @string:	attribute string
 * @dev_attr:	underlying device attribute
 */
struct iio_const_attr {
	const char *string;
	struct device_attribute dev_attr;
};

#define to_iio_const_attr(_dev_attr) \
	container_of(_dev_attr, struct iio_const_attr, dev_attr)

/* Some attributes will be hard coded (device dependent) and not require an
   address, in these cases pass a negative */
#define IIO_ATTR(_name, _mode, _show, _store, _addr)		\
	{ .dev_attr = __ATTR(_name, _mode, _show, _store),	\
	  .address = _addr }

#define IIO_ATTR_2(_name, _mode, _show, _store, _addr, _val2)	\
	{ .dev_attr = __ATTR(_name, _mode, _show, _store),	\
			.address = _addr,			\
			.val2 = _val2 }

#define IIO_DEVICE_ATTR(_name, _mode, _show, _store, _addr)	\
	struct iio_dev_attr iio_dev_attr_##_name		\
	= IIO_ATTR(_name, _mode, _show, _store, _addr)

#define IIO_DEVICE_ATTR_NAMED(_vname, _name, _mode, _show, _store, _addr) \
	struct iio_dev_attr iio_dev_attr_##_vname			\
	= IIO_ATTR(_name, _mode, _show, _store, _addr)

#define IIO_DEVICE_ATTR_2(_name, _mode, _show, _store, _addr, _val2)	\
	struct iio_dev_attr iio_dev_attr_##_name			\
	= IIO_ATTR_2(_name, _mode, _show, _store, _addr, _val2)

#define IIO_CONST_ATTR(_name, _string)					\
	struct iio_const_attr iio_const_attr_##_name			\
	= { .string = _string,						\
	    .dev_attr = __ATTR(_name, S_IRUGO, iio_read_const_attr, NULL)}

/* Generic attributes of onetype or another */

/**
 * IIO_DEV_ATTR_REV - revision number for the device
 * @_show: output method for the attribute
 *
 * Very much device dependent.
 **/
#define IIO_DEV_ATTR_REV(_show)			\
	IIO_DEVICE_ATTR(revision, S_IRUGO, _show, NULL, 0)

/**
 * IIO_DEV_ATTR_NAME - chip type dependent identifier
 * @_show: output method for the attribute
 **/
#define IIO_DEV_ATTR_NAME(_show)				\
	IIO_DEVICE_ATTR(name, S_IRUGO, _show, NULL, 0)

/**
 * IIO_DEV_ATTR_SAMP_FREQ - sets any internal clock frequency
 * @_mode: sysfs file mode/permissions
 * @_show: output method for the attribute
 * @_store: input method for the attribute
 **/
#define IIO_DEV_ATTR_SAMP_FREQ(_mode, _show, _store)			\
	IIO_DEVICE_ATTR(sampling_frequency, _mode, _show, _store, 0)

/**
 * IIO_DEV_ATTR_AVAIL_SAMP_FREQ - list available sampling frequencies
 * @_show: output method for the attribute
 *
 * May be mode dependent on some devices
 **/
/* Deprecated */
#define IIO_DEV_ATTR_AVAIL_SAMP_FREQ(_show)				\
	IIO_DEVICE_ATTR(available_sampling_frequency, S_IRUGO, _show, NULL, 0)

#define IIO_DEV_ATTR_SAMP_FREQ_AVAIL(_show)				\
	IIO_DEVICE_ATTR(sampling_frequency_available, S_IRUGO, _show, NULL, 0)
/**
 * IIO_CONST_ATTR_AVAIL_SAMP_FREQ - list available sampling frequencies
 * @_string: frequency string for the attribute
 *
 * Constant version
 **/
/* Deprecated */
#define IIO_CONST_ATTR_AVAIL_SAMP_FREQ(_string)			\
	IIO_CONST_ATTR(available_sampling_frequency, _string)

#define IIO_CONST_ATTR_SAMP_FREQ_AVAIL(_string)			\
	IIO_CONST_ATTR(sampling_frequency_available, _string)

/**
 * IIO_DEV_ATTR_SCAN_MODE - select a scan mode
 * @_mode: sysfs file mode/permissions
 * @_show: output method for the attribute
 * @_store: input method for the attribute
 *
 * This is used when only certain combinations of inputs may be read in one
 * scan.
 **/
#define IIO_DEV_ATTR_SCAN_MODE(_mode, _show, _store)		\
	IIO_DEVICE_ATTR(scan_mode, _mode, _show, _store, 0)

/**
 * IIO_DEV_ATTR_AVAIL_SCAN_MODES - list available scan modes
 * @_show: output method for the attribute
 **/
#define IIO_DEV_ATTR_AVAIL_SCAN_MODES(_show)				\
	IIO_DEVICE_ATTR(available_scan_modes, S_IRUGO, _show, NULL, 0)

/**
 * IIO_DEV_ATTR_SCAN - result of scan of multiple channels
 * @_show: output method for the attribute
 **/
#define IIO_DEV_ATTR_SCAN(_show)		\
	IIO_DEVICE_ATTR(scan, S_IRUGO, _show, NULL, 0);

/**
 * IIO_DEV_ATTR_INPUT - direct read of a single input channel
 * @_number: input channel number
 * @_show: output method for the attribute
 **/
#define IIO_DEV_ATTR_INPUT(_number, _show)				\
	IIO_DEVICE_ATTR(in##_number, S_IRUGO, _show, NULL, _number)

/**
 * IIO_DEV_ATTR_SW_RING_ENABLE - enable software ring buffer
 * @_show: output method for the attribute
 * @_store: input method for the attribute
 *
 * Success may be dependent on attachment of trigger previously.
 **/
#define IIO_DEV_ATTR_SW_RING_ENABLE(_show, _store)			\
	IIO_DEVICE_ATTR(sw_ring_enable, S_IRUGO | S_IWUSR, _show, _store, 0)

/**
 * IIO_DEV_ATTR_HW_RING_ENABLE - enable hardware ring buffer
 * @_show: output method for the attribute
 * @_store: input method for the attribute
 *
 * This is a different attribute from the software one as one can envision
 * schemes where a combination of the two may be used.
 **/
#define IIO_DEV_ATTR_HW_RING_ENABLE(_show, _store)			\
	IIO_DEVICE_ATTR(hw_ring_enable, S_IRUGO | S_IWUSR, _show, _store, 0)

/**
 * IIO_DEV_ATTR_BPSE - set number of bits per scan element
 * @_mode: sysfs file mode/permissions
 * @_show: output method for the attribute
 * @_store: input method for the attribute
 **/
#define IIO_DEV_ATTR_BPSE(_mode, _show, _store)		\
	IIO_DEVICE_ATTR(bpse, _mode, _show, _store, 0)

/**
 * IIO_DEV_ATTR_BPSE_AVAILABLE - number of bits per scan element supported
 * @_show: output method for the attribute
 **/
#define IIO_DEV_ATTR_BPSE_AVAILABLE(_show)				\
	IIO_DEVICE_ATTR(bpse_available, S_IRUGO, _show, NULL, 0)

/**
 * IIO_DEV_ATTR_TEMP - many sensors have auxiliary temperature sensors
 * @_show: output method for the attribute
 **/
#define IIO_DEV_ATTR_TEMP(_show)			\
	IIO_DEVICE_ATTR(temp, S_IRUGO, _show, NULL, 0)

#define IIO_DEV_ATTR_TEMP_RAW(_show)			\
	IIO_DEVICE_ATTR(temp_raw, S_IRUGO, _show, NULL, 0)

/**
 * IIO_EVENT_SH - generic shared event handler
 * @_name: event name
 * @_handler: handler function to be called
 *
 * This is used in cases where more than one event may result from a single
 * handler.  Often the case that some alarm register must be read and multiple
 * alarms may have been triggered.
 **/
#define IIO_EVENT_SH(_name, _handler)					\
	static struct iio_event_handler_list				\
	iio_event_##_name = {						\
		.handler = _handler,					\
		.refcount = 0,						\
		.exist_lock = __MUTEX_INITIALIZER(iio_event_##_name	\
						  .exist_lock),		\
		.list = {						\
			.next = &iio_event_##_name.list,		\
			.prev = &iio_event_##_name.list,		\
		},							\
	};

/**
 * IIO_EVENT_ATTR_SH - generic shared event attribute
 * @_name: event name
 * @_ev_list: event handler list
 * @_show: output method for the attribute
 * @_store: input method for the attribute
 * @_mask: mask used when detecting the event
 *
 * An attribute with an associated IIO_EVENT_SH
 **/
#define IIO_EVENT_ATTR_SH(_name, _ev_list, _show, _store, _mask)	\
	static struct iio_event_attr					\
	iio_event_attr_##_name						\
	= { .dev_attr = __ATTR(_name, S_IRUGO | S_IWUSR,		\
			       _show, _store),				\
	    .mask = _mask,						\
	    .listel = &_ev_list };

/**
 * IIO_EVENT_ATTR - non-shared event attribute
 * @_name: event name
 * @_show: output method for the attribute
 * @_store: input method for the attribute
 * @_mask: mask used when detecting the event
 * @_handler: handler function to be called
 **/
#define IIO_EVENT_ATTR(_name, _show, _store, _mask, _handler)		\
	static struct iio_event_handler_list				\
	iio_event_##_name = {						\
		.handler = _handler,					\
	};								\
	static struct							\
	iio_event_attr							\
	iio_event_attr_##_name						\
	= { .dev_attr = __ATTR(_name, S_IRUGO | S_IWUSR,		\
			       _show, _store),				\
	    .mask = _mask,						\
	    .listel = &iio_event_##_name };				\

/**
 * IIO_EVENT_ATTR_DATA_RDY - event driven by data ready signal
 * @_show: output method for the attribute
 * @_store: input method for the attribute
 * @_mask: mask used when detecting the event
 * @_handler: handler function to be called
 *
 * Not typically implemented in devices where full triggering support
 * has been implemented.
 **/
#define IIO_EVENT_ATTR_DATA_RDY(_show, _store, _mask, _handler) \
	IIO_EVENT_ATTR(data_rdy, _show, _store, _mask, _handler)

#define IIO_EVENT_CODE_DATA_RDY		100
#define IIO_EVENT_CODE_RING_BASE	200
#define IIO_EVENT_CODE_ACCEL_BASE	300
#define IIO_EVENT_CODE_GYRO_BASE	400
#define IIO_EVENT_CODE_ADC_BASE		500
#define IIO_EVENT_CODE_MISC_BASE	600

#define IIO_EVENT_CODE_DEVICE_SPECIFIC	1000

/**
 * IIO_EVENT_ATTR_RING_50_FULL - ring buffer event to indicate 50% full
 * @_show: output method for the attribute
 * @_store: input method for the attribute
 * @_mask: mask used when detecting the event
 * @_handler: handler function to be called
 **/
#define IIO_EVENT_ATTR_RING_50_FULL(_show, _store, _mask, _handler)	\
	IIO_EVENT_ATTR(ring_50_full, _show, _store, _mask, _handler)

/**
 * IIO_EVENT_ATTR_RING_50_FULL_SH - shared ring event to indicate 50% full
 * @_evlist: event handler list
 * @_show: output method for the attribute
 * @_store: input method for the attribute
 * @_mask: mask used when detecting the event
 **/
#define IIO_EVENT_ATTR_RING_50_FULL_SH(_evlist, _show, _store, _mask)	\
	IIO_EVENT_ATTR_SH(ring_50_full, _evlist, _show, _store, _mask)

/**
 * IIO_EVENT_ATTR_RING_75_FULL_SH - shared ring event to indicate 75% full
 * @_evlist: event handler list
 * @_show: output method for the attribute
 * @_store: input method for the attribute
 * @_mask: mask used when detecting the event
 **/
#define IIO_EVENT_ATTR_RING_75_FULL_SH(_evlist, _show, _store, _mask)	\
	IIO_EVENT_ATTR_SH(ring_75_full, _evlist, _show, _store, _mask)

#define IIO_EVENT_CODE_RING_50_FULL	IIO_EVENT_CODE_RING_BASE
#define IIO_EVENT_CODE_RING_75_FULL	(IIO_EVENT_CODE_RING_BASE + 1)
#define IIO_EVENT_CODE_RING_100_FULL	(IIO_EVENT_CODE_RING_BASE + 2)

#endif /* _INDUSTRIAL_IO_SYSFS_H_ */
Commit	Line	Data
847ec80b JC	1	/* The industrial I/O core
	2	*
	3	*Copyright (c) 2008 Jonathan Cameron
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 as published by
	7	* the Free Software Foundation.
	8	*
	9	* General attributes
	10	*/
	11
	12	#ifndef _INDUSTRIAL_IO_SYSFS_H_
	13	#define _INDUSTRIAL_IO_SYSFS_H_
	14
	15	#include "iio.h"
	16
	17	/**
4c572605	18	* struct iio_event_attr - event control attribute
847ec80b JC	19	* @dev_attr: underlying device attribute
	20	* @mask: mask for the event when detecting
	21	* @listel: list header to allow addition to list of event handlers
	22	*/
	23	struct iio_event_attr {
	24	struct device_attribute dev_attr;
	25	int mask;
	26	struct iio_event_handler_list *listel;
	27	};
	28
	29	#define to_iio_event_attr(_dev_attr) \
	30	container_of(_dev_attr, struct iio_event_attr, dev_attr)
	31
	32	/**
	33	* struct iio_chrdev_minor_attr - simple attribute to allow reading of chrdev
	34	* minor number
	35	* @dev_attr: underlying device attribute
	36	* @minor: the minor number
	37	*/
	38	struct iio_chrdev_minor_attr {
	39	struct device_attribute dev_attr;
	40	int minor;
	41	};
	42
	43	void
	44	__init_iio_chrdev_minor_attr(struct iio_chrdev_minor_attr *minor_attr,
	45	const char *name,
	46	struct module *owner,
	47	int id);
	48
	49
	50	#define to_iio_chrdev_minor_attr(_dev_attr) \
	51	container_of(_dev_attr, struct iio_chrdev_minor_attr, dev_attr);
	52
	53	/**
	54	* struct iio_dev_attr - iio specific device attribute
	55	* @dev_attr: underlying device attribute
	56	* @address: associated register address
4c572605	57	* @val2: secondary attribute value
847ec80b JC	58	*/
	59	struct iio_dev_attr {
	60	struct device_attribute dev_attr;
	61	int address;
	62	int val2;
	63	};
	64
	65	#define to_iio_dev_attr(_dev_attr) \
	66	container_of(_dev_attr, struct iio_dev_attr, dev_attr)
	67
	68	ssize_t iio_read_const_attr(struct device *dev,
	69	struct device_attribute *attr,
	70	char *len);
	71
	72	/**
	73	* struct iio_const_attr - constant device specific attribute
	74	* often used for things like available modes
4c572605 RD	75	* @string: attribute string
4c572605 RD	76	* @dev_attr: underlying device attribute
847ec80b JC	77	*/
	78	struct iio_const_attr {
	79	const char *string;
	80	struct device_attribute dev_attr;
	81	};
	82
	83	#define to_iio_const_attr(_dev_attr) \
	84	container_of(_dev_attr, struct iio_const_attr, dev_attr)
	85
4c572605	86	/* Some attributes will be hard coded (device dependent) and not require an
847ec80b JC	87	address, in these cases pass a negative */
	88	#define IIO_ATTR(_name, _mode, _show, _store, _addr) \
	89	{ .dev_attr = __ATTR(_name, _mode, _show, _store), \
	90	.address = _addr }
	91
	92	#define IIO_ATTR_2(_name, _mode, _show, _store, _addr, _val2) \
	93	{ .dev_attr = __ATTR(_name, _mode, _show, _store), \
	94	.address = _addr, \
	95	.val2 = _val2 }
	96
	97	#define IIO_DEVICE_ATTR(_name, _mode, _show, _store, _addr) \
	98	struct iio_dev_attr iio_dev_attr_##_name \
	99	= IIO_ATTR(_name, _mode, _show, _store, _addr)
	100
ad313b10 JC	101	#define IIO_DEVICE_ATTR_NAMED(_vname, _name, _mode, _show, _store, _addr) \
	102	struct iio_dev_attr iio_dev_attr_##_vname \
	103	= IIO_ATTR(_name, _mode, _show, _store, _addr)
847ec80b JC	104
	105	#define IIO_DEVICE_ATTR_2(_name, _mode, _show, _store, _addr, _val2) \
	106	struct iio_dev_attr iio_dev_attr_##_name \
	107	= IIO_ATTR_2(_name, _mode, _show, _store, _addr, _val2)
	108
	109	#define IIO_CONST_ATTR(_name, _string) \
	110	struct iio_const_attr iio_const_attr_##_name \
	111	= { .string = _string, \
	112	.dev_attr = __ATTR(_name, S_IRUGO, iio_read_const_attr, NULL)}
	113
	114	/* Generic attributes of onetype or another */
	115
	116	/**
4c572605 RD	117	* IIO_DEV_ATTR_REV - revision number for the device
4c572605 RD	118	* @_show: output method for the attribute
847ec80b JC	119	*
	120	* Very much device dependent.
	121	**/
	122	#define IIO_DEV_ATTR_REV(_show) \
	123	IIO_DEVICE_ATTR(revision, S_IRUGO, _show, NULL, 0)
4c572605	124
847ec80b	125	/**
4c572605 RD	126	* IIO_DEV_ATTR_NAME - chip type dependent identifier
4c572605 RD	127	* @_show: output method for the attribute
847ec80b JC	128	**/
	129	#define IIO_DEV_ATTR_NAME(_show) \
	130	IIO_DEVICE_ATTR(name, S_IRUGO, _show, NULL, 0)
	131
	132	/**
4c572605 RD	133	* IIO_DEV_ATTR_SAMP_FREQ - sets any internal clock frequency
	134	* @_mode: sysfs file mode/permissions
	135	* @_show: output method for the attribute
	136	* @_store: input method for the attribute
847ec80b JC	137	**/
	138	#define IIO_DEV_ATTR_SAMP_FREQ(_mode, _show, _store) \
	139	IIO_DEVICE_ATTR(sampling_frequency, _mode, _show, _store, 0)
	140
	141	/**
4c572605 RD	142	* IIO_DEV_ATTR_AVAIL_SAMP_FREQ - list available sampling frequencies
4c572605 RD	143	* @_show: output method for the attribute
847ec80b	144	*
4c572605	145	* May be mode dependent on some devices
847ec80b	146	**/
ff7723e2	147	/* Deprecated */
847ec80b JC	148	#define IIO_DEV_ATTR_AVAIL_SAMP_FREQ(_show) \
	149	IIO_DEVICE_ATTR(available_sampling_frequency, S_IRUGO, _show, NULL, 0)
	150
ff7723e2 JC	151	#define IIO_DEV_ATTR_SAMP_FREQ_AVAIL(_show) \
ff7723e2 JC	152	IIO_DEVICE_ATTR(sampling_frequency_available, S_IRUGO, _show, NULL, 0)
847ec80b	153	/**
4c572605 RD	154	* IIO_CONST_ATTR_AVAIL_SAMP_FREQ - list available sampling frequencies
4c572605 RD	155	* @_string: frequency string for the attribute
847ec80b JC	156	*
	157	* Constant version
	158	**/
ff7723e2 JC	159	/* Deprecated */
ff7723e2 JC	160	#define IIO_CONST_ATTR_AVAIL_SAMP_FREQ(_string) \
847ec80b	161	IIO_CONST_ATTR(available_sampling_frequency, _string)
4c572605	162
ff7723e2 JC	163	#define IIO_CONST_ATTR_SAMP_FREQ_AVAIL(_string) \
	164	IIO_CONST_ATTR(sampling_frequency_available, _string)
	165
847ec80b	166	/**
4c572605 RD	167	* IIO_DEV_ATTR_SCAN_MODE - select a scan mode
	168	* @_mode: sysfs file mode/permissions
	169	* @_show: output method for the attribute
	170	* @_store: input method for the attribute
847ec80b JC	171	*
	172	* This is used when only certain combinations of inputs may be read in one
	173	* scan.
	174	**/
	175	#define IIO_DEV_ATTR_SCAN_MODE(_mode, _show, _store) \
	176	IIO_DEVICE_ATTR(scan_mode, _mode, _show, _store, 0)
4c572605	177
847ec80b	178	/**
4c572605 RD	179	* IIO_DEV_ATTR_AVAIL_SCAN_MODES - list available scan modes
4c572605 RD	180	* @_show: output method for the attribute
847ec80b JC	181	**/
	182	#define IIO_DEV_ATTR_AVAIL_SCAN_MODES(_show) \
	183	IIO_DEVICE_ATTR(available_scan_modes, S_IRUGO, _show, NULL, 0)
	184
	185	/**
4c572605 RD	186	* IIO_DEV_ATTR_SCAN - result of scan of multiple channels
4c572605 RD	187	* @_show: output method for the attribute
847ec80b JC	188	**/
	189	#define IIO_DEV_ATTR_SCAN(_show) \
	190	IIO_DEVICE_ATTR(scan, S_IRUGO, _show, NULL, 0);
	191
	192	/**
4c572605 RD	193	* IIO_DEV_ATTR_INPUT - direct read of a single input channel
	194	* @_number: input channel number
	195	* @_show: output method for the attribute
847ec80b JC	196	**/
	197	#define IIO_DEV_ATTR_INPUT(_number, _show) \
	198	IIO_DEVICE_ATTR(in##_number, S_IRUGO, _show, NULL, _number)
	199
847ec80b	200	/**
4c572605 RD	201	* IIO_DEV_ATTR_SW_RING_ENABLE - enable software ring buffer
	202	* @_show: output method for the attribute
	203	* @_store: input method for the attribute
847ec80b	204	*
4c572605	205	* Success may be dependent on attachment of trigger previously.
847ec80b JC	206	**/
	207	#define IIO_DEV_ATTR_SW_RING_ENABLE(_show, _store) \
	208	IIO_DEVICE_ATTR(sw_ring_enable, S_IRUGO \| S_IWUSR, _show, _store, 0)
	209
	210	/**
4c572605 RD	211	* IIO_DEV_ATTR_HW_RING_ENABLE - enable hardware ring buffer
	212	* @_show: output method for the attribute
	213	* @_store: input method for the attribute
847ec80b	214	*
4c572605	215	* This is a different attribute from the software one as one can envision
847ec80b JC	216	* schemes where a combination of the two may be used.
	217	**/
	218	#define IIO_DEV_ATTR_HW_RING_ENABLE(_show, _store) \
	219	IIO_DEVICE_ATTR(hw_ring_enable, S_IRUGO \| S_IWUSR, _show, _store, 0)
	220
	221	/**
4c572605 RD	222	* IIO_DEV_ATTR_BPSE - set number of bits per scan element
	223	* @_mode: sysfs file mode/permissions
	224	* @_show: output method for the attribute
	225	* @_store: input method for the attribute
847ec80b JC	226	**/
	227	#define IIO_DEV_ATTR_BPSE(_mode, _show, _store) \
	228	IIO_DEVICE_ATTR(bpse, _mode, _show, _store, 0)
	229
	230	/**
4c572605 RD	231	* IIO_DEV_ATTR_BPSE_AVAILABLE - number of bits per scan element supported
4c572605 RD	232	* @_show: output method for the attribute
847ec80b JC	233	**/
	234	#define IIO_DEV_ATTR_BPSE_AVAILABLE(_show) \
	235	IIO_DEVICE_ATTR(bpse_available, S_IRUGO, _show, NULL, 0)
	236
	237	/**
4c572605 RD	238	* IIO_DEV_ATTR_TEMP - many sensors have auxiliary temperature sensors
4c572605 RD	239	* @_show: output method for the attribute
847ec80b JC	240	**/
	241	#define IIO_DEV_ATTR_TEMP(_show) \
	242	IIO_DEVICE_ATTR(temp, S_IRUGO, _show, NULL, 0)
4c572605	243
ff7723e2 JC	244	#define IIO_DEV_ATTR_TEMP_RAW(_show) \
	245	IIO_DEVICE_ATTR(temp_raw, S_IRUGO, _show, NULL, 0)
	246
847ec80b	247	/**
4c572605 RD	248	* IIO_EVENT_SH - generic shared event handler
	249	* @_name: event name
	250	* @_handler: handler function to be called
847ec80b JC	251	*
	252	* This is used in cases where more than one event may result from a single
	253	* handler. Often the case that some alarm register must be read and multiple
	254	* alarms may have been triggered.
	255	**/
	256	#define IIO_EVENT_SH(_name, _handler) \
	257	static struct iio_event_handler_list \
	258	iio_event_##_name = { \
	259	.handler = _handler, \
	260	.refcount = 0, \
	261	.exist_lock = __MUTEX_INITIALIZER(iio_event_##_name \
	262	.exist_lock), \
	263	.list = { \
	264	.next = &iio_event_##_name.list, \
	265	.prev = &iio_event_##_name.list, \
	266	}, \
	267	};
4c572605	268
847ec80b	269	/**
4c572605 RD	270	* IIO_EVENT_ATTR_SH - generic shared event attribute
	271	* @_name: event name
	272	* @_ev_list: event handler list
	273	* @_show: output method for the attribute
	274	* @_store: input method for the attribute
	275	* @_mask: mask used when detecting the event
847ec80b JC	276	*
	277	* An attribute with an associated IIO_EVENT_SH
	278	**/
	279	#define IIO_EVENT_ATTR_SH(_name, _ev_list, _show, _store, _mask) \
	280	static struct iio_event_attr \
	281	iio_event_attr_##_name \
	282	= { .dev_attr = __ATTR(_name, S_IRUGO \| S_IWUSR, \
	283	_show, _store), \
	284	.mask = _mask, \
	285	.listel = &_ev_list };
	286
	287	/**
4c572605 RD	288	* IIO_EVENT_ATTR - non-shared event attribute
	289	* @_name: event name
	290	* @_show: output method for the attribute
	291	* @_store: input method for the attribute
	292	* @_mask: mask used when detecting the event
	293	* @_handler: handler function to be called
847ec80b JC	294	**/
	295	#define IIO_EVENT_ATTR(_name, _show, _store, _mask, _handler) \
	296	static struct iio_event_handler_list \
	297	iio_event_##_name = { \
	298	.handler = _handler, \
	299	}; \
	300	static struct \
	301	iio_event_attr \
	302	iio_event_attr_##_name \
	303	= { .dev_attr = __ATTR(_name, S_IRUGO \| S_IWUSR, \
	304	_show, _store), \
	305	.mask = _mask, \
	306	.listel = &iio_event_##_name }; \
	307
	308	/**
4c572605 RD	309	* IIO_EVENT_ATTR_DATA_RDY - event driven by data ready signal
	310	* @_show: output method for the attribute
	311	* @_store: input method for the attribute
	312	* @_mask: mask used when detecting the event
	313	* @_handler: handler function to be called
847ec80b JC	314	*
847ec80b JC	315	* Not typically implemented in devices where full triggering support
4c572605	316	* has been implemented.
847ec80b JC	317	**/
	318	#define IIO_EVENT_ATTR_DATA_RDY(_show, _store, _mask, _handler) \
	319	IIO_EVENT_ATTR(data_rdy, _show, _store, _mask, _handler)
	320
	321	#define IIO_EVENT_CODE_DATA_RDY 100
	322	#define IIO_EVENT_CODE_RING_BASE 200
	323	#define IIO_EVENT_CODE_ACCEL_BASE 300
	324	#define IIO_EVENT_CODE_GYRO_BASE 400
	325	#define IIO_EVENT_CODE_ADC_BASE 500
	326	#define IIO_EVENT_CODE_MISC_BASE 600
	327
	328	#define IIO_EVENT_CODE_DEVICE_SPECIFIC 1000
	329
	330	/**
4c572605 RD	331	* IIO_EVENT_ATTR_RING_50_FULL - ring buffer event to indicate 50% full
	332	* @_show: output method for the attribute
	333	* @_store: input method for the attribute
	334	* @_mask: mask used when detecting the event
	335	* @_handler: handler function to be called
847ec80b JC	336	**/
	337	#define IIO_EVENT_ATTR_RING_50_FULL(_show, _store, _mask, _handler) \
	338	IIO_EVENT_ATTR(ring_50_full, _show, _store, _mask, _handler)
	339
	340	/**
4c572605 RD	341	* IIO_EVENT_ATTR_RING_50_FULL_SH - shared ring event to indicate 50% full
	342	* @_evlist: event handler list
	343	* @_show: output method for the attribute
	344	* @_store: input method for the attribute
	345	* @_mask: mask used when detecting the event
847ec80b JC	346	**/
	347	#define IIO_EVENT_ATTR_RING_50_FULL_SH(_evlist, _show, _store, _mask) \
	348	IIO_EVENT_ATTR_SH(ring_50_full, _evlist, _show, _store, _mask)
	349
	350	/**
4c572605 RD	351	* IIO_EVENT_ATTR_RING_75_FULL_SH - shared ring event to indicate 75% full
	352	* @_evlist: event handler list
	353	* @_show: output method for the attribute
	354	* @_store: input method for the attribute
	355	* @_mask: mask used when detecting the event
847ec80b JC	356	**/
	357	#define IIO_EVENT_ATTR_RING_75_FULL_SH(_evlist, _show, _store, _mask) \
	358	IIO_EVENT_ATTR_SH(ring_75_full, _evlist, _show, _store, _mask)
	359
	360	#define IIO_EVENT_CODE_RING_50_FULL IIO_EVENT_CODE_RING_BASE
	361	#define IIO_EVENT_CODE_RING_75_FULL (IIO_EVENT_CODE_RING_BASE + 1)
	362	#define IIO_EVENT_CODE_RING_100_FULL (IIO_EVENT_CODE_RING_BASE + 2)
	363
	364	#endif /* _INDUSTRIAL_IO_SYSFS_H_ */