[mirror_ubuntu-bionic-kernel.git] / include / linux / rmi.h

/*
 * Copyright (c) 2011-2016 Synaptics Incorporated
 * Copyright (c) 2011 Unixphere
 *
 * 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 _RMI_H
#define _RMI_H
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/input.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/types.h>

#define NAME_BUFFER_SIZE 256

/**
 * struct rmi_2d_axis_alignment - target axis alignment
 * @swap_axes: set to TRUE if desired to swap x- and y-axis
 * @flip_x: set to TRUE if desired to flip direction on x-axis
 * @flip_y: set to TRUE if desired to flip direction on y-axis
 * @clip_x_low - reported X coordinates below this setting will be clipped to
 *               the specified value
 * @clip_x_high - reported X coordinates above this setting will be clipped to
 *               the specified value
 * @clip_y_low - reported Y coordinates below this setting will be clipped to
 *               the specified value
 * @clip_y_high - reported Y coordinates above this setting will be clipped to
 *               the specified value
 * @offset_x - this value will be added to all reported X coordinates
 * @offset_y - this value will be added to all reported Y coordinates
 * @rel_report_enabled - if set to true, the relative reporting will be
 *               automatically enabled for this sensor.
 */
struct rmi_2d_axis_alignment {
	bool swap_axes;
	bool flip_x;
	bool flip_y;
	u16 clip_x_low;
	u16 clip_y_low;
	u16 clip_x_high;
	u16 clip_y_high;
	u16 offset_x;
	u16 offset_y;
	u8 delta_x_threshold;
	u8 delta_y_threshold;
};

/** This is used to override any hints an F11 2D sensor might have provided
 * as to what type of sensor it is.
 *
 * @rmi_f11_sensor_default - do not override, determine from F11_2D_QUERY14 if
 * available.
 * @rmi_f11_sensor_touchscreen - treat the sensor as a touchscreen (direct
 * pointing).
 * @rmi_f11_sensor_touchpad - thread the sensor as a touchpad (indirect
 * pointing).
 */
enum rmi_sensor_type {
	rmi_sensor_default = 0,
	rmi_sensor_touchscreen,
	rmi_sensor_touchpad
};

#define RMI_F11_DISABLE_ABS_REPORT      BIT(0)

/**
 * struct rmi_2d_sensor_data - overrides defaults for a 2D sensor.
 * @axis_align - provides axis alignment overrides (see above).
 * @sensor_type - Forces the driver to treat the sensor as an indirect
 * pointing device (touchpad) rather than a direct pointing device
 * (touchscreen).  This is useful when F11_2D_QUERY14 register is not
 * available.
 * @disable_report_mask - Force data to not be reported even if it is supported
 * by the firware.
 * @topbuttonpad - Used with the "5 buttons touchpads" found on the Lenovo 40
 * series
 * @kernel_tracking - most moderns RMI f11 firmwares implement Multifinger
 * Type B protocol. However, there are some corner cases where the user
 * triggers some jumps by tapping with two fingers on the touchpad.
 * Use this setting and dmax to filter out these jumps.
 * Also, when using an old sensor using MF Type A behavior, set to true to
 * report an actual MT protocol B.
 * @dmax - the maximum distance (in sensor units) the kernel tracking allows two
 * distincts fingers to be considered the same.
 */
struct rmi_2d_sensor_platform_data {
	struct rmi_2d_axis_alignment axis_align;
	enum rmi_sensor_type sensor_type;
	int x_mm;
	int y_mm;
	int disable_report_mask;
	u16 rezero_wait;
	bool topbuttonpad;
	bool kernel_tracking;
	int dmax;
	int dribble;
	int palm_detect;
};

/**
 * struct rmi_f30_data - overrides defaults for a single F30 GPIOs/LED chip.
 * @buttonpad - the touchpad is a buttonpad, so enable only the first actual
 * button that is found.
 * @trackstick_buttons - Set when the function 30 is handling the physical
 * buttons of the trackstick (as a PS/2 passthrough device).
 * @disable - the touchpad incorrectly reports F30 and it should be ignored.
 * This is a special case which is due to misconfigured firmware.
 */
