[linux-2.6-block.git] / drivers / input / rmi4 / rmi_f12.c

/*
 * Copyright (c) 2012-2016 Synaptics Incorporated
 *
 * 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.
 */
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/rmi.h>
#include "rmi_driver.h"
#include "rmi_2d_sensor.h"

enum rmi_f12_object_type {
	RMI_F12_OBJECT_NONE			= 0x00,
	RMI_F12_OBJECT_FINGER			= 0x01,
	RMI_F12_OBJECT_STYLUS			= 0x02,
	RMI_F12_OBJECT_PALM			= 0x03,
	RMI_F12_OBJECT_UNCLASSIFIED		= 0x04,
	RMI_F12_OBJECT_GLOVED_FINGER		= 0x06,
	RMI_F12_OBJECT_NARROW_OBJECT		= 0x07,
	RMI_F12_OBJECT_HAND_EDGE		= 0x08,
	RMI_F12_OBJECT_COVER			= 0x0A,
	RMI_F12_OBJECT_STYLUS_2			= 0x0B,
	RMI_F12_OBJECT_ERASER			= 0x0C,
	RMI_F12_OBJECT_SMALL_OBJECT		= 0x0D,
};

struct f12_data {
	struct rmi_function *fn;
	struct rmi_2d_sensor sensor;
	struct rmi_2d_sensor_platform_data sensor_pdata;

	u16 data_addr;

	struct rmi_register_descriptor query_reg_desc;
	struct rmi_register_descriptor control_reg_desc;
	struct rmi_register_descriptor data_reg_desc;

	/* F12 Data1 describes sensed objects */
	const struct rmi_register_desc_item *data1;
	u16 data1_offset;

	/* F12 Data5 describes finger ACM */
	const struct rmi_register_desc_item *data5;
	u16 data5_offset;

	/* F12 Data5 describes Pen */
	const struct rmi_register_desc_item *data6;
	u16 data6_offset;


	/* F12 Data9 reports relative data */
	const struct rmi_register_desc_item *data9;
	u16 data9_offset;

	const struct rmi_register_desc_item *data15;
	u16 data15_offset;
};

static int rmi_f12_read_sensor_tuning(struct f12_data *f12)
{
	const struct rmi_register_desc_item *item;
	struct rmi_2d_sensor *sensor = &f12->sensor;
	struct rmi_function *fn = sensor->fn;
	struct rmi_device *rmi_dev = fn->rmi_dev;
	int ret;
	int offset;
	u8 buf[15];
	int pitch_x = 0;
	int pitch_y = 0;
	int clip_x_low = 0;
	int clip_x_high = 0;
	int clip_y_low = 0;
	int clip_y_high = 0;
	int rx_receivers = 0;
	int tx_receivers = 0;
	int sensor_flags = 0;

	item = rmi_get_register_desc_item(&f12->control_reg_desc, 8);
	if (!item) {
		dev_err(&fn->dev,
			"F12 does not have the sensor tuning control register\n");
		return -ENODEV;
	}

	offset = rmi_register_desc_calc_reg_offset(&f12->control_reg_desc, 8);

	if (item->reg_size > sizeof(buf)) {
		dev_err(&fn->dev,
			"F12 control8 should be no bigger than %zd bytes, not: %ld\n",
			sizeof(buf), item->reg_size);
		return -ENODEV;
	}

	ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr + offset, buf,
				item->reg_size);
	if (ret)
		return ret;

	offset = 0;
	if (rmi_register_desc_has_subpacket(item, 0)) {
		sensor->max_x = (buf[offset + 1] << 8) | buf[offset];
		sensor->max_y = (buf[offset + 3] << 8) | buf[offset + 2];
		offset += 4;
	}

	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: max_x: %d max_y: %d\n", __func__,
		sensor->max_x, sensor->max_y);

	if (rmi_register_desc_has_subpacket(item, 1)) {
		pitch_x = (buf[offset + 1] << 8) | buf[offset];
		pitch_y	= (buf[offset + 3] << 8) | buf[offset + 2];
		offset += 4;
	}

	if (rmi_register_desc_has_subpacket(item, 2)) {
		sensor->axis_align.clip_x_low = buf[offset];
		sensor->axis_align.clip_x_high = sensor->max_x
							- buf[offset + 1];
		sensor->axis_align.clip_y_low = buf[offset + 2];
		sensor->axis_align.clip_y_high = sensor->max_y
							- buf[offset + 3];
		offset += 4;
	}

	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x low: %d x high: %d y low: %d y high: %d\n",
		__func__, clip_x_low, clip_x_high, clip_y_low, clip_y_high);

	if (rmi_register_desc_has_subpacket(item, 3)) {
		rx_receivers = buf[offset];
		tx_receivers = buf[offset + 1];
		offset += 2;
	}

	if (rmi_register_desc_has_subpacket(item, 4)) {
		sensor_flags = buf[offset];
		offset += 1;
	}

	sensor->x_mm = (pitch_x * rx_receivers) >> 12;
	sensor->y_mm = (pitch_y * tx_receivers) >> 12;

	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x_mm: %d y_mm: %d\n", __func__,
		sensor->x_mm, sensor->y_mm);

	return 0;
}

