[linux-2.6-block.git] / drivers / input / rmi4 / rmi_f30.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/kernel.h>
#include <linux/rmi.h>
#include <linux/input.h>
#include <linux/slab.h>
#include "rmi_driver.h"

#define RMI_F30_QUERY_SIZE			2

/* Defs for Query 0 */
#define RMI_F30_EXTENDED_PATTERNS		0x01
#define RMI_F30_HAS_MAPPABLE_BUTTONS		(1 << 1)
#define RMI_F30_HAS_LED			(1 << 2)
#define RMI_F30_HAS_GPIO			(1 << 3)
#define RMI_F30_HAS_HAPTIC			(1 << 4)
#define RMI_F30_HAS_GPIO_DRV_CTL		(1 << 5)
#define RMI_F30_HAS_MECH_MOUSE_BTNS		(1 << 6)

/* Defs for Query 1 */
#define RMI_F30_GPIO_LED_COUNT			0x1F

/* Defs for Control Registers */
#define RMI_F30_CTRL_1_GPIO_DEBOUNCE		0x01
#define RMI_F30_CTRL_1_HALT			(1 << 4)
#define RMI_F30_CTRL_1_HALTED			(1 << 5)
#define RMI_F30_CTRL_10_NUM_MECH_MOUSE_BTNS	0x03

struct rmi_f30_ctrl_data {
	int address;
	int length;
	u8 *regs;
};

#define RMI_F30_CTRL_MAX_REGS		32
#define RMI_F30_CTRL_MAX_BYTES		((RMI_F30_CTRL_MAX_REGS + 7) >> 3)
#define RMI_F30_CTRL_MAX_REG_BLOCKS	11

#define RMI_F30_CTRL_REGS_MAX_SIZE (RMI_F30_CTRL_MAX_BYTES		\
					+ 1				\
					+ RMI_F30_CTRL_MAX_BYTES	\
					+ RMI_F30_CTRL_MAX_BYTES	\
					+ RMI_F30_CTRL_MAX_BYTES	\
					+ 6				\
					+ RMI_F30_CTRL_MAX_REGS		\
					+ RMI_F30_CTRL_MAX_REGS		\
					+ RMI_F30_CTRL_MAX_BYTES	\
					+ 1				\
					+ 1)

struct f30_data {
	/* Query Data */
	bool has_extended_pattern;
	bool has_mappable_buttons;
	bool has_led;
	bool has_gpio;
	bool has_haptic;
	bool has_gpio_driver_control;
	bool has_mech_mouse_btns;
	u8 gpioled_count;

	u8 register_count;

	/* Control Register Data */
	struct rmi_f30_ctrl_data ctrl[RMI_F30_CTRL_MAX_REG_BLOCKS];
	u8 ctrl_regs[RMI_F30_CTRL_REGS_MAX_SIZE];
	u32 ctrl_regs_size;

	u8 data_regs[RMI_F30_CTRL_MAX_BYTES];
	u16 *gpioled_key_map;

	struct input_dev *input;
};

static int rmi_f30_read_control_parameters(struct rmi_function *fn,
						struct f30_data *f30)
{
	struct rmi_device *rmi_dev = fn->rmi_dev;
	int error = 0;

	error = rmi_read_block(rmi_dev, fn->fd.control_base_addr,
				f30->ctrl_regs, f30->ctrl_regs_size);
	if (error) {
		dev_err(&rmi_dev->dev, "%s : Could not read control registers at 0x%x error (%d)\n",
			__func__, fn->fd.control_base_addr, error);
		return error;
	}

	return 0;
}