struct rmi_f30_data {
	bool buttonpad;
	bool trackstick_buttons;
	bool disable;
};


/*
 * Set the state of a register
 *	DEFAULT - use the default value set by the firmware config
 *	OFF - explicitly disable the register
 *	ON - explicitly enable the register
 */
enum rmi_reg_state {
	RMI_REG_STATE_DEFAULT = 0,
	RMI_REG_STATE_OFF = 1,
	RMI_REG_STATE_ON = 2
};

/**
 * struct rmi_f01_power_management -When non-zero, these values will be written
 * to the touch sensor to override the default firmware settigns.  For a
 * detailed explanation of what each field does, see the corresponding
 * documention in the RMI4 specification.
 *
 * @nosleep - specifies whether the device is permitted to sleep or doze (that
 * is, enter a temporary low power state) when no fingers are touching the
 * sensor.
 * @wakeup_threshold - controls the capacitance threshold at which the touch
 * sensor will decide to wake up from that low power state.
 * @doze_holdoff - controls how long the touch sensor waits after the last
 * finger lifts before entering the doze state, in units of 100ms.
 * @doze_interval - controls the interval between checks for finger presence
 * when the touch sensor is in doze mode, in units of 10ms.
 */
struct rmi_f01_power_management {
	enum rmi_reg_state nosleep;
	u8 wakeup_threshold;
	u8 doze_holdoff;
	u8 doze_interval;
};

/**
 * struct rmi_device_platform_data_spi - provides parameters used in SPI
 * communications.  All Synaptics SPI products support a standard SPI
 * interface; some also support what is called SPI V2 mode, depending on
 * firmware and/or ASIC limitations.  In V2 mode, the touch sensor can
 * support shorter delays during certain operations, and these are specified
 * separately from the standard mode delays.
 *
 * @block_delay - for standard SPI transactions consisting of both a read and
 * write operation, the delay (in microseconds) between the read and write
 * operations.
 * @split_read_block_delay_us - for V2 SPI transactions consisting of both a
 * read and write operation, the delay (in microseconds) between the read and
 * write operations.
 * @read_delay_us - the delay between each byte of a read operation in normal
 * SPI mode.
 * @write_delay_us - the delay between each byte of a write operation in normal
 * SPI mode.
 * @split_read_byte_delay_us - the delay between each byte of a read operation
 * in V2 mode.
 * @pre_delay_us - the delay before the start of a SPI transaction.  This is
 * typically useful in conjunction with custom chip select assertions (see
 * below).
 * @post_delay_us - the delay after the completion of an SPI transaction.  This
 * is typically useful in conjunction with custom chip select assertions (see
 * below).
 * @cs_assert - For systems where the SPI subsystem does not control the CS/SSB
 * line, or where such control is broken, you can provide a custom routine to
 * handle a GPIO as CS/SSB.  This routine will be called at the beginning and
 * end of each SPI transaction.  The RMI SPI implementation will wait
 * pre_delay_us after this routine returns before starting the SPI transfer;
 * and post_delay_us after completion of the SPI transfer(s) before calling it
 * with assert==FALSE.
 */
struct rmi_device_platform_data_spi {
	u32 block_delay_us;
	u32 split_read_block_delay_us;
	u32 read_delay_us;
	u32 write_delay_us;
	u32 split_read_byte_delay_us;
	u32 pre_delay_us;
	u32 post_delay_us;
	u8 bits_per_word;
	u16 mode;

	void *cs_assert_data;
	int (*cs_assert)(const void *cs_assert_data, const bool assert);
};

/**
 * struct rmi_device_platform_data - system specific configuration info.
 *
 * @reset_delay_ms - after issuing a reset command to the touch sensor, the
 * driver waits a few milliseconds to give the firmware a chance to
 * to re-initialize.  You can override the default wait period here.
 * @irq: irq associated with the attn gpio line, or negative
 */
