[mirror_ubuntu-hirsute-kernel.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,
};

#define F12_DATA1_BYTES_PER_OBJ			8

struct f12_data {
	struct rmi_2d_sensor sensor;
	struct rmi_2d_sensor_platform_data sensor_pdata;
	bool has_dribble;

	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 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__,
		sensor->axis_align.clip_x_low, sensor->axis_align.clip_x_high,
		sensor->axis_align.clip_y_low, sensor->axis_align.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 size)
{
	int i;
	struct rmi_2d_sensor *sensor = &f12->sensor;
	int objects = f12->data1->num_subpackets;

	if ((f12->data1->num_subpackets * F12_DATA1_BYTES_PER_OBJ) > size)
		objects = size / F12_DATA1_BYTES_PER_OBJ;

	for (i = 0; i < objects; 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 += F12_DATA1_BYTES_PER_OBJ;
	}

	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 < objects; 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 rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
	struct f12_data *f12 = dev_get_drvdata(&fn->dev);
	struct rmi_2d_sensor *sensor = &f12->sensor;
	int valid_bytes = sensor->pkt_size;

	if (drvdata->attn_data.data) {
		if (sensor->attn_size > drvdata->attn_data.size)
			valid_bytes = drvdata->attn_data.size;
		else
			valid_bytes = sensor->attn_size;
		memcpy(sensor->data_pkt, drvdata->attn_data.data,
			valid_bytes);
		drvdata->attn_data.data += sensor->attn_size;
		drvdata->attn_data.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], valid_bytes);

	input_mt_sync_frame(sensor->input);

	return 0;
}