static int rmi_f30_attention(struct rmi_function *fn, unsigned long *irq_bits)
{
	struct f30_data *f30 = dev_get_drvdata(&fn->dev);
	struct rmi_device *rmi_dev = fn->rmi_dev;
	struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
	int retval;
	int gpiled = 0;
	int value = 0;
	int i;
	int reg_num;

	if (!f30->input)
		return 0;

	/* Read the gpi led data. */
	if (drvdata->attn_data.data) {
		if (drvdata->attn_data.size < f30->register_count) {
			dev_warn(&fn->dev, "F30 interrupted, but data is missing\n");
			return 0;
		}
		memcpy(f30->data_regs, drvdata->attn_data.data,
			f30->register_count);
		drvdata->attn_data.data += f30->register_count;
		drvdata->attn_data.size -= f30->register_count;
	} else {
		retval = rmi_read_block(rmi_dev, fn->fd.data_base_addr,
			f30->data_regs, f30->register_count);

		if (retval) {
			dev_err(&fn->dev, "%s: Failed to read F30 data registers.\n",
				__func__);
			return retval;
		}
	}

	for (reg_num = 0; reg_num < f30->register_count; ++reg_num) {
		for (i = 0; gpiled < f30->gpioled_count && i < 8; ++i,
			++gpiled) {
			if (f30->gpioled_key_map[gpiled] != 0) {
				/* buttons have pull up resistors */
				value = (((f30->data_regs[reg_num] >> i) & 0x01)
									== 0);

				rmi_dbg(RMI_DEBUG_FN, &fn->dev,
					"%s: call input report key (0x%04x) value (0x%02x)",
					__func__,
					f30->gpioled_key_map[gpiled], value);
				input_report_key(f30->input,
						 f30->gpioled_key_map[gpiled],
						 value);
			}

		}
	}

	return 0;
}

static int rmi_f30_register_device(struct rmi_function *fn)
{
	int i;
	struct rmi_device *rmi_dev = fn->rmi_dev;
	struct rmi_driver_data *drv_data = dev_get_drvdata(&rmi_dev->dev);
	struct f30_data *f30 = dev_get_drvdata(&fn->dev);
	struct input_dev *input_dev;
	int button_count = 0;

	input_dev = drv_data->input;
	if (!input_dev) {
		dev_info(&fn->dev, "F30: no input device found, ignoring.\n");
		return -EINVAL;
	}

	f30->input = input_dev;

	set_bit(EV_KEY, input_dev->evbit);

	input_dev->keycode = f30->gpioled_key_map;
	input_dev->keycodesize = sizeof(u16);
	input_dev->keycodemax = f30->gpioled_count;

	for (i = 0; i < f30->gpioled_count; i++) {
		if (f30->gpioled_key_map[i] != 0) {
			input_set_capability(input_dev, EV_KEY,
						f30->gpioled_key_map[i]);
			button_count++;
		}
	}

	if (button_count == 1)
		__set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
	return 0;
}

static int rmi_f30_config(struct rmi_function *fn)
{
	struct f30_data *f30 = dev_get_drvdata(&fn->dev);
	struct rmi_driver *drv = fn->rmi_dev->driver;
	const struct rmi_device_platform_data *pdata =
				rmi_get_platform_data(fn->rmi_dev);
	int error;

	if (pdata->f30_data.disable) {
		drv->clear_irq_bits(fn->rmi_dev, fn->irq_mask);
	} else {
		/* Write Control Register values back to device */
		error = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
					f30->ctrl_regs, f30->ctrl_regs_size);
		if (error) {
			dev_err(&fn->rmi_dev->dev,
				"%s : Could not write control registers at 0x%x error (%d)\n",
				__func__, fn->fd.control_base_addr, error);
			return error;
		}

		drv->set_irq_bits(fn->rmi_dev, fn->irq_mask);
	}
	return 0;
}

static inline void rmi_f30_set_ctrl_data(struct rmi_f30_ctrl_data *ctrl,
					int *ctrl_addr, int len, u8 **reg)
{
	ctrl->address = *ctrl_addr;
	ctrl->length = len;
	ctrl->regs = *reg;
	*ctrl_addr += len;
	*reg += len;
}

static inline bool rmi_f30_is_valid_button(int button,
		struct rmi_f30_ctrl_data *ctrl)
{
	int byte_position = button >> 3;
	int bit_position = button & 0x07;

	/*
	 * ctrl2 -> dir == 0 -> input mode
	 * ctrl3 -> data == 1 -> actual button
	 */
	return !(ctrl[2].regs[byte_position] & BIT(bit_position)) &&
		(ctrl[3].regs[byte_position] & BIT(bit_position));
}

