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

/* The industrial I/O core - character device related
 *
 * 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.
 */

#ifndef _IIO_CHRDEV_H_
#define _IIO_CHRDEV_H_
struct iio_dev;

/**
 * struct iio_handler - Structure used to specify file operations
 *			for a particular chrdev
 * @chrdev:	character device structure
 * @id:		the location in the handler table - used for deallocation.
 * @flags:	file operations related flags including busy flag.
 * @private:	handler specific data used by the fileops registered with
 *		the chrdev.
 */
struct iio_handler {
	struct cdev	chrdev;
	int		id;
	unsigned long	flags;
	void		*private;
};

#define iio_cdev_to_handler(cd)				\
	container_of(cd, struct iio_handler, chrdev)

/**
 * struct iio_event_data - The actual event being pushed to userspace
 * @id:		event identifier
 * @timestamp:	best estimate of time of event occurance (often from
 *		the interrupt handler)
 */
struct iio_event_data {
	int	id;
	s64	timestamp;
};

/**
 * struct iio_detected_event_list - list element for events that have occured
 * @list:		linked list header
 * @ev:			the event itself
 * @shared_pointer:	used when the event is shared - i.e. can be escallated
 *			on demand (eg ring buffer 50%->100% full)
 */
struct iio_detected_event_list {
	struct list_head		list;
	struct iio_event_data		ev;
	struct iio_shared_ev_pointer	*shared_pointer;
};
/**
 * struct iio_shared_ev_pointer - allows shared events to identify if currently
 *				in the detected event list
 * @ev_p:	pointer to detected event list element (null if not in list)
 * @lock:	protect this element to prevent simultaneous edit and remove
 */
struct iio_shared_ev_pointer {
	struct iio_detected_event_list	*ev_p;
	spinlock_t			lock;
};

/**
 * struct iio_event_interface - chrdev interface for an event line
 * @dev:		device assocated with event interface
 * @handler:		fileoperations and related control for the chrdev
 * @wait:		wait queue to allow blocking reads of events
 * @event_list_lock:	mutex to protect the list of detected events
 * @det_events:		list of detected events
 * @max_events:		maximum number of events before new ones are dropped
 * @current_events:	number of events in detected list
 * @id:			indentifier to allow the event interface to know which
 *			physical line it corresponds to
 * @owner:		ensure the driver module owns the file, not iio
 * @private:		driver specific data
 * @_name:		used internally to store the sysfs name for minor id
 *			attribute
 */
struct iio_event_interface {
	struct device				dev;
	struct iio_handler			handler;
	wait_queue_head_t			wait;
	struct mutex				event_list_lock;
	struct iio_detected_event_list		det_events;
	int					max_events;
	int					current_events;
	int					id;
	struct iio_chrdev_minor_attr		attr;
	struct module				*owner;
	void					*private;
	char					_name[20];
	char					_attrname[20];
};

/**
 * struct iio_event_handler_list - element in list of handlers for events
 * @list:		list header
 * @refcount:		as the handler may be shared between multiple device
 *			side events, reference counting ensures clean removal
 * @exist_lock:		prevents race conditions related to refcount useage.
 * @handler:		event handler function - called on event if this
 *			event_handler is enabled.
 *
 * Each device has one list of these per interrupt line
 **/
struct iio_event_handler_list {
	struct list_head	list;
	int			refcount;
	struct mutex		exist_lock;
	int (*handler)(struct iio_dev *dev_info, int index, s64 timestamp,
		       int no_test);
};

#endif
Commit	Line	Data
847ec80b JC	1	/* The industrial I/O core - character device related
	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
	10	#ifndef _IIO_CHRDEV_H_
	11	#define _IIO_CHRDEV_H_
	12	struct iio_dev;
	13
	14	/**
	15	* struct iio_handler - Structure used to specify file operations
	16	* for a particular chrdev
	17	* @chrdev: character device structure
	18	* @id: the location in the handler table - used for deallocation.
	19	* @flags: file operations related flags including busy flag.
	20	* @private: handler specific data used by the fileops registered with
	21	* the chrdev.
	22	*/
	23	struct iio_handler {
	24	struct cdev chrdev;
	25	int id;
	26	unsigned long flags;
	27	void *private;
	28	};
	29
	30	#define iio_cdev_to_handler(cd) \
	31	container_of(cd, struct iio_handler, chrdev)
	32
	33	/**
	34	* struct iio_event_data - The actual event being pushed to userspace
	35	* @id: event identifier
	36	* @timestamp: best estimate of time of event occurance (often from
	37	* the interrupt handler)
	38	*/
	39	struct iio_event_data {
	40	int id;
	41	s64 timestamp;
	42	};
	43
	44	/**
	45	* struct iio_detected_event_list - list element for events that have occured
	46	* @list: linked list header
	47	* @ev: the event itself
	48	* @shared_pointer: used when the event is shared - i.e. can be escallated
	49	* on demand (eg ring buffer 50%->100% full)
	50	*/
	51	struct iio_detected_event_list {
	52	struct list_head list;
	53	struct iio_event_data ev;
	54	struct iio_shared_ev_pointer *shared_pointer;
	55	};
	56	/**
	57	* struct iio_shared_ev_pointer - allows shared events to identify if currently
	58	* in the detected event list
	59	* @ev_p: pointer to detected event list element (null if not in list)
	60	* @lock: protect this element to prevent simultaneous edit and remove
	61	*/
	62	struct iio_shared_ev_pointer {
	63	struct iio_detected_event_list *ev_p;
	64	spinlock_t lock;
65	};
66
67	/**
68	* struct iio_event_interface - chrdev interface for an event line
69	* @dev: device assocated with event interface
70	* @handler: fileoperations and related control for the chrdev
71	* @wait: wait queue to allow blocking reads of events
72	* @event_list_lock: mutex to protect the list of detected events
73	* @det_events: list of detected events
74	* @max_events: maximum number of events before new ones are dropped
75	* @current_events: number of events in detected list
76	* @id: indentifier to allow the event interface to know which
77	* physical line it corresponds to
78	* @owner: ensure the driver module owns the file, not iio
79	* @private: driver specific data
80	* @_name: used internally to store the sysfs name for minor id
81	* attribute
82	*/
83	struct iio_event_interface {
84	struct device dev;
85	struct iio_handler handler;
86	wait_queue_head_t wait;
87	struct mutex event_list_lock;
88	struct iio_detected_event_list det_events;
89	int max_events;
90	int current_events;
91	int id;
92	struct iio_chrdev_minor_attr attr;
93	struct module *owner;
94	void *private;
95	char _name[20];
96	char _attrname[20];
97	};
98
99	/**
100	* struct iio_event_handler_list - element in list of handlers for events
101	* @list: list header
102	* @refcount: as the handler may be shared between multiple device
103	* side events, reference counting ensures clean removal
104	* @exist_lock: prevents race conditions related to refcount useage.
105	* @handler: event handler function - called on event if this
106	* event_handler is enabled.
107	*
108	* Each device has one list of these per interrupt line
109	**/
110	struct iio_event_handler_list {
111	struct list_head list;
112	int refcount;
113	struct mutex exist_lock;
114	int (handler)(struct iio_dev dev_info, int index, s64 timestamp,
115	int no_test);
116	};
117
118	#endif