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

Commit 71110499 authored by Alexandra Chin's avatar Alexandra Chin Committed by Stephen Boyd
Browse files

input: synaptics: Add support for F12 



2013-07-23
- Add F$12 support
- Correct data size in struct image_header_data
- use DECLARE_COMPLETION

Signed-off-by: default avatarAlexandra Chin <alexandra.chin@tw.synaptics.com>
Change-Id: Ie9c1be58f963467e10ff0355f2c7b5b0244ea003
Git-commit: ca4b0c286031245c28b1fa1aca1e1d1614d6c18e
Git-repo: git://github.com/synaptics-touch/msm-3.4.git


[amaloche@codeaurora.org: Changes due to base driver
differences]
Signed-off-by: default avatarAmy Maloche <amaloche@codeaurora.org>
parent e0abee5f

drivers/input/touchscreen/synaptics_fw_update.c

+3 −5
Original line number Diff line number Diff line
@@ -257,7 +257,7 @@ struct synaptics_rmi4_fwu_handle { 


static struct synaptics_rmi4_fwu_handle *fwu;



static struct completion remove_complete;

DECLARE_COMPLETION(fwu_remove_complete);



static unsigned int extract_uint(const unsigned char *ptr)

{
@@ -1900,8 +1900,6 @@ static int synaptics_rmi4_fwu_init(struct synaptics_rmi4_data *rmi4_data) 
			msecs_to_jiffies(1000));

#endif



	init_completion(&remove_complete);



	return 0;

exit_free_ts_info:

	debugfs_remove(temp);
@@ -1937,7 +1935,7 @@ static void synaptics_rmi4_fwu_remove(struct synaptics_rmi4_data *rmi4_data) 
	kfree(fwu->fn_ptr);

	kfree(fwu);



	complete(&remove_complete);

	complete(&fwu_remove_complete);



	return;

}
@@ -1957,7 +1955,7 @@ static void __exit rmi4_fw_update_module_exit(void) 
			synaptics_rmi4_fwu_init,

			synaptics_rmi4_fwu_remove,

			synaptics_rmi4_fwu_attn);

	wait_for_completion(&remove_complete);

	wait_for_completion(&fwu_remove_complete);

	return;

}

drivers/input/touchscreen/synaptics_i2c_rmi4.c