static inline int rmi_f30_initialize(struct rmi_function *fn)
{
	struct f30_data *f30;
	struct rmi_device *rmi_dev = fn->rmi_dev;
	const struct rmi_device_platform_data *pdata;
	int retval = 0;
	int control_address;
	int i;
	int button;
	u8 buf[RMI_F30_QUERY_SIZE];
	u8 *ctrl_reg;
	u8 *map_memory;

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

	dev_set_drvdata(&fn->dev, f30);

	retval = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr, buf,
				RMI_F30_QUERY_SIZE);

	if (retval) {
		dev_err(&fn->dev, "Failed to read query register.\n");
		return retval;
	}

	f30->has_extended_pattern = buf[0] & RMI_F30_EXTENDED_PATTERNS;
	f30->has_mappable_buttons = buf[0] & RMI_F30_HAS_MAPPABLE_BUTTONS;
	f30->has_led = buf[0] & RMI_F30_HAS_LED;
	f30->has_gpio = buf[0] & RMI_F30_HAS_GPIO;
	f30->has_haptic = buf[0] & RMI_F30_HAS_HAPTIC;
	f30->has_gpio_driver_control = buf[0] & RMI_F30_HAS_GPIO_DRV_CTL;
	f30->has_mech_mouse_btns = buf[0] & RMI_F30_HAS_MECH_MOUSE_BTNS;
	f30->gpioled_count = buf[1] & RMI_F30_GPIO_LED_COUNT;

	f30->register_count = (f30->gpioled_count + 7) >> 3;

	control_address = fn->fd.control_base_addr;
	ctrl_reg = f30->ctrl_regs;

	if (f30->has_gpio && f30->has_led)
		rmi_f30_set_ctrl_data(&f30->ctrl[0], &control_address,
					f30->register_count, &ctrl_reg);

	rmi_f30_set_ctrl_data(&f30->ctrl[1], &control_address, sizeof(u8),
				&ctrl_reg);

	if (f30->has_gpio) {
		rmi_f30_set_ctrl_data(&f30->ctrl[2], &control_address,
					f30->register_count, &ctrl_reg);

		rmi_f30_set_ctrl_data(&f30->ctrl[3], &control_address,
					f30->register_count, &ctrl_reg);
	}

	if (f30->has_led) {
		int ctrl5_len;

		rmi_f30_set_ctrl_data(&f30->ctrl[4], &control_address,
					f30->register_count, &ctrl_reg);

		if (f30->has_extended_pattern)
			ctrl5_len = 6;
		else
			ctrl5_len = 2;

		rmi_f30_set_ctrl_data(&f30->ctrl[5], &control_address,
					ctrl5_len, &ctrl_reg);
	}

	if (f30->has_led || f30->has_gpio_driver_control) {
		/* control 6 uses a byte per gpio/led */
		rmi_f30_set_ctrl_data(&f30->ctrl[6], &control_address,
					f30->gpioled_count, &ctrl_reg);
	}

	if (f30->has_mappable_buttons) {
		/* control 7 uses a byte per gpio/led */
		rmi_f30_set_ctrl_data(&f30->ctrl[7], &control_address,
					f30->gpioled_count, &ctrl_reg);
	}

	if (f30->has_haptic) {
		rmi_f30_set_ctrl_data(&f30->ctrl[8], &control_address,
					f30->register_count, &ctrl_reg);

		rmi_f30_set_ctrl_data(&f30->ctrl[9], &control_address,
					sizeof(u8), &ctrl_reg);
	}

	if (f30->has_mech_mouse_btns)
		rmi_f30_set_ctrl_data(&f30->ctrl[10], &control_address,
					sizeof(u8), &ctrl_reg);

	f30->ctrl_regs_size = ctrl_reg - f30->ctrl_regs
				?: RMI_F30_CTRL_REGS_MAX_SIZE;

	retval = rmi_f30_read_control_parameters(fn, f30);
	if (retval < 0) {
		dev_err(&fn->dev,
			"Failed to initialize F19 control params.\n");
		return retval;
	}

	map_memory = devm_kzalloc(&fn->dev,
				  (f30->gpioled_count * (sizeof(u16))),
				  GFP_KERNEL);
	if (!map_memory) {
		dev_err(&fn->dev, "Failed to allocate gpioled map memory.\n");
		return -ENOMEM;
	}

	f30->gpioled_key_map = (u16 *)map_memory;

	pdata = rmi_get_platform_data(rmi_dev);
	if (f30->has_gpio) {
		button = BTN_LEFT;
		for (i = 0; i < f30->gpioled_count; i++) {
			if (rmi_f30_is_valid_button(i, f30->ctrl)) {
				f30->gpioled_key_map[i] = button++;

				/*
				 * buttonpad might be given by
				 * f30->has_mech_mouse_btns, but I am
				 * not sure, so use only the pdata info
				 */
				if (pdata->f30_data.buttonpad)
					break;
			}
		}
	}

	return 0;
}