static void rmi_f12_process_objects(struct f12_data *f12, u8 *data1)
{
	int i;
	struct rmi_2d_sensor *sensor = &f12->sensor;

	for (i = 0; i < f12->data1->num_subpackets; i++) {
		struct rmi_2d_sensor_abs_object *obj = &sensor->objs[i];

		obj->type = RMI_2D_OBJECT_NONE;
		obj->mt_tool = MT_TOOL_FINGER;

		switch (data1[0]) {
		case RMI_F12_OBJECT_FINGER:
			obj->type = RMI_2D_OBJECT_FINGER;
			break;
		case RMI_F12_OBJECT_STYLUS:
			obj->type = RMI_2D_OBJECT_STYLUS;
			obj->mt_tool = MT_TOOL_PEN;
			break;
		case RMI_F12_OBJECT_PALM:
			obj->type = RMI_2D_OBJECT_PALM;
			obj->mt_tool = MT_TOOL_PALM;
			break;
		case RMI_F12_OBJECT_UNCLASSIFIED:
			obj->type = RMI_2D_OBJECT_UNCLASSIFIED;
			break;
		}

		obj->x = (data1[2] << 8) | data1[1];
		obj->y = (data1[4] << 8) | data1[3];
		obj->z = data1[5];
		obj->wx = data1[6];
		obj->wy = data1[7];

		rmi_2d_sensor_abs_process(sensor, obj, i);

		data1 += 8;
	}

	if (sensor->kernel_tracking)
		input_mt_assign_slots(sensor->input,
				      sensor->tracking_slots,
				      sensor->tracking_pos,
				      sensor->nbr_fingers,
				      sensor->dmax);

	for (i = 0; i < sensor->nbr_fingers; i++)
		rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
}

static int rmi_f12_attention(struct rmi_function *fn,
			     unsigned long *irq_nr_regs)
{
	int retval;
	struct rmi_device *rmi_dev = fn->rmi_dev;
	struct f12_data *f12 = dev_get_drvdata(&fn->dev);
	struct rmi_2d_sensor *sensor = &f12->sensor;

	if (rmi_dev->xport->attn_data) {
		memcpy(sensor->data_pkt, rmi_dev->xport->attn_data,
			sensor->attn_size);
		rmi_dev->xport->attn_data += sensor->attn_size;
		rmi_dev->xport->attn_size -= sensor->attn_size;
	} else {
		retval = rmi_read_block(rmi_dev, f12->data_addr,
					sensor->data_pkt, sensor->pkt_size);
		if (retval < 0) {
			dev_err(&fn->dev, "Failed to read object data. Code: %d.\n",
				retval);
			return retval;
		}
	}

	if (f12->data1)
		rmi_f12_process_objects(f12,
			&sensor->data_pkt[f12->data1_offset]);

	input_mt_sync_frame(sensor->input);

	return 0;
}