static int rmi_f12_write_control_regs(struct rmi_function *fn)
{
	int ret;
	const struct rmi_register_desc_item *item;
	struct rmi_device *rmi_dev = fn->rmi_dev;
	struct f12_data *f12 = dev_get_drvdata(&fn->dev);
	int control_size;
	char buf[3];
	u16 control_offset = 0;
	u8 subpacket_offset = 0;

	if (f12->has_dribble
	    && (f12->sensor.dribble != RMI_REG_STATE_DEFAULT)) {
		item = rmi_get_register_desc_item(&f12->control_reg_desc, 20);
		if (item) {
			control_offset = rmi_register_desc_calc_reg_offset(
						&f12->control_reg_desc, 20);

			/*
			 * The byte containing the EnableDribble bit will be
			 * in either byte 0 or byte 2 of control 20. Depending
			 * on the existence of subpacket 0. If control 20 is
			 * larger then 3 bytes, just read the first 3.
			 */
			control_size = min(item->reg_size, 3UL);

			ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr
					+ control_offset, buf, control_size);
			if (ret)
				return ret;

			if (rmi_register_desc_has_subpacket(item, 0))
				subpacket_offset += 1;

			switch (f12->sensor.dribble) {
			case RMI_REG_STATE_OFF:
				buf[subpacket_offset] &= ~BIT(2);
				break;
			case RMI_REG_STATE_ON:
				buf[subpacket_offset] |= BIT(2);
				break;
			case RMI_REG_STATE_DEFAULT:
			default:
				break;
			}

			ret = rmi_write_block(rmi_dev,
				fn->fd.control_base_addr + control_offset,
				buf, control_size);
			if (ret)
				return ret;
		}
	}

	return 0;

}

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

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

	ret = rmi_f12_write_control_regs(fn);
	if (ret)
		dev_warn(&fn->dev,
			"Failed to write F12 control registers: %d\n", ret);

	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_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
	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 & BIT(0))) {
		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;

	f12->has_dribble = !!(buf & BIT(3));

	if (fn->dev.of_node) {
		ret = rmi_2d_sensor_of_probe(&fn->dev, &f12->sensor_pdata);
		if (ret)
			return ret;
	} else {
		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;
	sensor->dribble = f12->sensor_pdata.dribble;

	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 && !drvdata->attn_data.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 && !drvdata->attn_data.data)
		data_offset += item->reg_size;

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

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 4);
	if (item && !drvdata->attn_data.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 && !drvdata->attn_data.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 && !drvdata->attn_data.data)
		data_offset += item->reg_size;

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

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 9);
	if (item && !drvdata->attn_data.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 && !drvdata->attn_data.data)
		data_offset += item->reg_size;

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

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

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

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

	item = rmi_get_register_desc_item(&f12->data_reg_desc, 15);
	if (item && !drvdata->attn_data.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
6d0dbeae AD	29	#define F12_DATA1_BYTES_PER_OBJ 8
6d0dbeae AD	30
b43d2c1e	31	struct f12_data {
b43d2c1e AD	32	struct rmi_2d_sensor sensor;
b43d2c1e AD	33	struct rmi_2d_sensor_platform_data sensor_pdata;
24f63b1c	34	bool has_dribble;
b43d2c1e AD	35
	36	u16 data_addr;
	37
	38	struct rmi_register_descriptor query_reg_desc;
	39	struct rmi_register_descriptor control_reg_desc;
	40	struct rmi_register_descriptor data_reg_desc;
	41
	42	/* F12 Data1 describes sensed objects */
	43	const struct rmi_register_desc_item *data1;
	44	u16 data1_offset;
	45
	46	/* F12 Data5 describes finger ACM */
	47	const struct rmi_register_desc_item *data5;
	48	u16 data5_offset;
	49
	50	/* F12 Data5 describes Pen */
	51	const struct rmi_register_desc_item *data6;
	52	u16 data6_offset;
	53
	54
	55	/* F12 Data9 reports relative data */
	56	const struct rmi_register_desc_item *data9;
	57	u16 data9_offset;
	58
	59	const struct rmi_register_desc_item *data15;
	60	u16 data15_offset;
	61	};
	62
	63	static int rmi_f12_read_sensor_tuning(struct f12_data *f12)
	64	{
	65	const struct rmi_register_desc_item *item;
	66	struct rmi_2d_sensor *sensor = &f12->sensor;
	67	struct rmi_function *fn = sensor->fn;
	68	struct rmi_device *rmi_dev = fn->rmi_dev;
	69	int ret;
	70	int offset;
e4add7b6	71	u8 buf[15];
b43d2c1e AD	72	int pitch_x = 0;
b43d2c1e AD	73	int pitch_y = 0;
b43d2c1e AD	74	int rx_receivers = 0;
	75	int tx_receivers = 0;
	76	int sensor_flags = 0;
	77
	78	item = rmi_get_register_desc_item(&f12->control_reg_desc, 8);
	79	if (!item) {
	80	dev_err(&fn->dev,
	81	"F12 does not have the sensor tuning control register\n");
	82	return -ENODEV;
	83	}
	84
	85	offset = rmi_register_desc_calc_reg_offset(&f12->control_reg_desc, 8);
	86
e4add7b6 AD	87	if (item->reg_size > sizeof(buf)) {
	88	dev_err(&fn->dev,
	89	"F12 control8 should be no bigger than %zd bytes, not: %ld\n",
	90	sizeof(buf), item->reg_size);
b43d2c1e AD	91	return -ENODEV;
	92	}
	93
	94	ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr + offset, buf,
	95	item->reg_size);
	96	if (ret)
	97	return ret;
	98
	99	offset = 0;
	100	if (rmi_register_desc_has_subpacket(item, 0)) {
	101	sensor->max_x = (buf[offset + 1] << 8) \| buf[offset];
	102	sensor->max_y = (buf[offset + 3] << 8) \| buf[offset + 2];
	103	offset += 4;
	104	}
	105
	106	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: max_x: %d max_y: %d\n", __func__,
	107	sensor->max_x, sensor->max_y);
	108
	109	if (rmi_register_desc_has_subpacket(item, 1)) {
	110	pitch_x = (buf[offset + 1] << 8) \| buf[offset];
	111	pitch_y = (buf[offset + 3] << 8) \| buf[offset + 2];
	112	offset += 4;
	113	}
	114
	115	if (rmi_register_desc_has_subpacket(item, 2)) {
	116	sensor->axis_align.clip_x_low = buf[offset];
	117	sensor->axis_align.clip_x_high = sensor->max_x
	118	- buf[offset + 1];
	119	sensor->axis_align.clip_y_low = buf[offset + 2];
	120	sensor->axis_align.clip_y_high = sensor->max_y
	121	- buf[offset + 3];
	122	offset += 4;
	123	}
	124
	125	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x low: %d x high: %d y low: %d y high: %d\n",