static int rmi_f30_probe(struct rmi_function *fn)
{
	int rc;
	const struct rmi_device_platform_data *pdata =
				rmi_get_platform_data(fn->rmi_dev);

	if (pdata->f30_data.disable)
		return 0;

	rc = rmi_f30_initialize(fn);
	if (rc < 0)
		goto error_exit;

	rc = rmi_f30_register_device(fn);
	if (rc < 0)
		goto error_exit;

	return 0;

error_exit:
	return rc;

}

struct rmi_function_handler rmi_f30_handler = {
	.driver = {
		.name = "rmi4_f30",
	},
	.func = 0x30,
	.probe = rmi_f30_probe,
	.config = rmi_f30_config,
	.attention = rmi_f30_attention,
};
Commit	Line	Data
562b42d3 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
	9	#include <linux/kernel.h>
	10	#include <linux/rmi.h>
	11	#include <linux/input.h>
	12	#include <linux/slab.h>
	13	#include "rmi_driver.h"
	14
	15	#define RMI_F30_QUERY_SIZE 2
	16
	17	/* Defs for Query 0 */
	18	#define RMI_F30_EXTENDED_PATTERNS 0x01
	19	#define RMI_F30_HAS_MAPPABLE_BUTTONS (1 << 1)
	20	#define RMI_F30_HAS_LED (1 << 2)
	21	#define RMI_F30_HAS_GPIO (1 << 3)
	22	#define RMI_F30_HAS_HAPTIC (1 << 4)
	23	#define RMI_F30_HAS_GPIO_DRV_CTL (1 << 5)
	24	#define RMI_F30_HAS_MECH_MOUSE_BTNS (1 << 6)
	25
	26	/* Defs for Query 1 */
	27	#define RMI_F30_GPIO_LED_COUNT 0x1F
	28
	29	/* Defs for Control Registers */
	30	#define RMI_F30_CTRL_1_GPIO_DEBOUNCE 0x01
	31	#define RMI_F30_CTRL_1_HALT (1 << 4)
	32	#define RMI_F30_CTRL_1_HALTED (1 << 5)
	33	#define RMI_F30_CTRL_10_NUM_MECH_MOUSE_BTNS 0x03
	34
	35	struct rmi_f30_ctrl_data {
	36	int address;
	37	int length;
	38	u8 *regs;
	39	};
	40
	41	#define RMI_F30_CTRL_MAX_REGS 32
	42	#define RMI_F30_CTRL_MAX_BYTES ((RMI_F30_CTRL_MAX_REGS + 7) >> 3)
	43	#define RMI_F30_CTRL_MAX_REG_BLOCKS 11
	44
	45	#define RMI_F30_CTRL_REGS_MAX_SIZE (RMI_F30_CTRL_MAX_BYTES \
	46	+ 1 \
	47	+ RMI_F30_CTRL_MAX_BYTES \
	48	+ RMI_F30_CTRL_MAX_BYTES \
	49	+ RMI_F30_CTRL_MAX_BYTES \
	50	+ 6 \
	51	+ RMI_F30_CTRL_MAX_REGS \
	52	+ RMI_F30_CTRL_MAX_REGS \
	53	+ RMI_F30_CTRL_MAX_BYTES \
	54	+ 1 \
	55	+ 1)
	56
	57	struct f30_data {
	58	/* Query Data */
	59	bool has_extended_pattern;
	60	bool has_mappable_buttons;
	61	bool has_led;
	62	bool has_gpio;
	63	bool has_haptic;
	64	bool has_gpio_driver_control;
65	bool has_mech_mouse_btns;
66	u8 gpioled_count;
67
68	u8 register_count;
69
70	/* Control Register Data */
71	struct rmi_f30_ctrl_data ctrl[RMI_F30_CTRL_MAX_REG_BLOCKS];
72	u8 ctrl_regs[RMI_F30_CTRL_REGS_MAX_SIZE];
73	u32 ctrl_regs_size;
74
75	u8 data_regs[RMI_F30_CTRL_MAX_BYTES];
76	u16 *gpioled_key_map;
77
78	struct input_dev *input;
79	};
80
81	static int rmi_f30_read_control_parameters(struct rmi_function *fn,
82	struct f30_data *f30)
83	{
84	struct rmi_device *rmi_dev = fn->rmi_dev;
85	int error = 0;
86
87	error = rmi_read_block(rmi_dev, fn->fd.control_base_addr,
88	f30->ctrl_regs, f30->ctrl_regs_size);
89	if (error) {
90	dev_err(&rmi_dev->dev, "%s : Could not read control registers at 0x%x error (%d)\n",
91	__func__, fn->fd.control_base_addr, error);
92	return error;
93	}
94
95	return 0;
96	}
97
98	static int rmi_f30_attention(struct rmi_function fn, unsigned long irq_bits)
99	{
100	struct f30_data *f30 = dev_get_drvdata(&fn->dev);
101	struct rmi_device *rmi_dev = fn->rmi_dev;
ae9979c3	102	struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
562b42d3 AD	103	int retval;
	104	int gpiled = 0;
	105	int value = 0;
	106	int i;
	107	int reg_num;
	108
	109	if (!f30->input)
	110	return 0;
	111
	112	/* Read the gpi led data. */
ae9979c3 BT	113	if (drvdata->attn_data.data) {
ae9979c3 BT	114	if (drvdata->attn_data.size < f30->register_count) {
6d0dbeae AD	115	dev_warn(&fn->dev, "F30 interrupted, but data is missing\n");
	116	return 0;
	117	}
ae9979c3	118	memcpy(f30->data_regs, drvdata->attn_data.data,
562b42d3	119	f30->register_count);
ae9979c3 BT	120	drvdata->attn_data.data += f30->register_count;
ae9979c3 BT	121	drvdata->attn_data.size -= f30->register_count;
562b42d3 AD	122	} else {
	123	retval = rmi_read_block(rmi_dev, fn->fd.data_base_addr,
	124	f30->data_regs, f30->register_count);
	125
	126	if (retval) {
	127	dev_err(&fn->dev, "%s: Failed to read F30 data registers.\n",
	128	__func__);
	129	return retval;
	130	}
	131	}
	132
	133	for (reg_num = 0; reg_num < f30->register_count; ++reg_num) {
	134	for (i = 0; gpiled < f30->gpioled_count && i < 8; ++i,
	135	++gpiled) {
	136	if (f30->gpioled_key_map[gpiled] != 0) {
	137	/* buttons have pull up resistors */
	138	value = (((f30->data_regs[reg_num] >> i) & 0x01)
	139	== 0);
	140
	141	rmi_dbg(RMI_DEBUG_FN, &fn->dev,
	142	"%s: call input report key (0x%04x) value (0x%02x)",
	143	__func__,
	144	f30->gpioled_key_map[gpiled], value);
	145	input_report_key(f30->input,
	146	f30->gpioled_key_map[gpiled],
	147	value);
	148	}
	149
	150	}
	151	}
	152
	153	return 0;
	154	}
	155
	156	static int rmi_f30_register_device(struct rmi_function *fn)
	157	{
	158	int i;
	159	struct rmi_device *rmi_dev = fn->rmi_dev;
	160	struct rmi_driver_data *drv_data = dev_get_drvdata(&rmi_dev->dev);
	161	struct f30_data *f30 = dev_get_drvdata(&fn->dev);
	162	struct input_dev *input_dev;
	163	int button_count = 0;
	164
	165	input_dev = drv_data->input;
	166	if (!input_dev) {
	167	dev_info(&fn->dev, "F30: no input device found, ignoring.\n");
	168	return -EINVAL;
	169	}
	170
	171	f30->input = input_dev;
	172
	173	set_bit(EV_KEY, input_dev->evbit);
	174
	175	input_dev->keycode = f30->gpioled_key_map;
	176	input_dev->keycodesize = sizeof(u16);
	177	input_dev->keycodemax = f30->gpioled_count;
	178
	179	for (i = 0; i < f30->gpioled_count; i++) {
	180	if (f30->gpioled_key_map[i] != 0) {
	181	input_set_capability(input_dev, EV_KEY,
	182	f30->gpioled_key_map[i]);
	183	button_count++;
	184	}
	185	}
186
187	if (button_count == 1)
188	__set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
189	return 0;
190	}
191
192	static int rmi_f30_config(struct rmi_function *fn)
193	{
194	struct f30_data *f30 = dev_get_drvdata(&fn->dev);
195	struct rmi_driver *drv = fn->rmi_dev->driver;
196	const struct rmi_device_platform_data *pdata =
197	rmi_get_platform_data(fn->rmi_dev);
198	int error;
199
0a135b88	200	if (pdata->f30_data.disable) {
562b42d3 AD	201	drv->clear_irq_bits(fn->rmi_dev, fn->irq_mask);
	202	} else {
	203	/* Write Control Register values back to device */
	204	error = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
	205	f30->ctrl_regs, f30->ctrl_regs_size);
	206	if (error) {
	207	dev_err(&fn->rmi_dev->dev,
	208	"%s : Could not write control registers at 0x%x error (%d)\n",
	209	__func__, fn->fd.control_base_addr, error);
	210	return error;
	211	}
	212
	213	drv->set_irq_bits(fn->rmi_dev, fn->irq_mask);
	214	}
	215	return 0;
	216	}
	217
	218	static inline void rmi_f30_set_ctrl_data(struct rmi_f30_ctrl_data *ctrl,
	219	int ctrl_addr, int len, u8 *reg)
	220	{
	221	ctrl->address = *ctrl_addr;
	222	ctrl->length = len;
	223	ctrl->regs = *reg;
	224	*ctrl_addr += len;
	225	*reg += len;
	226	}
	227
	228	static inline bool rmi_f30_is_valid_button(int button,
	229	struct rmi_f30_ctrl_data *ctrl)
	230	{
	231	int byte_position = button >> 3;
	232	int bit_position = button & 0x07;
	233
	234	/*
	235	* ctrl2 -> dir == 0 -> input mode
	236	* ctrl3 -> data == 1 -> actual button
	237	*/
	238	return !(ctrl[2].regs[byte_position] & BIT(bit_position)) &&
	239	(ctrl[3].regs[byte_position] & BIT(bit_position));
	240	}
	241
	242	static inline int rmi_f30_initialize(struct rmi_function *fn)
	243	{
	244	struct f30_data *f30;
	245	struct rmi_device *rmi_dev = fn->rmi_dev;
	246	const struct rmi_device_platform_data *pdata;
	247	int retval = 0;
	248	int control_address;
	249	int i;
	250	int button;
	251	u8 buf[RMI_F30_QUERY_SIZE];
	252	u8 *ctrl_reg;
	253	u8 *map_memory;
	254
	255	f30 = devm_kzalloc(&fn->dev, sizeof(struct f30_data),
	256	GFP_KERNEL);
	257	if (!f30)
	258	return -ENOMEM;
	259
	260	dev_set_drvdata(&fn->dev, f30);
	261
	262	retval = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr, buf,
	263	RMI_F30_QUERY_SIZE);
	264