+515 −10
Original line number Diff line number Diff line
@@ -93,6 +93,8 @@ enum device_status { 
#define RMI4_I2C_LPM_LOAD_UA	10



#define RMI4_GPIO_SLEEP_LOW_US 10000

#define F12_FINGERS_TO_SUPPORT 10

#define MAX_F11_TOUCH_WIDTH 15



static int synaptics_rmi4_i2c_read(struct synaptics_rmi4_data *rmi4_data,

		unsigned short addr, unsigned char *data,
@@ -168,6 +170,131 @@ struct synaptics_rmi4_f01_device_status { 
	};

};



struct synaptics_rmi4_f12_query_5 {

	union {

		struct {

			unsigned char size_of_query6;

			struct {

				unsigned char ctrl0_is_present:1;

				unsigned char ctrl1_is_present:1;

				unsigned char ctrl2_is_present:1;

				unsigned char ctrl3_is_present:1;

				unsigned char ctrl4_is_present:1;

				unsigned char ctrl5_is_present:1;

				unsigned char ctrl6_is_present:1;

				unsigned char ctrl7_is_present:1;

			} __packed;

			struct {

				unsigned char ctrl8_is_present:1;

				unsigned char ctrl9_is_present:1;

				unsigned char ctrl10_is_present:1;

				unsigned char ctrl11_is_present:1;

				unsigned char ctrl12_is_present:1;

				unsigned char ctrl13_is_present:1;

				unsigned char ctrl14_is_present:1;

				unsigned char ctrl15_is_present:1;

			} __packed;

			struct {

				unsigned char ctrl16_is_present:1;

				unsigned char ctrl17_is_present:1;

				unsigned char ctrl18_is_present:1;

				unsigned char ctrl19_is_present:1;

				unsigned char ctrl20_is_present:1;

				unsigned char ctrl21_is_present:1;

				unsigned char ctrl22_is_present:1;

				unsigned char ctrl23_is_present:1;

			} __packed;

			struct {

				unsigned char ctrl24_is_present:1;

				unsigned char ctrl25_is_present:1;

				unsigned char ctrl26_is_present:1;

				unsigned char ctrl27_is_present:1;

				unsigned char ctrl28_is_present:1;

				unsigned char ctrl29_is_present:1;

				unsigned char ctrl30_is_present:1;

				unsigned char ctrl31_is_present:1;

			} __packed;

		};

		unsigned char data[5];

	};

};



struct synaptics_rmi4_f12_query_8 {

	union {

		struct {

			unsigned char size_of_query9;

			struct {

				unsigned char data0_is_present:1;

				unsigned char data1_is_present:1;

				unsigned char data2_is_present:1;

				unsigned char data3_is_present:1;

				unsigned char data4_is_present:1;

				unsigned char data5_is_present:1;

				unsigned char data6_is_present:1;

				unsigned char data7_is_present:1;

			} __packed;

			struct {

				unsigned char data8_is_present:1;

				unsigned char data9_is_present:1;

				unsigned char data10_is_present:1;

				unsigned char data11_is_present:1;

				unsigned char data12_is_present:1;

				unsigned char data13_is_present:1;

				unsigned char data14_is_present:1;

				unsigned char data15_is_present:1;

			} __packed;

		};

		unsigned char data[3];

	};

};



struct synaptics_rmi4_f12_ctrl_8 {

	union {

		struct {

			unsigned char max_x_coord_lsb;

			unsigned char max_x_coord_msb;

			unsigned char max_y_coord_lsb;

			unsigned char max_y_coord_msb;

			unsigned char rx_pitch_lsb;

			unsigned char rx_pitch_msb;

			unsigned char tx_pitch_lsb;

			unsigned char tx_pitch_msb;

			unsigned char low_rx_clip;

			unsigned char high_rx_clip;

			unsigned char low_tx_clip;

			unsigned char high_tx_clip;

			unsigned char num_of_rx;

			unsigned char num_of_tx;

		};

		unsigned char data[14];

	};

};



struct synaptics_rmi4_f12_ctrl_23 {

	union {

		struct {

			unsigned char obj_type_enable;

			unsigned char max_reported_objects;

		};

		unsigned char data[2];

	};

};



struct synaptics_rmi4_f12_finger_data {

	unsigned char object_type_and_status;

	unsigned char x_lsb;

	unsigned char x_msb;

	unsigned char y_lsb;

	unsigned char y_msb;

#ifdef REPORT_2D_Z

	unsigned char z;

#endif

#ifdef REPORT_2D_W

	unsigned char wx;

	unsigned char wy;

#endif

};



struct synaptics_rmi4_f1a_query {

	union {

		struct {
@@ -223,6 +350,13 @@ struct synaptics_rmi4_f1a_handle { 
	struct synaptics_rmi4_f1a_control button_control;

};



struct synaptics_rmi4_f12_extra_data {

	unsigned char data1_offset;

	unsigned char data15_offset;

	unsigned char data15_size;

	unsigned char data15_data[(F12_FINGERS_TO_SUPPORT + 7) / 8];

};



struct synaptics_rmi4_exp_fn {

	enum exp_fn fn_type;

	bool inserted;
@@ -817,12 +951,128 @@ static int synaptics_rmi4_f11_abs_report(struct synaptics_rmi4_data *rmi4_data, 
	if (!touch_count)

		input_mt_sync(rmi4_data->input_dev);

#else

	/* sync after groups of events */

	#ifdef KERNEL_ABOVE_3_7

	input_mt_sync_frame(rmi4_data->input_dev);

	input_mt_report_pointer_emulation(rmi4_data->input_dev, false);

#endif



	input_sync(rmi4_data->input_dev);



	return touch_count;

}



 /**

 * synaptics_rmi4_f12_abs_report()

 *

 * Called by synaptics_rmi4_report_touch() when valid Function $12

 * finger data has been detected.

 *

 * This function reads the Function $12 data registers, determines the

 * status of each finger supported by the Function, processes any

 * necessary coordinate manipulation, reports the finger data to

 * the input subsystem, and returns the number of fingers detected.

 */

static int synaptics_rmi4_f12_abs_report(struct synaptics_rmi4_data *rmi4_data,

		struct synaptics_rmi4_fn *fhandler)

{

	int retval;

	unsigned char touch_count = 0; /* number of touch points */

	unsigned char finger;

	unsigned char fingers_to_process;

	unsigned char finger_status;

	unsigned char size_of_2d_data;

	unsigned short data_addr;

	int x;

	int y;

	int wx;

	int wy;

	struct synaptics_rmi4_f12_extra_data *extra_data;

	struct synaptics_rmi4_f12_finger_data *data;

	struct synaptics_rmi4_f12_finger_data *finger_data;



	fingers_to_process = fhandler->num_of_data_points;

	data_addr = fhandler->full_addr.data_base;

	extra_data = (struct synaptics_rmi4_f12_extra_data *)fhandler->extra;

	size_of_2d_data = sizeof(struct synaptics_rmi4_f12_finger_data);



	retval = synaptics_rmi4_i2c_read(rmi4_data,

			data_addr + extra_data->data1_offset,

			(unsigned char *)fhandler->data,

			fingers_to_process * size_of_2d_data);

	if (retval < 0)

		return 0;



	data = (struct synaptics_rmi4_f12_finger_data *)fhandler->data;



	for (finger = 0; finger < fingers_to_process; finger++) {

		finger_data = data + finger;

		finger_status = finger_data->object_type_and_status & MASK_2BIT;



		/*

		 * Each 2-bit finger status field represents the following:

		 * 00 = finger not present

		 * 01 = finger present and data accurate

		 * 10 = finger present but data may be inaccurate

		 * 11 = reserved

		 */

#ifdef TYPE_B_PROTOCOL

		input_mt_slot(rmi4_data->input_dev, finger);

		input_mt_report_slot_state(rmi4_data->input_dev,

				MT_TOOL_FINGER, finger_status != 0);

#endif



		if (finger_status) {

			x = (finger_data->x_msb << 8) | (finger_data->x_lsb);

			y = (finger_data->y_msb << 8) | (finger_data->y_lsb);

#ifdef REPORT_2D_W

			wx = finger_data->wx;

			wy = finger_data->wy;

#endif



			if (rmi4_data->board->x_flip)

				x = rmi4_data->sensor_max_x - x;

			if (rmi4_data->board->y_flip)

				y = rmi4_data->sensor_max_y - y;



			dev_dbg(&rmi4_data->i2c_client->dev,

					"%s: Finger %d:\n"

					"status = 0x%02x\n"

					"x = %d\n"

					"y = %d\n"

					"wx = %d\n"

					"wy = %d\n",

					__func__, finger,

					finger_status,

					x, y, wx, wy);



			input_report_key(rmi4_data->input_dev,

					BTN_TOUCH, 1);

			input_report_key(rmi4_data->input_dev,

					BTN_TOOL_FINGER, 1);

			input_report_abs(rmi4_data->input_dev,

					ABS_MT_POSITION_X, x);

			input_report_abs(rmi4_data->input_dev,

					ABS_MT_POSITION_Y, y);

#ifdef REPORT_2D_W

			input_report_abs(rmi4_data->input_dev,

					ABS_MT_TOUCH_MAJOR, max(wx, wy));

			input_report_abs(rmi4_data->input_dev,

					ABS_MT_TOUCH_MINOR, min(wx, wy));

#endif

#ifndef TYPE_B_PROTOCOL

			input_mt_sync(rmi4_data->input_dev);

#endif

			touch_count++;

		}

	}



	input_report_key(rmi4_data->input_dev,

			BTN_TOUCH, touch_count > 0);

	input_report_key(rmi4_data->input_dev,

			BTN_TOOL_FINGER, touch_count > 0);

#ifndef TYPE_B_PROTOCOL

	if (!touch_count)

		input_mt_sync(rmi4_data->input_dev);

#endif

	input_mt_report_pointer_emulation(rmi4_data->input_dev, false);

	input_sync(rmi4_data->input_dev);



	return touch_count;
@@ -955,6 +1205,16 @@ static void synaptics_rmi4_report_touch(struct synaptics_rmi4_data *rmi4_data, 
			rmi4_data->fingers_on_2d = false;

		break;



	case SYNAPTICS_RMI4_F12:

		touch_count_2d = synaptics_rmi4_f12_abs_report(rmi4_data,

				fhandler);



		if (touch_count_2d)

			rmi4_data->fingers_on_2d = true;

		else

			rmi4_data->fingers_on_2d = false;

		break;



	case SYNAPTICS_RMI4_F1A:

		synaptics_rmi4_f1a_report(rmi4_data, fhandler);

		break;
@@ -1045,6 +1305,7 @@ static irqreturn_t synaptics_rmi4_irq(int irq, void *data) 
	return IRQ_HANDLED;

}



#ifdef CONFIG_OF

static int synaptics_rmi4_parse_dt(struct device *dev,

				struct synaptics_rmi4_platform_data *rmi4_pdata)

{
@@ -1127,6 +1388,13 @@ static int synaptics_rmi4_parse_dt(struct device *dev, 
	}

	return 0;

}

#else

static inline int synaptics_rmi4_parse_dt(struct device *dev,

				struct synaptics_rmi4_platform_data *rmi4_pdata)

{

	return 0;

}

#endif



 /**

 * synaptics_rmi4_irq_enable()
@@ -1237,6 +1505,8 @@ static int synaptics_rmi4_f11_init(struct synaptics_rmi4_data *rmi4_data, 
			rmi4_data->sensor_max_x,

			rmi4_data->sensor_max_y);



	rmi4_data->max_touch_width = MAX_F11_TOUCH_WIDTH;



	fhandler->intr_reg_num = (intr_count + 7) / 8;

	if (fhandler->intr_reg_num != 0)

		fhandler->intr_reg_num -= 1;
@@ -1257,6 +1527,212 @@ static int synaptics_rmi4_f11_init(struct synaptics_rmi4_data *rmi4_data, 
	return retval;

}



static int synaptics_rmi4_f12_set_enables(struct synaptics_rmi4_data *rmi4_data,

		unsigned short ctrl28)

{

	int retval;

	static unsigned short ctrl_28_address;



	if (ctrl28)

		ctrl_28_address = ctrl28;



	retval = synaptics_rmi4_i2c_write(rmi4_data,

			ctrl_28_address,

			&rmi4_data->report_enable,

			sizeof(rmi4_data->report_enable));

	if (retval < 0)

		return retval;



	return retval;

}



 /**

 * synaptics_rmi4_f12_init()

 *

 * Called by synaptics_rmi4_query_device().

 *

 * This funtion parses information from the Function 12 registers and

 * determines the number of fingers supported, offset to the data1

 * register, x and y data ranges, offset to the associated interrupt

 * status register, interrupt bit mask, and allocates memory resources

 * for finger data acquisition.

 */

static int synaptics_rmi4_f12_init(struct synaptics_rmi4_data *rmi4_data,

		struct synaptics_rmi4_fn *fhandler,

		struct synaptics_rmi4_fn_desc *fd,

		unsigned int intr_count)

{

	int retval;

	unsigned char ii;

	unsigned char intr_offset;

	unsigned char size_of_2d_data;

	unsigned char size_of_query8;

	unsigned char ctrl_8_offset;

	unsigned char ctrl_23_offset;

	unsigned char ctrl_28_offset;

	unsigned char num_of_fingers;

	struct synaptics_rmi4_f12_extra_data *extra_data;

	struct synaptics_rmi4_f12_query_5 query_5;

	struct synaptics_rmi4_f12_query_8 query_8;

	struct synaptics_rmi4_f12_ctrl_8 ctrl_8;

	struct synaptics_rmi4_f12_ctrl_23 ctrl_23;



	fhandler->fn_number = fd->fn_number;

	fhandler->num_of_data_sources = fd->intr_src_count;

	fhandler->extra = kmalloc(sizeof(*extra_data), GFP_KERNEL);

	extra_data = (struct synaptics_rmi4_f12_extra_data *)fhandler->extra;

	size_of_2d_data = sizeof(struct synaptics_rmi4_f12_finger_data);



	retval = synaptics_rmi4_i2c_read(rmi4_data,

			fhandler->full_addr.query_base + 5,

			query_5.data,

			sizeof(query_5.data));

	if (retval < 0)

		return retval;



	ctrl_8_offset = query_5.ctrl0_is_present +

			query_5.ctrl1_is_present +

			query_5.ctrl2_is_present +

			query_5.ctrl3_is_present +

			query_5.ctrl4_is_present +

			query_5.ctrl5_is_present +

			query_5.ctrl6_is_present +

			query_5.ctrl7_is_present;



	ctrl_23_offset = ctrl_8_offset +

			query_5.ctrl8_is_present +

			query_5.ctrl9_is_present +

			query_5.ctrl10_is_present +

			query_5.ctrl11_is_present +

			query_5.ctrl12_is_present +

			query_5.ctrl13_is_present +

			query_5.ctrl14_is_present +

			query_5.ctrl15_is_present +

			query_5.ctrl16_is_present +

			query_5.ctrl17_is_present +

			query_5.ctrl18_is_present +

			query_5.ctrl19_is_present +

			query_5.ctrl20_is_present +

			query_5.ctrl21_is_present +

			query_5.ctrl22_is_present;



	ctrl_28_offset = ctrl_23_offset +

			query_5.ctrl23_is_present +

			query_5.ctrl24_is_present +

			query_5.ctrl25_is_present +

			query_5.ctrl26_is_present +

			query_5.ctrl27_is_present;



	retval = synaptics_rmi4_i2c_read(rmi4_data,

			fhandler->full_addr.ctrl_base + ctrl_23_offset,

			ctrl_23.data,

			sizeof(ctrl_23.data));

	if (retval < 0)

		return retval;



	/* Maximum number of fingers supported */

	fhandler->num_of_data_points = min(ctrl_23.max_reported_objects,

			(unsigned char)F12_FINGERS_TO_SUPPORT);



	num_of_fingers = fhandler->num_of_data_points;

	rmi4_data->num_of_fingers = num_of_fingers;



	retval = synaptics_rmi4_i2c_read(rmi4_data,

			fhandler->full_addr.query_base + 7,

			&size_of_query8,

			sizeof(size_of_query8));

	if (retval < 0)

		return retval;



	retval = synaptics_rmi4_i2c_read(rmi4_data,

			fhandler->full_addr.query_base + 8,

			query_8.data,

			size_of_query8);

	if (retval < 0)

		return retval;



	/* Determine the presence of the Data0 register */

	extra_data->data1_offset = query_8.data0_is_present;



	if ((size_of_query8 >= 3) && (query_8.data15_is_present)) {

		extra_data->data15_offset = query_8.data0_is_present +

				query_8.data1_is_present +

				query_8.data2_is_present +

				query_8.data3_is_present +

				query_8.data4_is_present +

				query_8.data5_is_present +

				query_8.data6_is_present +

				query_8.data7_is_present +

				query_8.data8_is_present +

				query_8.data9_is_present +

				query_8.data10_is_present +

				query_8.data11_is_present +

				query_8.data12_is_present +

				query_8.data13_is_present +

				query_8.data14_is_present;

		extra_data->data15_size = (num_of_fingers + 7) / 8;

	} else {

		extra_data->data15_size = 0;

	}



	rmi4_data->report_enable = RPT_DEFAULT;

#ifdef REPORT_2D_Z

	rmi4_data->report_enable |= RPT_Z;

#endif

#ifdef REPORT_2D_W

	rmi4_data->report_enable |= (RPT_WX | RPT_WY);

#endif



	retval = synaptics_rmi4_f12_set_enables(rmi4_data,

			fhandler->full_addr.ctrl_base + ctrl_28_offset);

	if (retval < 0)

		return retval;



	retval = synaptics_rmi4_i2c_read(rmi4_data,

			fhandler->full_addr.ctrl_base + ctrl_8_offset,

			ctrl_8.data,

			sizeof(ctrl_8.data));

	if (retval < 0)

		return retval;



	/* Maximum x and y */

	rmi4_data->sensor_max_x =

			((unsigned short)ctrl_8.max_x_coord_lsb << 0) |

			((unsigned short)ctrl_8.max_x_coord_msb << 8);

	rmi4_data->sensor_max_y =

			((unsigned short)ctrl_8.max_y_coord_lsb << 0) |

			((unsigned short)ctrl_8.max_y_coord_msb << 8);

	dev_dbg(&rmi4_data->i2c_client->dev,

			"%s: Function %02x max x = %d max y = %d\n",

			__func__, fhandler->fn_number,

			rmi4_data->sensor_max_x,

			rmi4_data->sensor_max_y);



	rmi4_data->num_of_rx = ctrl_8.num_of_rx;

	rmi4_data->num_of_tx = ctrl_8.num_of_tx;

	rmi4_data->max_touch_width = max(rmi4_data->num_of_rx,

			rmi4_data->num_of_tx);



	fhandler->intr_reg_num = (intr_count + 7) / 8;

	if (fhandler->intr_reg_num != 0)

		fhandler->intr_reg_num -= 1;



	/* Set an enable bit for each data source */

	intr_offset = intr_count % 8;

	fhandler->intr_mask = 0;

	for (ii = intr_offset;

			ii < ((fd->intr_src_count & MASK_3BIT) +

			intr_offset);

			ii++)

		fhandler->intr_mask |= 1 << ii;



	/* Allocate memory for finger data storage space */

	fhandler->data_size = num_of_fingers * size_of_2d_data;

	fhandler->data = kmalloc(fhandler->data_size, GFP_KERNEL);



	return retval;

}



static int synaptics_rmi4_f1a_alloc_mem(struct synaptics_rmi4_data *rmi4_data,

		struct synaptics_rmi4_fn *fhandler)

{
@@ -1601,6 +2077,26 @@ static int synaptics_rmi4_query_device(struct synaptics_rmi4_data *rmi4_data) 
					return retval;

				break;



			case SYNAPTICS_RMI4_F12:

				if (rmi_fd.intr_src_count == 0)

					break;



				retval = synaptics_rmi4_alloc_fh(&fhandler,

						&rmi_fd, page_number);

				if (retval < 0) {

					dev_err(&rmi4_data->i2c_client->dev,

							"%s: Failed to alloc for F%d\n",

							__func__,

							rmi_fd.fn_number);

					return retval;

				}



				retval = synaptics_rmi4_f12_init(rmi4_data,

						fhandler, &rmi_fd, intr_count);

				if (retval < 0)

					return retval;

				break;



			case SYNAPTICS_RMI4_F1A:

				if (rmi_fd.intr_src_count == 0)

					break;
@@ -1760,8 +2256,10 @@ static int synaptics_rmi4_reset_device(struct synaptics_rmi4_data *rmi4_data) 
		list_for_each_entry(fhandler, &rmi->support_fn_list, link) {

			if (fhandler->fn_number == SYNAPTICS_RMI4_F1A)

				synaptics_rmi4_f1a_kfree(fhandler);

			else

			else {

				kfree(fhandler->data);

				kfree(fhandler->extra);

			}

			kfree(fhandler);

		}

	}
@@ -2260,7 +2758,10 @@ static int synaptics_rmi4_probe(struct i2c_client *client, 
#ifdef REPORT_2D_W

	input_set_abs_params(rmi4_data->input_dev,

			ABS_MT_TOUCH_MAJOR, 0,

			MAX_ABS_MT_TOUCH_MAJOR, 0, 0);

			rmi4_data->max_touch_width, 0, 0);

	input_set_abs_params(rmi4_data->input_dev,

			ABS_MT_TOUCH_MINOR, 0,

			rmi4_data->max_touch_width, 0, 0);

#endif



#ifdef TYPE_B_PROTOCOL
@@ -2384,8 +2885,10 @@ err_register_input: 
		list_for_each_entry(fhandler, &rmi->support_fn_list, link) {

			if (fhandler->fn_number == SYNAPTICS_RMI4_F1A)

				synaptics_rmi4_f1a_kfree(fhandler);

			else

			else {

				kfree(fhandler->data);

				kfree(fhandler->extra);

			}

			kfree(fhandler);

		}

	}
@@ -2447,8 +2950,10 @@ static int synaptics_rmi4_remove(struct i2c_client *client) 
		list_for_each_entry(fhandler, &rmi->support_fn_list, link) {

			if (fhandler->fn_number == SYNAPTICS_RMI4_F1A)

				synaptics_rmi4_f1a_kfree(fhandler);

			else

			else {

				kfree(fhandler->data);

				kfree(fhandler->extra);

			}

			kfree(fhandler);

		}

	}

drivers/input/touchscreen/synaptics_i2c_rmi4.h

+4 −0
Original line number Diff line number Diff line
@@ -45,6 +45,7 @@ 


#define SYNAPTICS_RMI4_F01 (0x01)

#define SYNAPTICS_RMI4_F11 (0x11)

#define SYNAPTICS_RMI4_F12 (0x12)

#define SYNAPTICS_RMI4_F1A (0x1a)

#define SYNAPTICS_RMI4_F34 (0x34)

#define SYNAPTICS_RMI4_F54 (0x54)
@@ -129,6 +130,7 @@ struct synaptics_rmi4_fn { 
	struct list_head link;

	int data_size;

	void *data;

	void *extra;

};



/*
@@ -214,6 +216,8 @@ struct synaptics_rmi4_data { 
	unsigned char num_of_rx;

	unsigned char num_of_tx;

	unsigned char num_of_fingers;

	unsigned char max_touch_width;

	unsigned char report_enable;

	unsigned char intr_mask[MAX_INTR_REGISTERS];

	unsigned short num_of_intr_regs;

	unsigned short f01_query_base_addr;