static int rmi_f12_config(struct rmi_function *fn)
{
	struct rmi_driver *drv = fn->rmi_dev->driver;

	drv->set_irq_bits(fn->rmi_dev, fn->irq_mask);

	return 0;
}

static int rmi_f12_probe(struct rmi_function *fn)
{
	struct f12_data *f12;
	int ret;
	struct rmi_device *rmi_dev = fn->rmi_dev;
	char buf;
	u16 query_addr = fn->fd.query_base_addr;
	const struct rmi_register_desc_item *item;
	struct rmi_2d_sensor *sensor;
	struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
	struct rmi_transport_dev *xport = rmi_dev->xport;
	u16 data_offset = 0;

	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s\n", __func__);

	ret = rmi_read(fn->rmi_dev, query_addr, &buf);
	if (ret < 0) {
		dev_err(&fn->dev, "Failed to read general info register: %d\n",
			ret);
		return -ENODEV;
	}
	++query_addr;

	if (!(buf & 0x1)) {
		dev_err(&fn->dev,
			"Behavior of F12 without register descriptors is undefined.\n");
		return -ENODEV;
	}

	f12 = devm_kzalloc(&fn->dev, sizeof(struct f12_data), GFP_KERNEL);
	if (!f12)
		return -ENOMEM;

	if (fn->dev.of_node) {
		ret = rmi_2d_sensor_of_probe(&fn->dev, &f12->sensor_pdata);
		if (ret)
			return ret;
	} else if (pdata->sensor_pdata) {
		f12->sensor_pdata = *pdata->sensor_pdata;
	}

	ret = rmi_read_register_desc(rmi_dev, query_addr,
					&f12->query_reg_desc);
	if (ret) {
		dev_err(&fn->dev,
			"Failed to read the Query Register Descriptor: %d\n",
			ret);
		return ret;
	}
	query_addr += 3;

	ret = rmi_read_register_desc(rmi_dev, query_addr,
						&f12->control_reg_desc);
	if (ret) {
		dev_err(&fn->dev,
			"Failed to read the Control Register Descriptor: %d\n",
			ret);
		return ret;
	}
	query_addr += 3;

	ret = rmi_read_register_desc(rmi_dev, query_addr,
						&f12->data_reg_desc);
	if (ret) {
		dev_err(&fn->dev,
			"Failed to read the Data Register Descriptor: %d\n",
			ret);
		return ret;
	}
	query_addr += 3;

	sensor = &f12->sensor;
	sensor->fn = fn;
	f12->data_addr = fn->fd.data_base_addr;
	sensor->pkt_size = rmi_register_desc_calc_size(&f12->data_reg_desc);

	sensor->axis_align =
		f12->sensor_pdata.axis_align;

	sensor->x_mm = f12->sensor_pdata.x_mm;
	sensor->y_mm = f12->sensor_pdata.y_mm;

	if (sensor->sensor_type == rmi_sensor_default)
		sensor->sensor_type =
			f12->sensor_pdata.sensor_type;

	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: data packet size: %d\n", __func__,
		sensor->pkt_size);
	sensor->data_pkt = devm_kzalloc(&fn->dev, sensor->pkt_size, GFP_KERNEL);
	if (!sensor->data_pkt)
		return -ENOMEM;

	dev_set_drvdata(&fn->dev, f12);

	ret = rmi_f12_read_sensor_tuning(f12);
	if (ret)
		return ret;

	/*
	 * Figure out what data is contained in the data registers. HID devices
	 * may have registers defined, but their data is not reported in the
	 * HID attention report. Registers which are not reported in the HID
	 * attention report check to see if the device is receiving data from
	 * HID attention reports.
	 */
	item = rmi_get_register_desc_item(&f12->data_reg_desc, 0);
	if (item && !xport->attn_data)
		data_offset += item->reg_size;

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 1);
	if (item) {
		f12->data1 = item;
		f12->data1_offset = data_offset;
		data_offset += item->reg_size;
		sensor->nbr_fingers = item->num_subpackets;
		sensor->report_abs = 1;
		sensor->attn_size += item->reg_size;
	}

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 2);
	if (item && !xport->attn_data)
		data_offset += item->reg_size;

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 3);
	if (item && !xport->attn_data)
		data_offset += item->reg_size;

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 4);
	if (item && !xport->attn_data)
		data_offset += item->reg_size;

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 5);
	if (item) {
		f12->data5 = item;
		f12->data5_offset = data_offset;
		data_offset += item->reg_size;
		sensor->attn_size += item->reg_size;
	}

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 6);
	if (item && !xport->attn_data) {
		f12->data6 = item;
		f12->data6_offset = data_offset;
		data_offset += item->reg_size;
	}

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 7);
	if (item && !xport->attn_data)
		data_offset += item->reg_size;

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 8);
	if (item && !xport->attn_data)
		data_offset += item->reg_size;

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 9);
	if (item && !xport->attn_data) {
		f12->data9 = item;
		f12->data9_offset = data_offset;
		data_offset += item->reg_size;
		if (!sensor->report_abs)
			sensor->report_rel = 1;
	}

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 10);
	if (item && !xport->attn_data)
		data_offset += item->reg_size;

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 11);
	if (item && !xport->attn_data)
		data_offset += item->reg_size;

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 12);
	if (item && !xport->attn_data)
		data_offset += item->reg_size;

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 13);
	if (item && !xport->attn_data)
		data_offset += item->reg_size;

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 14);
	if (item && !xport->attn_data)
		data_offset += item->reg_size;

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 15);
	if (item && !xport->attn_data) {
		f12->data15 = item;
		f12->data15_offset = data_offset;
		data_offset += item->reg_size;
	}

	/* allocate the in-kernel tracking buffers */
	sensor->tracking_pos = devm_kzalloc(&fn->dev,
			sizeof(struct input_mt_pos) * sensor->nbr_fingers,
			GFP_KERNEL);
	sensor->tracking_slots = devm_kzalloc(&fn->dev,
			sizeof(int) * sensor->nbr_fingers, GFP_KERNEL);
	sensor->objs = devm_kzalloc(&fn->dev,
			sizeof(struct rmi_2d_sensor_abs_object)
			* sensor->nbr_fingers, GFP_KERNEL);
	if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs)
		return -ENOMEM;

	ret = rmi_2d_sensor_configure_input(fn, sensor);
	if (ret)
		return ret;

	return 0;
}