struct rmi_device_platform_data {
	int reset_delay_ms;
	int irq;

	struct rmi_device_platform_data_spi spi_data;

	/* function handler pdata */
	struct rmi_2d_sensor_platform_data *sensor_pdata;
	struct rmi_f01_power_management power_management;
	struct rmi_f30_data *f30_data;
};

/**
 * struct rmi_function_descriptor - RMI function base addresses
 *
 * @query_base_addr: The RMI Query base address
 * @command_base_addr: The RMI Command base address
 * @control_base_addr: The RMI Control base address
 * @data_base_addr: The RMI Data base address
 * @interrupt_source_count: The number of irqs this RMI function needs
 * @function_number: The RMI function number
 *
 * This struct is used when iterating the Page Description Table. The addresses
 * are 16-bit values to include the current page address.
 *
 */
struct rmi_function_descriptor {
	u16 query_base_addr;
	u16 command_base_addr;
	u16 control_base_addr;
	u16 data_base_addr;
	u8 interrupt_source_count;
	u8 function_number;
	u8 function_version;
};

struct rmi_device;

/**
 * struct rmi_transport_dev - represent an RMI transport device
 *
 * @dev: Pointer to the communication device, e.g. i2c or spi
 * @rmi_dev: Pointer to the RMI device
 * @proto_name: name of the transport protocol (SPI, i2c, etc)
 * @ops: pointer to transport operations implementation
 *
 * The RMI transport device implements the glue between different communication
 * buses such as I2C and SPI.
 *
 */
struct rmi_transport_dev {
	struct device *dev;
	struct rmi_device *rmi_dev;

	const char *proto_name;
	const struct rmi_transport_ops *ops;

	struct rmi_device_platform_data pdata;

	struct input_dev *input;

	void *attn_data;
	int attn_size;
};

/**
 * struct rmi_transport_ops - defines transport protocol operations.
 *
 * @write_block: Writing a block of data to the specified address
 * @read_block: Read a block of data from the specified address.
 */
struct rmi_transport_ops {
	int (*write_block)(struct rmi_transport_dev *xport, u16 addr,
			   const void *buf, size_t len);
	int (*read_block)(struct rmi_transport_dev *xport, u16 addr,
			  void *buf, size_t len);
	int (*reset)(struct rmi_transport_dev *xport, u16 reset_addr);
};

/**
 * struct rmi_driver - driver for an RMI4 sensor on the RMI bus.
 *
 * @driver: Device driver model driver
 * @reset_handler: Called when a reset is detected.
 * @clear_irq_bits: Clear the specified bits in the current interrupt mask.
 * @set_irq_bist: Set the specified bits in the current interrupt mask.
 * @store_productid: Callback for cache product id from function 01
 * @data: Private data pointer
 *
 */
struct rmi_driver {
	struct device_driver driver;

	int (*reset_handler)(struct rmi_device *rmi_dev);
	int (*clear_irq_bits)(struct rmi_device *rmi_dev, unsigned long *mask);
	int (*set_irq_bits)(struct rmi_device *rmi_dev, unsigned long *mask);
	int (*store_productid)(struct rmi_device *rmi_dev);
	int (*set_input_params)(struct rmi_device *rmi_dev,
			struct input_dev *input);
	void *data;
};

/**
 * struct rmi_device - represents an RMI4 sensor device on the RMI bus.
 *
 * @dev: The device created for the RMI bus
 * @number: Unique number for the device on the bus.
 * @driver: Pointer to associated driver
 * @xport: Pointer to the transport interface
 *
 */
struct rmi_device {
	struct device dev;
	int number;

	struct rmi_driver *driver;
	struct rmi_transport_dev *xport;

};

struct rmi_driver_data {
	struct list_head function_list;

	struct rmi_device *rmi_dev;

	struct rmi_function *f01_container;
	struct rmi_function *f34_container;
	bool f01_bootloader_mode;