5d244f7e ND	126	__func__,
	127	sensor->axis_align.clip_x_low, sensor->axis_align.clip_x_high,
	128	sensor->axis_align.clip_y_low, sensor->axis_align.clip_y_high);
b43d2c1e AD	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
6d0dbeae	150	static void rmi_f12_process_objects(struct f12_data f12, u8 data1, int size)
b43d2c1e AD	151	{
	152	int i;
	153	struct rmi_2d_sensor *sensor = &f12->sensor;
6d0dbeae AD	154	int objects = f12->data1->num_subpackets;
	155
	156	if ((f12->data1->num_subpackets * F12_DATA1_BYTES_PER_OBJ) > size)
	157	objects = size / F12_DATA1_BYTES_PER_OBJ;
b43d2c1e	158
6d0dbeae	159	for (i = 0; i < objects; i++) {
b43d2c1e AD	160	struct rmi_2d_sensor_abs_object *obj = &sensor->objs[i];
	161
	162	obj->type = RMI_2D_OBJECT_NONE;
	163	obj->mt_tool = MT_TOOL_FINGER;
	164
	165	switch (data1[0]) {
	166	case RMI_F12_OBJECT_FINGER:
	167	obj->type = RMI_2D_OBJECT_FINGER;
	168	break;
	169	case RMI_F12_OBJECT_STYLUS:
	170	obj->type = RMI_2D_OBJECT_STYLUS;
	171	obj->mt_tool = MT_TOOL_PEN;
	172	break;
	173	case RMI_F12_OBJECT_PALM:
	174	obj->type = RMI_2D_OBJECT_PALM;
	175	obj->mt_tool = MT_TOOL_PALM;
	176	break;
	177	case RMI_F12_OBJECT_UNCLASSIFIED:
	178	obj->type = RMI_2D_OBJECT_UNCLASSIFIED;
	179	break;
	180	}
	181
	182	obj->x = (data1[2] << 8) \| data1[1];
	183	obj->y = (data1[4] << 8) \| data1[3];
	184	obj->z = data1[5];
	185	obj->wx = data1[6];
	186	obj->wy = data1[7];
	187
	188	rmi_2d_sensor_abs_process(sensor, obj, i);
	189
6d0dbeae	190	data1 += F12_DATA1_BYTES_PER_OBJ;
b43d2c1e AD	191	}
	192
	193	if (sensor->kernel_tracking)
	194	input_mt_assign_slots(sensor->input,
	195	sensor->tracking_slots,
	196	sensor->tracking_pos,
	197	sensor->nbr_fingers,
	198	sensor->dmax);
	199
6d0dbeae	200	for (i = 0; i < objects; i++)
b43d2c1e AD	201	rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
	202	}
	203
	204	static int rmi_f12_attention(struct rmi_function *fn,
	205	unsigned long *irq_nr_regs)
	206	{
	207	int retval;
	208	struct rmi_device *rmi_dev = fn->rmi_dev;
ae9979c3	209	struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
b43d2c1e AD	210	struct f12_data *f12 = dev_get_drvdata(&fn->dev);
b43d2c1e AD	211	struct rmi_2d_sensor *sensor = &f12->sensor;
6d0dbeae	212	int valid_bytes = sensor->pkt_size;
b43d2c1e	213
ae9979c3 BT	214	if (drvdata->attn_data.data) {
	215	if (sensor->attn_size > drvdata->attn_data.size)
	216	valid_bytes = drvdata->attn_data.size;
6d0dbeae AD	217	else
6d0dbeae AD	218	valid_bytes = sensor->attn_size;
ae9979c3	219	memcpy(sensor->data_pkt, drvdata->attn_data.data,
6d0dbeae	220	valid_bytes);
ae9979c3 BT	221	drvdata->attn_data.data += sensor->attn_size;
ae9979c3 BT	222	drvdata->attn_data.size -= sensor->attn_size;
b43d2c1e AD	223	} else {
	224	retval = rmi_read_block(rmi_dev, f12->data_addr,
	225	sensor->data_pkt, sensor->pkt_size);
	226	if (retval < 0) {
	227	dev_err(&fn->dev, "Failed to read object data. Code: %d.\n",
	228	retval);
	229	return retval;
	230	}
	231	}
	232
	233	if (f12->data1)
	234	rmi_f12_process_objects(f12,
6d0dbeae	235	&sensor->data_pkt[f12->data1_offset], valid_bytes);
b43d2c1e AD	236
	237	input_mt_sync_frame(sensor->input);
	238
	239	return 0;
	240	}
	241