struct rmi_function_handler rmi_f12_handler = {
	.driver = {
		.name = "rmi4_f12",
	},
	.func = 0x12,
	.probe = rmi_f12_probe,
	.config = rmi_f12_config,
	.attention = rmi_f12_attention,
};
Commit	Line	Data
b43d2c1e AD	1	/*
	2	* Copyright (c) 2012-2016 Synaptics Incorporated
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU General Public License version 2 as published by
	6	* the Free Software Foundation.
	7	*/
	8	#include <linux/input.h>
	9	#include <linux/input/mt.h>
	10	#include <linux/rmi.h>
	11	#include "rmi_driver.h"
	12	#include "rmi_2d_sensor.h"
	13
	14	enum rmi_f12_object_type {
	15	RMI_F12_OBJECT_NONE = 0x00,
	16	RMI_F12_OBJECT_FINGER = 0x01,
	17	RMI_F12_OBJECT_STYLUS = 0x02,
	18	RMI_F12_OBJECT_PALM = 0x03,
	19	RMI_F12_OBJECT_UNCLASSIFIED = 0x04,
	20	RMI_F12_OBJECT_GLOVED_FINGER = 0x06,
	21	RMI_F12_OBJECT_NARROW_OBJECT = 0x07,
	22	RMI_F12_OBJECT_HAND_EDGE = 0x08,
	23	RMI_F12_OBJECT_COVER = 0x0A,
	24	RMI_F12_OBJECT_STYLUS_2 = 0x0B,
	25	RMI_F12_OBJECT_ERASER = 0x0C,
	26	RMI_F12_OBJECT_SMALL_OBJECT = 0x0D,
	27	};
	28
	29	struct f12_data {
	30	struct rmi_function *fn;
	31	struct rmi_2d_sensor sensor;
	32	struct rmi_2d_sensor_platform_data sensor_pdata;
	33
	34	u16 data_addr;
	35
	36	struct rmi_register_descriptor query_reg_desc;
	37	struct rmi_register_descriptor control_reg_desc;
	38	struct rmi_register_descriptor data_reg_desc;
	39
	40	/* F12 Data1 describes sensed objects */
	41	const struct rmi_register_desc_item *data1;
	42	u16 data1_offset;
	43
	44	/* F12 Data5 describes finger ACM */
	45	const struct rmi_register_desc_item *data5;
	46	u16 data5_offset;
	47
	48	/* F12 Data5 describes Pen */
	49	const struct rmi_register_desc_item *data6;
	50	u16 data6_offset;
	51
	52
	53	/* F12 Data9 reports relative data */
	54	const struct rmi_register_desc_item *data9;
	55	u16 data9_offset;
	56
	57	const struct rmi_register_desc_item *data15;
	58	u16 data15_offset;
	59	};
	60
	61	static int rmi_f12_read_sensor_tuning(struct f12_data *f12)
	62	{
	63	const struct rmi_register_desc_item *item;
	64	struct rmi_2d_sensor *sensor = &f12->sensor;
65	struct rmi_function *fn = sensor->fn;
66	struct rmi_device *rmi_dev = fn->rmi_dev;
67	int ret;
68	int offset;
e4add7b6	69	u8 buf[15];
b43d2c1e AD	70	int pitch_x = 0;
	71	int pitch_y = 0;
	72	int clip_x_low = 0;
	73	int clip_x_high = 0;
	74	int clip_y_low = 0;
	75	int clip_y_high = 0;
	76	int rx_receivers = 0;
	77	int tx_receivers = 0;
	78	int sensor_flags = 0;
	79
	80	item = rmi_get_register_desc_item(&f12->control_reg_desc, 8);
	81	if (!item) {
	82	dev_err(&fn->dev,
	83	"F12 does not have the sensor tuning control register\n");
	84	return -ENODEV;
	85	}
	86
	87	offset = rmi_register_desc_calc_reg_offset(&f12->control_reg_desc, 8);
	88
e4add7b6 AD	89	if (item->reg_size > sizeof(buf)) {
	90	dev_err(&fn->dev,
	91	"F12 control8 should be no bigger than %zd bytes, not: %ld\n",
	92	sizeof(buf), item->reg_size);
b43d2c1e AD	93	return -ENODEV;
	94	}
	95
	96	ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr + offset, buf,
	97	item->reg_size);
	98	if (ret)
	99	return ret;
	100
	101	offset = 0;
	102	if (rmi_register_desc_has_subpacket(item, 0)) {
	103	sensor->max_x = (buf[offset + 1] << 8) \| buf[offset];
	104	sensor->max_y = (buf[offset + 3] << 8) \| buf[offset + 2];
	105	offset += 4;
	106	}
	107
	108	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: max_x: %d max_y: %d\n", __func__,
	109	sensor->max_x, sensor->max_y);
	110
	111	if (rmi_register_desc_has_subpacket(item, 1)) {
	112	pitch_x = (buf[offset + 1] << 8) \| buf[offset];
	113	pitch_y = (buf[offset + 3] << 8) \| buf[offset + 2];
	114	offset += 4;
	115	}
	116
	117	if (rmi_register_desc_has_subpacket(item, 2)) {
	118	sensor->axis_align.clip_x_low = buf[offset];
	119	sensor->axis_align.clip_x_high = sensor->max_x
	120	- buf[offset + 1];
	121	sensor->axis_align.clip_y_low = buf[offset + 2];
	122	sensor->axis_align.clip_y_high = sensor->max_y
	123	- buf[offset + 3];
	124	offset += 4;
	125	}
	126
	127	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x low: %d x high: %d y low: %d y high: %d\n",
	128	__func__, clip_x_low, clip_x_high, clip_y_low, clip_y_high);
	129
	130	if (rmi_register_desc_has_subpacket(item, 3)) {
	131	rx_receivers = buf[offset];
	132	tx_receivers = buf[offset + 1];
	133	offset += 2;
	134	}
	135
	136	if (rmi_register_desc_has_subpacket(item, 4)) {
	137	sensor_flags = buf[offset];
	138	offset += 1;
	139	}
	140
	141	sensor->x_mm = (pitch_x * rx_receivers) >> 12;
	142	sensor->y_mm = (pitch_y * tx_receivers) >> 12;
	143
	144	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x_mm: %d y_mm: %d\n", __func__,
	145	sensor->x_mm, sensor->y_mm);
	146
	147	return 0;
	148	}
	149
	150	static void rmi_f12_process_objects(struct f12_data f12, u8 data1)
	151	{
	152	int i;
	153	struct rmi_2d_sensor *sensor = &f12->sensor;
	154
	155	for (i = 0; i < f12->data1->num_subpackets; i++) {
	156	struct rmi_2d_sensor_abs_object *obj = &sensor->objs[i];
157
158	obj->type = RMI_2D_OBJECT_NONE;
159	obj->mt_tool = MT_TOOL_FINGER;
160
161	switch (data1[0]) {
162	case RMI_F12_OBJECT_FINGER:
163	obj->type = RMI_2D_OBJECT_FINGER;
164	break;
165	case RMI_F12_OBJECT_STYLUS:
166	obj->type = RMI_2D_OBJECT_STYLUS;
167	obj->mt_tool = MT_TOOL_PEN;
168	break;
169	case RMI_F12_OBJECT_PALM:
170	obj->type = RMI_2D_OBJECT_PALM;
171	obj->mt_tool = MT_TOOL_PALM;
172	break;
173	case RMI_F12_OBJECT_UNCLASSIFIED:
174	obj->type = RMI_2D_OBJECT_UNCLASSIFIED;
175	break;
176	}
177
178	obj->x = (data1[2] << 8) \| data1[1];
179	obj->y = (data1[4] << 8) \| data1[3];
180	obj->z = data1[5];
181	obj->wx = data1[6];
182	obj->wy = data1[7];
183
184	rmi_2d_sensor_abs_process(sensor, obj, i);
185
186	data1 += 8;
187	}
188
189	if (sensor->kernel_tracking)
190	input_mt_assign_slots(sensor->input,
191	sensor->tracking_slots,
192	sensor->tracking_pos,
193	sensor->nbr_fingers,
194	sensor->dmax);
195
196	for (i = 0; i < sensor->nbr_fingers; i++)
197	rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
198	}
199
200	static int rmi_f12_attention(struct rmi_function *fn,
201	unsigned long *irq_nr_regs)
202	{
203	int retval;
204	struct rmi_device *rmi_dev = fn->rmi_dev;
205	struct f12_data *f12 = dev_get_drvdata(&fn->dev);
206	struct rmi_2d_sensor *sensor = &f12->sensor;
207
208	if (rmi_dev->xport->attn_data) {
209	memcpy(sensor->data_pkt, rmi_dev->xport->attn_data,
210	sensor->attn_size);
211	rmi_dev->xport->attn_data += sensor->attn_size;
212	rmi_dev->xport->attn_size -= sensor->attn_size;
213	} else {
214	retval = rmi_read_block(rmi_dev, f12->data_addr,
215	sensor->data_pkt, sensor->pkt_size);
216	if (retval < 0) {
217	dev_err(&fn->dev, "Failed to read object data. Code: %d.\n",
218	retval);
219	return retval;
220	}
221	}
222
223	if (f12->data1)
224	rmi_f12_process_objects(f12,
225	&sensor->data_pkt[f12->data1_offset]);
226
227	input_mt_sync_frame(sensor->input);
228
229	return 0;
230	}
231
232	static int rmi_f12_config(struct rmi_function *fn)
233	{
234	struct rmi_driver *drv = fn->rmi_dev->driver;
235
236	drv->set_irq_bits(fn->rmi_dev, fn->irq_mask);
237
238	return 0;
239	}
240
241	static int rmi_f12_probe(struct rmi_function *fn)
242	{
243	struct f12_data *f12;
244	int ret;
245	struct rmi_device *rmi_dev = fn->rmi_dev;
246	char buf;
247	u16 query_addr = fn->fd.query_base_addr;
248	const struct rmi_register_desc_item *item;
249	struct rmi_2d_sensor *sensor;
250	struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
251	struct rmi_transport_dev *xport = rmi_dev->xport;
252	u16 data_offset = 0;
253
254	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s\n", __func__);
255
256	ret = rmi_read(fn->rmi_dev, query_addr, &buf);
257	if (ret < 0) {
258	dev_err(&fn->dev, "Failed to read general info register: %d\n",
259	ret);
260	return -ENODEV;
261	}
262	++query_addr;
263
264	if (!(buf & 0x1)) {
265	dev_err(&fn->dev,
266	"Behavior of F12 without register descriptors is undefined.\n");
267	return -ENODEV;
268	}
269
270	f12 = devm_kzalloc(&fn->dev, sizeof(struct f12_data), GFP_KERNEL);
271	if (!f12)
272	return -ENOMEM;
273
274	if (fn->dev.of_node) {
275	ret = rmi_2d_sensor_of_probe(&fn->dev, &f12->sensor_pdata);
276	if (ret)
277	return ret;
278	} else if (pdata->sensor_pdata) {
279	f12->sensor_pdata = *pdata->sensor_pdata;
280	}
281
282	ret = rmi_read_register_desc(rmi_dev, query_addr,
283	&f12->query_reg_desc);
284	if (ret) {
285	dev_err(&fn->dev,
286	"Failed to read the Query Register Descriptor: %d\n",
287	ret);
288	return ret;
289	}
290	query_addr += 3;
291
292	ret = rmi_read_register_desc(rmi_dev, query_addr,
293	&f12->control_reg_desc);
294	if (ret) {
295	dev_err(&fn->dev,
296	"Failed to read the Control Register Descriptor: %d\n",
297	ret);
298	return ret;
299	}
300	query_addr += 3;
301
302	ret = rmi_read_register_desc(rmi_dev, query_addr,
303	&f12->data_reg_desc);
304	if (ret) {
305	dev_err(&fn->dev,
306	"Failed to read the Data Register Descriptor: %d\n",
307	ret);
308	return ret;
309	}
310	query_addr += 3;
311
312	sensor = &f12->sensor;
313	sensor->fn = fn;
314	f12->data_addr = fn->fd.data_base_addr;
315	sensor->pkt_size = rmi_register_desc_calc_size(&f12->data_reg_desc);
316
317	sensor->axis_align =
318	f12->sensor_pdata.axis_align;
319
320	sensor->x_mm = f12->sensor_pdata.x_mm;
321	sensor->y_mm = f12->sensor_pdata.y_mm;
322
323	if (sensor->sensor_type == rmi_sensor_default)
324	sensor->sensor_type =
325	f12->sensor_pdata.sensor_type;
326
327	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: data packet size: %d\n", __func__,
328	sensor->pkt_size);
329	sensor->data_pkt = devm_kzalloc(&fn->dev, sensor->pkt_size, GFP_KERNEL);
330	if (!sensor->data_pkt)
331	return -ENOMEM;
332
333	dev_set_drvdata(&fn->dev, f12);
334
335	ret = rmi_f12_read_sensor_tuning(f12);
336	if (ret)
337	return ret;
338
339	/*
340	* Figure out what data is contained in the data registers. HID devices
341	* may have registers defined, but their data is not reported in the
342	* HID attention report. Registers which are not reported in the HID
343	* attention report check to see if the device is receiving data from
344	* HID attention reports.
345	*/
346	item = rmi_get_register_desc_item(&f12->data_reg_desc, 0);
347	if (item && !xport->attn_data)
348	data_offset += item->reg_size;
349
350	item = rmi_get_register_desc_item(&f12->data_reg_desc, 1);
351	if (item) {
352	f12->data1 = item;
353	f12->data1_offset = data_offset;
354	data_offset += item->reg_size;
355	sensor->nbr_fingers = item->num_subpackets;
356	sensor->report_abs = 1;
357	sensor->attn_size += item->reg_size;
358	}
359
360	item = rmi_get_register_desc_item(&f12->data_reg_desc, 2);
361	if (item && !xport->attn_data)
362	data_offset += item->reg_size;
363
364	item = rmi_get_register_desc_item(&f12->data_reg_desc, 3);
365	if (item && !xport->attn_data)
366	data_offset += item->reg_size;
367
368	item = rmi_get_register_desc_item(&f12->data_reg_desc, 4);
369	if (item && !xport->attn_data)
370	data_offset += item->reg_size;
371
372	item = rmi_get_register_desc_item(&f12->data_reg_desc, 5);
373	if (item) {
374	f12->data5 = item;
375	f12->data5_offset = data_offset;
376	data_offset += item->reg_size;
377	sensor->attn_size += item->reg_size;
378	}
379
380	item = rmi_get_register_desc_item(&f12->data_reg_desc, 6);
381	if (item && !xport->attn_data) {
382	f12->data6 = item;
383	f12->data6_offset = data_offset;
384	data_offset += item->reg_size;
385	}
386
387	item = rmi_get_register_desc_item(&f12->data_reg_desc, 7);
388	if (item && !xport->attn_data)
389	data_offset += item->reg_size;
390
391	item = rmi_get_register_desc_item(&f12->data_reg_desc, 8);
392	if (item && !xport->attn_data)
393	data_offset += item->reg_size;
394
395	item = rmi_get_register_desc_item(&f12->data_reg_desc, 9);
396	if (item && !xport->attn_data) {
397	f12->data9 = item;
398	f12->data9_offset = data_offset;
399	data_offset += item->reg_size;
400	if (!sensor->report_abs)
401	sensor->report_rel = 1;
402	}
403
404	item = rmi_get_register_desc_item(&f12->data_reg_desc, 10);
405	if (item && !xport->attn_data)
406	data_offset += item->reg_size;
407
408	item = rmi_get_register_desc_item(&f12->data_reg_desc, 11);
409	if (item && !xport->attn_data)
410	data_offset += item->reg_size;
411
412	item = rmi_get_register_desc_item(&f12->data_reg_desc, 12);
413	if (item && !xport->attn_data)
414	data_offset += item->reg_size;
415
416	item = rmi_get_register_desc_item(&f12->data_reg_desc, 13);
417	if (item && !xport->attn_data)
418	data_offset += item->reg_size;
419
420	item = rmi_get_register_desc_item(&f12->data_reg_desc, 14);
421	if (item && !xport->attn_data)
422	data_offset += item->reg_size;
423
424	item = rmi_get_register_desc_item(&f12->data_reg_desc, 15);
425	if (item && !xport->attn_data) {
426	f12->data15 = item;
427	f12->data15_offset = data_offset;
428	data_offset += item->reg_size;
429	}
430
431	/* allocate the in-kernel tracking buffers */
432	sensor->tracking_pos = devm_kzalloc(&fn->dev,
433	sizeof(struct input_mt_pos) * sensor->nbr_fingers,
434	GFP_KERNEL);
435	sensor->tracking_slots = devm_kzalloc(&fn->dev,
436	sizeof(int) * sensor->nbr_fingers, GFP_KERNEL);
437	sensor->objs = devm_kzalloc(&fn->dev,
438	sizeof(struct rmi_2d_sensor_abs_object)
439	* sensor->nbr_fingers, GFP_KERNEL);
440	if (!sensor->tracking_pos \|\| !sensor->tracking_slots \|\| !sensor->objs)
441	return -ENOMEM;
442
443	ret = rmi_2d_sensor_configure_input(fn, sensor);
444	if (ret)
445	return ret;
446
447	return 0;
448	}
449
450	struct rmi_function_handler rmi_f12_handler = {
451	.driver = {
452	.name = "rmi4_f12",
453	},
454	.func = 0x12,
455	.probe = rmi_f12_probe,
456	.config = rmi_f12_config,
457	.attention = rmi_f12_attention,
458	};