	int num_of_irq_regs;
	int irq_count;
	void *irq_memory;
	unsigned long *irq_status;
	unsigned long *fn_irq_bits;
	unsigned long *current_irq_mask;
	unsigned long *new_irq_mask;
	struct mutex irq_mutex;
	struct input_dev *input;

	u8 pdt_props;

	u8 num_rx_electrodes;
	u8 num_tx_electrodes;

	bool enabled;
};

int rmi_register_transport_device(struct rmi_transport_dev *xport);
void rmi_unregister_transport_device(struct rmi_transport_dev *xport);

int rmi_driver_suspend(struct rmi_device *rmi_dev, bool enable_wake);
int rmi_driver_resume(struct rmi_device *rmi_dev, bool clear_wake);
#endif
Commit	Line	Data
2b6a321d AD	1	/*
	2	* Copyright (c) 2011-2016 Synaptics Incorporated
	3	* Copyright (c) 2011 Unixphere
	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 _RMI_H
	11	#define _RMI_H
	12	#include <linux/kernel.h>
	13	#include <linux/device.h>
	14	#include <linux/interrupt.h>
	15	#include <linux/input.h>
	16	#include <linux/list.h>
	17	#include <linux/module.h>
	18	#include <linux/types.h>
	19
	20	#define NAME_BUFFER_SIZE 256
	21
ff8f8370 AD	22	/**
	23	* struct rmi_2d_axis_alignment - target axis alignment
	24	* @swap_axes: set to TRUE if desired to swap x- and y-axis
	25	* @flip_x: set to TRUE if desired to flip direction on x-axis
	26	* @flip_y: set to TRUE if desired to flip direction on y-axis
	27	* @clip_x_low - reported X coordinates below this setting will be clipped to
	28	* the specified value
	29	* @clip_x_high - reported X coordinates above this setting will be clipped to
	30	* the specified value
	31	* @clip_y_low - reported Y coordinates below this setting will be clipped to
	32	* the specified value
	33	* @clip_y_high - reported Y coordinates above this setting will be clipped to
	34	* the specified value
	35	* @offset_x - this value will be added to all reported X coordinates
	36	* @offset_y - this value will be added to all reported Y coordinates
	37	* @rel_report_enabled - if set to true, the relative reporting will be
	38	* automatically enabled for this sensor.
	39	*/
	40	struct rmi_2d_axis_alignment {
	41	bool swap_axes;
	42	bool flip_x;
	43	bool flip_y;
	44	u16 clip_x_low;
	45	u16 clip_y_low;
	46	u16 clip_x_high;
	47	u16 clip_y_high;
	48	u16 offset_x;
	49	u16 offset_y;
	50	u8 delta_x_threshold;
	51	u8 delta_y_threshold;
	52	};
	53
	54	/** This is used to override any hints an F11 2D sensor might have provided
	55	* as to what type of sensor it is.
	56	*
	57	* @rmi_f11_sensor_default - do not override, determine from F11_2D_QUERY14 if
	58	* available.
	59	* @rmi_f11_sensor_touchscreen - treat the sensor as a touchscreen (direct
	60	* pointing).
	61	* @rmi_f11_sensor_touchpad - thread the sensor as a touchpad (indirect
	62	* pointing).
	63	*/
	64	enum rmi_sensor_type {
	65	rmi_sensor_default = 0,
	66	rmi_sensor_touchscreen,
	67	rmi_sensor_touchpad
	68	};
	69
	70	#define RMI_F11_DISABLE_ABS_REPORT BIT(0)
	71
	72	/**
	73	* struct rmi_2d_sensor_data - overrides defaults for a 2D sensor.
	74	* @axis_align - provides axis alignment overrides (see above).
	75	* @sensor_type - Forces the driver to treat the sensor as an indirect
	76	* pointing device (touchpad) rather than a direct pointing device
	77	* (touchscreen). This is useful when F11_2D_QUERY14 register is not
	78	* available.
	79	* @disable_report_mask - Force data to not be reported even if it is supported
	80	* by the firware.
	81	* @topbuttonpad - Used with the "5 buttons touchpads" found on the Lenovo 40
	82	* series
	83	* @kernel_tracking - most moderns RMI f11 firmwares implement Multifinger
	84	* Type B protocol. However, there are some corner cases where the user
	85	* triggers some jumps by tapping with two fingers on the touchpad.
86	* Use this setting and dmax to filter out these jumps.
87	* Also, when using an old sensor using MF Type A behavior, set to true to
88	* report an actual MT protocol B.
89	* @dmax - the maximum distance (in sensor units) the kernel tracking allows two
90	* distincts fingers to be considered the same.
91	*/
92	struct rmi_2d_sensor_platform_data {
93	struct rmi_2d_axis_alignment axis_align;
94	enum rmi_sensor_type sensor_type;
95	int x_mm;
96	int y_mm;
97	int disable_report_mask;
98	u16 rezero_wait;
99	bool topbuttonpad;
100	bool kernel_tracking;
101	int dmax;
2775e523 AD	102	int dribble;
2775e523 AD	103	int palm_detect;
ff8f8370 AD	104	};
ff8f8370 AD	105
562b42d3 AD	106	/**
	107	* struct rmi_f30_data - overrides defaults for a single F30 GPIOs/LED chip.
	108	* @buttonpad - the touchpad is a buttonpad, so enable only the first actual
	109	* button that is found.
	110	* @trackstick_buttons - Set when the function 30 is handling the physical
9e421b7c	111	* buttons of the trackstick (as a PS/2 passthrough device).
562b42d3 AD	112	* @disable - the touchpad incorrectly reports F30 and it should be ignored.
	113	* This is a special case which is due to misconfigured firmware.
	114	*/
	115	struct rmi_f30_data {
	116	bool buttonpad;
	117	bool trackstick_buttons;
	118	bool disable;
	119	};
	120