265	if (retval) {
266	dev_err(&fn->dev, "Failed to read query register.\n");
267	return retval;
268	}
269
270	f30->has_extended_pattern = buf[0] & RMI_F30_EXTENDED_PATTERNS;
271	f30->has_mappable_buttons = buf[0] & RMI_F30_HAS_MAPPABLE_BUTTONS;
272	f30->has_led = buf[0] & RMI_F30_HAS_LED;
273	f30->has_gpio = buf[0] & RMI_F30_HAS_GPIO;
274	f30->has_haptic = buf[0] & RMI_F30_HAS_HAPTIC;
275	f30->has_gpio_driver_control = buf[0] & RMI_F30_HAS_GPIO_DRV_CTL;
276	f30->has_mech_mouse_btns = buf[0] & RMI_F30_HAS_MECH_MOUSE_BTNS;
277	f30->gpioled_count = buf[1] & RMI_F30_GPIO_LED_COUNT;
278
279	f30->register_count = (f30->gpioled_count + 7) >> 3;
280
281	control_address = fn->fd.control_base_addr;
282	ctrl_reg = f30->ctrl_regs;
283
284	if (f30->has_gpio && f30->has_led)
285	rmi_f30_set_ctrl_data(&f30->ctrl[0], &control_address,
286	f30->register_count, &ctrl_reg);
287
288	rmi_f30_set_ctrl_data(&f30->ctrl[1], &control_address, sizeof(u8),
289	&ctrl_reg);
290
291	if (f30->has_gpio) {
292	rmi_f30_set_ctrl_data(&f30->ctrl[2], &control_address,
293	f30->register_count, &ctrl_reg);
294
295	rmi_f30_set_ctrl_data(&f30->ctrl[3], &control_address,
296	f30->register_count, &ctrl_reg);
297	}
298
299	if (f30->has_led) {
300	int ctrl5_len;
301
302	rmi_f30_set_ctrl_data(&f30->ctrl[4], &control_address,
303	f30->register_count, &ctrl_reg);
304
305	if (f30->has_extended_pattern)
306	ctrl5_len = 6;
307	else
308	ctrl5_len = 2;
309
310	rmi_f30_set_ctrl_data(&f30->ctrl[5], &control_address,
311	ctrl5_len, &ctrl_reg);
312	}
313
314	if (f30->has_led \|\| f30->has_gpio_driver_control) {
315	/* control 6 uses a byte per gpio/led */
316	rmi_f30_set_ctrl_data(&f30->ctrl[6], &control_address,
317	f30->gpioled_count, &ctrl_reg);
318	}
319
320	if (f30->has_mappable_buttons) {
321	/* control 7 uses a byte per gpio/led */
322	rmi_f30_set_ctrl_data(&f30->ctrl[7], &control_address,
323	f30->gpioled_count, &ctrl_reg);
324	}
325
326	if (f30->has_haptic) {
327	rmi_f30_set_ctrl_data(&f30->ctrl[8], &control_address,
328	f30->register_count, &ctrl_reg);
329
330	rmi_f30_set_ctrl_data(&f30->ctrl[9], &control_address,
331	sizeof(u8), &ctrl_reg);
332	}
333
334	if (f30->has_mech_mouse_btns)
335	rmi_f30_set_ctrl_data(&f30->ctrl[10], &control_address,
336	sizeof(u8), &ctrl_reg);
337
338	f30->ctrl_regs_size = ctrl_reg - f30->ctrl_regs
339	?: RMI_F30_CTRL_REGS_MAX_SIZE;
340
341	retval = rmi_f30_read_control_parameters(fn, f30);
342	if (retval < 0) {
343	dev_err(&fn->dev,
344	"Failed to initialize F19 control params.\n");
345	return retval;
346	}
347
348	map_memory = devm_kzalloc(&fn->dev,
349	(f30->gpioled_count * (sizeof(u16))),
350	GFP_KERNEL);
351	if (!map_memory) {
352	dev_err(&fn->dev, "Failed to allocate gpioled map memory.\n");
353	return -ENOMEM;
354	}
355
356	f30->gpioled_key_map = (u16 *)map_memory;
357
358	pdata = rmi_get_platform_data(rmi_dev);
0a135b88	359	if (f30->has_gpio) {
562b42d3 AD	360	button = BTN_LEFT;
	361	for (i = 0; i < f30->gpioled_count; i++) {
	362	if (rmi_f30_is_valid_button(i, f30->ctrl)) {
	363	f30->gpioled_key_map[i] = button++;
	364
	365	/*
	366	* buttonpad might be given by
	367	* f30->has_mech_mouse_btns, but I am
	368	* not sure, so use only the pdata info
	369	*/
0a135b88	370	if (pdata->f30_data.buttonpad)
562b42d3 AD	371	break;
	372	}
	373	}
	374	}
	375
	376	return 0;
	377	}
	378
	379	static int rmi_f30_probe(struct rmi_function *fn)
	380	{
	381	int rc;
	382	const struct rmi_device_platform_data *pdata =
	383	rmi_get_platform_data(fn->rmi_dev);
	384
0a135b88	385	if (pdata->f30_data.disable)
562b42d3 AD	386	return 0;
	387
	388	rc = rmi_f30_initialize(fn);
	389	if (rc < 0)
	390	goto error_exit;
	391
	392	rc = rmi_f30_register_device(fn);
	393	if (rc < 0)
	394	goto error_exit;
	395
	396	return 0;
	397
	398	error_exit:
	399	return rc;
	400
	401	}
	402
	403	struct rmi_function_handler rmi_f30_handler = {
	404	.driver = {
	405	.name = "rmi4_f30",
	406	},
	407	.func = 0x30,
	408	.probe = rmi_f30_probe,
	409	.config = rmi_f30_config,
	410	.attention = rmi_f30_attention,
	411	};