24f63b1c AD	242	static int rmi_f12_write_control_regs(struct rmi_function *fn)
	243	{
	244	int ret;
	245	const struct rmi_register_desc_item *item;
	246	struct rmi_device *rmi_dev = fn->rmi_dev;
	247	struct f12_data *f12 = dev_get_drvdata(&fn->dev);
	248	int control_size;
	249	char buf[3];
	250	u16 control_offset = 0;
	251	u8 subpacket_offset = 0;
	252
	253	if (f12->has_dribble
	254	&& (f12->sensor.dribble != RMI_REG_STATE_DEFAULT)) {
	255	item = rmi_get_register_desc_item(&f12->control_reg_desc, 20);
	256	if (item) {
	257	control_offset = rmi_register_desc_calc_reg_offset(
	258	&f12->control_reg_desc, 20);
	259
	260	/*
	261	* The byte containing the EnableDribble bit will be
	262	* in either byte 0 or byte 2 of control 20. Depending
	263	* on the existence of subpacket 0. If control 20 is
	264	* larger then 3 bytes, just read the first 3.
	265	*/
	266	control_size = min(item->reg_size, 3UL);
	267
	268	ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr
	269	+ control_offset, buf, control_size);
	270	if (ret)
	271	return ret;
	272
	273	if (rmi_register_desc_has_subpacket(item, 0))
	274	subpacket_offset += 1;
	275
	276	switch (f12->sensor.dribble) {
	277	case RMI_REG_STATE_OFF:
	278	buf[subpacket_offset] &= ~BIT(2);
	279	break;
	280	case RMI_REG_STATE_ON:
	281	buf[subpacket_offset] \|= BIT(2);
	282	break;
	283	case RMI_REG_STATE_DEFAULT:
	284	default:
	285	break;
	286	}
	287
	288	ret = rmi_write_block(rmi_dev,
	289	fn->fd.control_base_addr + control_offset,
	290	buf, control_size);
	291	if (ret)
	292	return ret;
	293	}
	294	}
	295
	296	return 0;
	297
	298	}
	299