2775e523 AD	121
	122	/*
	123	* Set the state of a register
	124	* DEFAULT - use the default value set by the firmware config
	125	* OFF - explicitly disable the register
	126	* ON - explicitly enable the register
2b6a321d	127	*/
2775e523 AD	128	enum rmi_reg_state {
	129	RMI_REG_STATE_DEFAULT = 0,
	130	RMI_REG_STATE_OFF = 1,
	131	RMI_REG_STATE_ON = 2
2b6a321d AD	132	};
	133
	134	/**
	135	* struct rmi_f01_power_management -When non-zero, these values will be written
	136	* to the touch sensor to override the default firmware settigns. For a
	137	* detailed explanation of what each field does, see the corresponding
	138	* documention in the RMI4 specification.
	139	*
	140	* @nosleep - specifies whether the device is permitted to sleep or doze (that
	141	* is, enter a temporary low power state) when no fingers are touching the
	142	* sensor.
	143	* @wakeup_threshold - controls the capacitance threshold at which the touch
	144	* sensor will decide to wake up from that low power state.
	145	* @doze_holdoff - controls how long the touch sensor waits after the last
	146	* finger lifts before entering the doze state, in units of 100ms.
	147	* @doze_interval - controls the interval between checks for finger presence
	148	* when the touch sensor is in doze mode, in units of 10ms.
	149	*/
	150	struct rmi_f01_power_management {
2775e523	151	enum rmi_reg_state nosleep;
2b6a321d AD	152	u8 wakeup_threshold;
	153	u8 doze_holdoff;
	154	u8 doze_interval;
	155	};
	156
8d99758d AD	157	/**
	158	* struct rmi_device_platform_data_spi - provides parameters used in SPI
	159	* communications. All Synaptics SPI products support a standard SPI
	160	* interface; some also support what is called SPI V2 mode, depending on
	161	* firmware and/or ASIC limitations. In V2 mode, the touch sensor can
	162	* support shorter delays during certain operations, and these are specified
	163	* separately from the standard mode delays.
	164	*
	165	* @block_delay - for standard SPI transactions consisting of both a read and
	166	* write operation, the delay (in microseconds) between the read and write
	167	* operations.
	168	* @split_read_block_delay_us - for V2 SPI transactions consisting of both a
	169	* read and write operation, the delay (in microseconds) between the read and
	170	* write operations.
	171	* @read_delay_us - the delay between each byte of a read operation in normal
	172	* SPI mode.
	173	* @write_delay_us - the delay between each byte of a write operation in normal
	174	* SPI mode.
	175	* @split_read_byte_delay_us - the delay between each byte of a read operation
	176	* in V2 mode.
	177	* @pre_delay_us - the delay before the start of a SPI transaction. This is
	178	* typically useful in conjunction with custom chip select assertions (see
	179	* below).
	180	* @post_delay_us - the delay after the completion of an SPI transaction. This
	181	* is typically useful in conjunction with custom chip select assertions (see
	182	* below).
	183	* @cs_assert - For systems where the SPI subsystem does not control the CS/SSB
	184	* line, or where such control is broken, you can provide a custom routine to
	185	* handle a GPIO as CS/SSB. This routine will be called at the beginning and
	186	* end of each SPI transaction. The RMI SPI implementation will wait
	187	* pre_delay_us after this routine returns before starting the SPI transfer;
	188	* and post_delay_us after completion of the SPI transfer(s) before calling it
	189	* with assert==FALSE.
	190	*/
	191	struct rmi_device_platform_data_spi {
	192	u32 block_delay_us;
	193	u32 split_read_block_delay_us;
	194	u32 read_delay_us;
	195	u32 write_delay_us;
	196	u32 split_read_byte_delay_us;
	197	u32 pre_delay_us;
	198	u32 post_delay_us;
	199	u8 bits_per_word;
	200	u16 mode;
	201
	202	void *cs_assert_data;
	203	int (cs_assert)(const void cs_assert_data, const bool assert);
	204	};
	205