b43d2c1e AD	300	static int rmi_f12_config(struct rmi_function *fn)
	301	{
	302	struct rmi_driver *drv = fn->rmi_dev->driver;
24f63b1c	303	int ret;
b43d2c1e AD	304
	305	drv->set_irq_bits(fn->rmi_dev, fn->irq_mask);
	306
24f63b1c AD	307	ret = rmi_f12_write_control_regs(fn);
	308	if (ret)
	309	dev_warn(&fn->dev,
	310	"Failed to write F12 control registers: %d\n", ret);
	311
b43d2c1e AD	312	return 0;
	313	}
	314
	315	static int rmi_f12_probe(struct rmi_function *fn)
	316	{
	317	struct f12_data *f12;
	318	int ret;
	319	struct rmi_device *rmi_dev = fn->rmi_dev;
	320	char buf;
	321	u16 query_addr = fn->fd.query_base_addr;
	322	const struct rmi_register_desc_item *item;
	323	struct rmi_2d_sensor *sensor;
	324	struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
ae9979c3	325	struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
b43d2c1e AD	326	u16 data_offset = 0;
	327
	328	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s\n", __func__);
	329
	330	ret = rmi_read(fn->rmi_dev, query_addr, &buf);
	331	if (ret < 0) {
	332	dev_err(&fn->dev, "Failed to read general info register: %d\n",
	333	ret);
	334	return -ENODEV;
	335	}
	336	++query_addr;
	337
24f63b1c	338	if (!(buf & BIT(0))) {
b43d2c1e AD	339	dev_err(&fn->dev,
	340	"Behavior of F12 without register descriptors is undefined.\n");
	341	return -ENODEV;
	342	}
	343
	344	f12 = devm_kzalloc(&fn->dev, sizeof(struct f12_data), GFP_KERNEL);
	345	if (!f12)
	346	return -ENOMEM;
	347
24f63b1c AD	348	f12->has_dribble = !!(buf & BIT(3));
24f63b1c AD	349
b43d2c1e AD	350	if (fn->dev.of_node) {
	351	ret = rmi_2d_sensor_of_probe(&fn->dev, &f12->sensor_pdata);
	352	if (ret)
	353	return ret;
0a135b88 BT	354	} else {
0a135b88 BT	355	f12->sensor_pdata = pdata->sensor_pdata;
b43d2c1e AD	356	}
	357
	358	ret = rmi_read_register_desc(rmi_dev, query_addr,
	359	&f12->query_reg_desc);
	360	if (ret) {
	361	dev_err(&fn->dev,
	362	"Failed to read the Query Register Descriptor: %d\n",
	363	ret);
	364	return ret;
	365	}
	366	query_addr += 3;
	367
	368	ret = rmi_read_register_desc(rmi_dev, query_addr,
	369	&f12->control_reg_desc);
	370	if (ret) {
	371	dev_err(&fn->dev,
	372	"Failed to read the Control Register Descriptor: %d\n",
	373	ret);
	374	return ret;
	375	}
	376	query_addr += 3;
	377
	378	ret = rmi_read_register_desc(rmi_dev, query_addr,
	379	&f12->data_reg_desc);
	380	if (ret) {
	381	dev_err(&fn->dev,
	382	"Failed to read the Data Register Descriptor: %d\n",
	383	ret);
	384	return ret;
	385	}
	386	query_addr += 3;
	387
	388	sensor = &f12->sensor;
	389	sensor->fn = fn;
	390	f12->data_addr = fn->fd.data_base_addr;
	391	sensor->pkt_size = rmi_register_desc_calc_size(&f12->data_reg_desc);
	392
	393	sensor->axis_align =
	394	f12->sensor_pdata.axis_align;
	395
	396	sensor->x_mm = f12->sensor_pdata.x_mm;
	397	sensor->y_mm = f12->sensor_pdata.y_mm;
24f63b1c	398	sensor->dribble = f12->sensor_pdata.dribble;
b43d2c1e AD	399
	400	if (sensor->sensor_type == rmi_sensor_default)
	401	sensor->sensor_type =
	402	f12->sensor_pdata.sensor_type;
	403
	404	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: data packet size: %d\n", __func__,
	405	sensor->pkt_size);
	406	sensor->data_pkt = devm_kzalloc(&fn->dev, sensor->pkt_size, GFP_KERNEL);
	407	if (!sensor->data_pkt)
	408	return -ENOMEM;
	409
	410	dev_set_drvdata(&fn->dev, f12);
	411
	412	ret = rmi_f12_read_sensor_tuning(f12);
	413	if (ret)
	414	return ret;
	415
	416	/*
	417	* Figure out what data is contained in the data registers. HID devices
	418	* may have registers defined, but their data is not reported in the
	419	* HID attention report. Registers which are not reported in the HID
	420	* attention report check to see if the device is receiving data from
	421	* HID attention reports.
	422	*/
	423	item = rmi_get_register_desc_item(&f12->data_reg_desc, 0);
ae9979c3	424	if (item && !drvdata->attn_data.data)
b43d2c1e AD	425	data_offset += item->reg_size;
	426
	427	item = rmi_get_register_desc_item(&f12->data_reg_desc, 1);
	428	if (item) {
	429	f12->data1 = item;
	430	f12->data1_offset = data_offset;
	431	data_offset += item->reg_size;
	432	sensor->nbr_fingers = item->num_subpackets;
	433	sensor->report_abs = 1;
	434	sensor->attn_size += item->reg_size;
	435	}
	436
	437	item = rmi_get_register_desc_item(&f12->data_reg_desc, 2);
ae9979c3	438	if (item && !drvdata->attn_data.data)
b43d2c1e AD	439	data_offset += item->reg_size;
	440
	441	item = rmi_get_register_desc_item(&f12->data_reg_desc, 3);
ae9979c3	442	if (item && !drvdata->attn_data.data)
b43d2c1e AD	443	data_offset += item->reg_size;
	444
	445	item = rmi_get_register_desc_item(&f12->data_reg_desc, 4);