2b6a321d AD	206	/**
	207	* struct rmi_device_platform_data - system specific configuration info.
	208	*
	209	* @reset_delay_ms - after issuing a reset command to the touch sensor, the
	210	* driver waits a few milliseconds to give the firmware a chance to
	211	* to re-initialize. You can override the default wait period here.
3aeed5b5	212	* @irq: irq associated with the attn gpio line, or negative
2b6a321d AD	213	*/
	214	struct rmi_device_platform_data {
	215	int reset_delay_ms;
3aeed5b5	216	int irq;
2b6a321d	217
8d99758d AD	218	struct rmi_device_platform_data_spi spi_data;
8d99758d AD	219
2b6a321d	220	/* function handler pdata */
ff8f8370	221	struct rmi_2d_sensor_platform_data *sensor_pdata;
2b6a321d	222	struct rmi_f01_power_management power_management;
562b42d3	223	struct rmi_f30_data *f30_data;
2b6a321d AD	224	};
	225
	226	/**
	227	* struct rmi_function_descriptor - RMI function base addresses
	228	*
	229	* @query_base_addr: The RMI Query base address
	230	* @command_base_addr: The RMI Command base address
	231	* @control_base_addr: The RMI Control base address
	232	* @data_base_addr: The RMI Data base address
	233	* @interrupt_source_count: The number of irqs this RMI function needs
	234	* @function_number: The RMI function number
	235	*
	236	* This struct is used when iterating the Page Description Table. The addresses
	237	* are 16-bit values to include the current page address.
	238	*
	239	*/
	240	struct rmi_function_descriptor {
	241	u16 query_base_addr;
	242	u16 command_base_addr;
	243	u16 control_base_addr;
	244	u16 data_base_addr;
	245	u8 interrupt_source_count;
	246	u8 function_number;
	247	u8 function_version;
	248	};
	249
	250	struct rmi_device;
	251
	252	/**
	253	* struct rmi_transport_dev - represent an RMI transport device
	254	*
	255	* @dev: Pointer to the communication device, e.g. i2c or spi
	256	* @rmi_dev: Pointer to the RMI device
	257	* @proto_name: name of the transport protocol (SPI, i2c, etc)
	258	* @ops: pointer to transport operations implementation
	259	*
	260	* The RMI transport device implements the glue between different communication
	261	* buses such as I2C and SPI.
	262	*
	263	*/
	264	struct rmi_transport_dev {
	265	struct device *dev;
	266	struct rmi_device *rmi_dev;
	267
	268	const char *proto_name;
	269	const struct rmi_transport_ops *ops;
	270
	271	struct rmi_device_platform_data pdata;
	272
	273	struct input_dev *input;
	274
	275	void *attn_data;
	276	int attn_size;
	277	};
	278
	279	/**
	280	* struct rmi_transport_ops - defines transport protocol operations.
	281	*
	282	* @write_block: Writing a block of data to the specified address
	283	* @read_block: Read a block of data from the specified address.
	284	*/
	285	struct rmi_transport_ops {
	286	int (write_block)(struct rmi_transport_dev xport, u16 addr,
	287	const void *buf, size_t len);
288	int (read_block)(struct rmi_transport_dev xport, u16 addr,
289	void *buf, size_t len);
290	int (reset)(struct rmi_transport_dev xport, u16 reset_addr);
291	};
292
293	/**
294	* struct rmi_driver - driver for an RMI4 sensor on the RMI bus.
295	*
296	* @driver: Device driver model driver
297	* @reset_handler: Called when a reset is detected.
298	* @clear_irq_bits: Clear the specified bits in the current interrupt mask.
299	* @set_irq_bist: Set the specified bits in the current interrupt mask.
300	* @store_productid: Callback for cache product id from function 01
301	* @data: Private data pointer
302	*
303	*/
304	struct rmi_driver {
305	struct device_driver driver;
306
307	int (reset_handler)(struct rmi_device rmi_dev);
308	int (clear_irq_bits)(struct rmi_device rmi_dev, unsigned long *mask);
309	int (set_irq_bits)(struct rmi_device rmi_dev, unsigned long *mask);
310	int (store_productid)(struct rmi_device rmi_dev);
311	int (set_input_params)(struct rmi_device rmi_dev,
312	struct input_dev *input);
313	void *data;
314	};
315
316	/**
317	* struct rmi_device - represents an RMI4 sensor device on the RMI bus.
318	*
319	* @dev: The device created for the RMI bus
320	* @number: Unique number for the device on the bus.
321	* @driver: Pointer to associated driver
322	* @xport: Pointer to the transport interface
323	*
324	*/
325	struct rmi_device {
326	struct device dev;
327	int number;
328
329	struct rmi_driver *driver;
330	struct rmi_transport_dev *xport;
331
332	};
333
334	struct rmi_driver_data {
335	struct list_head function_list;
336
337	struct rmi_device *rmi_dev;
338
339	struct rmi_function *f01_container;
29fd0ec2	340	struct rmi_function *f34_container;
2b6a321d AD	341	bool f01_bootloader_mode;
2b6a321d AD	342
2b6a321d AD	343	int num_of_irq_regs;
2b6a321d AD	344	int irq_count;
29fd0ec2	345	void *irq_memory;
2b6a321d AD	346	unsigned long *irq_status;
	347	unsigned long *fn_irq_bits;
	348	unsigned long *current_irq_mask;
	349	unsigned long *new_irq_mask;
	350	struct mutex irq_mutex;
	351	struct input_dev *input;
	352
	353	u8 pdt_props;
2b6a321d	354
c762cc68 GR	355	u8 num_rx_electrodes;
	356	u8 num_tx_electrodes;
	357
2b6a321d	358	bool enabled;
2b6a321d AD	359	};
	360
	361	int rmi_register_transport_device(struct rmi_transport_dev *xport);
	362	void rmi_unregister_transport_device(struct rmi_transport_dev *xport);
2b6a321d	363
3aeed5b5 BA	364	int rmi_driver_suspend(struct rmi_device *rmi_dev, bool enable_wake);
3aeed5b5 BA	365	int rmi_driver_resume(struct rmi_device *rmi_dev, bool clear_wake);
2b6a321d	366	#endif