ae9979c3	446	if (item && !drvdata->attn_data.data)
b43d2c1e AD	447	data_offset += item->reg_size;
	448
	449	item = rmi_get_register_desc_item(&f12->data_reg_desc, 5);
	450	if (item) {
	451	f12->data5 = item;
	452	f12->data5_offset = data_offset;
	453	data_offset += item->reg_size;
	454	sensor->attn_size += item->reg_size;
	455	}
	456
	457	item = rmi_get_register_desc_item(&f12->data_reg_desc, 6);
ae9979c3	458	if (item && !drvdata->attn_data.data) {
b43d2c1e AD	459	f12->data6 = item;
	460	f12->data6_offset = data_offset;
	461	data_offset += item->reg_size;
	462	}
	463
	464	item = rmi_get_register_desc_item(&f12->data_reg_desc, 7);
ae9979c3	465	if (item && !drvdata->attn_data.data)
b43d2c1e AD	466	data_offset += item->reg_size;
	467
	468	item = rmi_get_register_desc_item(&f12->data_reg_desc, 8);
ae9979c3	469	if (item && !drvdata->attn_data.data)
b43d2c1e AD	470	data_offset += item->reg_size;
	471
	472	item = rmi_get_register_desc_item(&f12->data_reg_desc, 9);
ae9979c3	473	if (item && !drvdata->attn_data.data) {
b43d2c1e AD	474	f12->data9 = item;
	475	f12->data9_offset = data_offset;
	476	data_offset += item->reg_size;
	477	if (!sensor->report_abs)
	478	sensor->report_rel = 1;
	479	}
	480
	481	item = rmi_get_register_desc_item(&f12->data_reg_desc, 10);
ae9979c3	482	if (item && !drvdata->attn_data.data)
b43d2c1e AD	483	data_offset += item->reg_size;
	484
	485	item = rmi_get_register_desc_item(&f12->data_reg_desc, 11);
ae9979c3	486	if (item && !drvdata->attn_data.data)
b43d2c1e AD	487	data_offset += item->reg_size;
	488
	489	item = rmi_get_register_desc_item(&f12->data_reg_desc, 12);
ae9979c3	490	if (item && !drvdata->attn_data.data)
b43d2c1e AD	491	data_offset += item->reg_size;
	492
	493	item = rmi_get_register_desc_item(&f12->data_reg_desc, 13);
ae9979c3	494	if (item && !drvdata->attn_data.data)
b43d2c1e AD	495	data_offset += item->reg_size;
	496
	497	item = rmi_get_register_desc_item(&f12->data_reg_desc, 14);
ae9979c3	498	if (item && !drvdata->attn_data.data)
b43d2c1e AD	499	data_offset += item->reg_size;
	500
	501	item = rmi_get_register_desc_item(&f12->data_reg_desc, 15);
ae9979c3	502	if (item && !drvdata->attn_data.data) {
b43d2c1e AD	503	f12->data15 = item;
	504	f12->data15_offset = data_offset;
	505	data_offset += item->reg_size;
	506	}
	507
	508	/* allocate the in-kernel tracking buffers */
	509	sensor->tracking_pos = devm_kzalloc(&fn->dev,
	510	sizeof(struct input_mt_pos) * sensor->nbr_fingers,
	511	GFP_KERNEL);
	512	sensor->tracking_slots = devm_kzalloc(&fn->dev,
	513	sizeof(int) * sensor->nbr_fingers, GFP_KERNEL);
	514	sensor->objs = devm_kzalloc(&fn->dev,
	515	sizeof(struct rmi_2d_sensor_abs_object)
	516	* sensor->nbr_fingers, GFP_KERNEL);
	517	if (!sensor->tracking_pos \|\| !sensor->tracking_slots \|\| !sensor->objs)
	518	return -ENOMEM;
	519
	520	ret = rmi_2d_sensor_configure_input(fn, sensor);
	521	if (ret)
	522	return ret;
	523
	524	return 0;
	525	}
	526
	527	struct rmi_function_handler rmi_f12_handler = {
	528	.driver = {
	529	.name = "rmi4_f12",
	530	},
	531	.func = 0x12,
	532	.probe = rmi_f12_probe,
	533	.config = rmi_f12_config,
	534	.attention = rmi_f12_attention,
	535	};