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

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2012-2016 Synaptics Incorporated
 */

#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		BIT(1)
#define RMI_F30_HAS_LED				BIT(2)
#define RMI_F30_HAS_GPIO			BIT(3)
#define RMI_F30_HAS_HAPTIC			BIT(4)
#define RMI_F30_HAS_GPIO_DRV_CTL		BIT(5)
#define RMI_F30_HAS_MECH_MOUSE_BTNS		BIT(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			BIT(4)
#define RMI_F30_CTRL_1_HALTED			BIT(5)
#define RMI_F30_CTRL_10_NUM_MECH_MOUSE_BTNS	0x03

#define RMI_F30_CTRL_MAX_REGS		32
#define RMI_F30_CTRL_MAX_BYTES		DIV_ROUND_UP(RMI_F30_CTRL_MAX_REGS, 8)
#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)

#define TRACKSTICK_RANGE_START		3
#define TRACKSTICK_RANGE_END		6

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

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;

	struct rmi_function *f03;
	bool trackstick_buttons;
};

static int rmi_f30_read_control_parameters(struct rmi_function *fn,
						struct f30_data *f30)
{
	int error;

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

	return 0;
}

static void rmi_f30_report_button(struct rmi_function *fn,
				  struct f30_data *f30, unsigned int button)
{
	unsigned int reg_num = button >> 3;
	unsigned int bit_num = button & 0x07;
	u16 key_code = f30->gpioled_key_map[button];
	bool key_down = !(f30->data_regs[reg_num] & BIT(bit_num));

	if (f30->trackstick_buttons &&
	    button >= TRACKSTICK_RANGE_START &&
	    button <= TRACKSTICK_RANGE_END) {
		rmi_f03_overwrite_button(f30->f03, key_code, key_down);
	} else {
		rmi_dbg(RMI_DEBUG_FN, &fn->dev,
			"%s: call input report key (0x%04x) value (0x%02x)",
			__func__, key_code, key_down);

		input_report_key(f30->input, key_code, key_down);
	}
}

static irqreturn_t rmi_f30_attention(int irq, void *ctx)
{
	struct rmi_function *fn = ctx;
	struct f30_data *f30 = dev_get_drvdata(&fn->dev);
	struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev);
	int error;
	int i;

	/* 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 IRQ_HANDLED;
		}
		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 {
		error = rmi_read_block(fn->rmi_dev, fn->fd.data_base_addr,
				       f30->data_regs, f30->register_count);
		if (error) {
			dev_err(&fn->dev,
				"%s: Failed to read F30 data registers: %d\n",
				__func__, error);
			return IRQ_RETVAL(error);
		}
	}

	if (f30->has_gpio) {
		for (i = 0; i < f30->gpioled_count; i++)
			if (f30->gpioled_key_map[i] != KEY_RESERVED)
				rmi_f30_report_button(fn, f30, i);
		if (f30->trackstick_buttons)
			rmi_f03_commit_buttons(f30->f03);
	}

	return IRQ_HANDLED;
}

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;

	/* can happen if f30_data.disable is set */
	if (!f30)
		return 0;

	if (pdata->f30_data.trackstick_buttons) {
		/* Try [re-]establish link to F03. */
		f30->f03 = rmi_find_function(fn->rmi_dev, 0x03);
		f30->trackstick_buttons = f30->f03 != NULL;
	}

	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->dev,
				"%s: Could not write control registers at 0x%x: %d\n",
				__func__, fn->fd.control_base_addr, error);
			return error;
		}

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

	return 0;
}

static 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 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 int rmi_f30_map_gpios(struct rmi_function *fn,
			     struct f30_data *f30)
{
	const struct rmi_device_platform_data *pdata =
					rmi_get_platform_data(fn->rmi_dev);
	struct input_dev *input = f30->input;
	unsigned int button = BTN_LEFT;
	unsigned int trackstick_button = BTN_LEFT;
	bool button_mapped = false;
	int i;
	int button_count = min_t(u8, f30->gpioled_count, TRACKSTICK_RANGE_END);

	f30->gpioled_key_map = devm_kcalloc(&fn->dev,
					    button_count,
					    sizeof(f30->gpioled_key_map[0]),
					    GFP_KERNEL);
	if (!f30->gpioled_key_map) {
		dev_err(&fn->dev, "Failed to allocate gpioled map memory.\n");
		return -ENOMEM;
	}

	for (i = 0; i < button_count; i++) {
		if (!rmi_f30_is_valid_button(i, f30->ctrl))
			continue;

		if (pdata->f30_data.trackstick_buttons &&
		    i >= TRACKSTICK_RANGE_START && i < TRACKSTICK_RANGE_END) {
			f30->gpioled_key_map[i] = trackstick_button++;
		} else if (!pdata->f30_data.buttonpad || !button_mapped) {
			f30->gpioled_key_map[i] = button;
			input_set_capability(input, EV_KEY, button++);
			button_mapped = true;
		}
	}

	input->keycode = f30->gpioled_key_map;
	input->keycodesize = sizeof(f30->gpioled_key_map[0]);
	input->keycodemax = f30->gpioled_count;

	/*
	 * Buttonpad could be also inferred from f30->has_mech_mouse_btns,
	 * but I am not sure, so use only the pdata info and the number of
	 * mapped buttons.
	 */
	if (pdata->f30_data.buttonpad || (button - BTN_LEFT == 1))
		__set_bit(INPUT_PROP_BUTTONPAD, input->propbit);

	return 0;
}

static int rmi_f30_initialize(struct rmi_function *fn, struct f30_data *f30)
{
	u8 *ctrl_reg = f30->ctrl_regs;
	int control_address = fn->fd.control_base_addr;
	u8 buf[RMI_F30_QUERY_SIZE];
	int error;

	error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr,
			       buf, RMI_F30_QUERY_SIZE);
	if (error) {
		dev_err(&fn->dev, "Failed to read query register\n");
		return error;
	}

	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 = DIV_ROUND_UP(f30->gpioled_count, 8);

	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) {
		rmi_f30_set_ctrl_data(&f30->ctrl[4], &control_address,
				      f30->register_count, &ctrl_reg);

		rmi_f30_set_ctrl_data(&f30->ctrl[5], &control_address,
				      f30->has_extended_pattern ? 6 : 2,
				      &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;

	error = rmi_f30_read_control_parameters(fn, f30);
	if (error) {
		dev_err(&fn->dev,
			"Failed to initialize F30 control params: %d\n",
			error);
		return error;
	}

	if (f30->has_gpio) {
		error = rmi_f30_map_gpios(fn, f30);
		if (error)
			return error;
	}

	return 0;
}

static int rmi_f30_probe(struct rmi_function *fn)
{
	struct rmi_device *rmi_dev = fn->rmi_dev;
	const struct rmi_device_platform_data *pdata =
					rmi_get_platform_data(rmi_dev);
	struct rmi_driver_data *drv_data = dev_get_drvdata(&rmi_dev->dev);
	struct f30_data *f30;
	int error;

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

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

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

	f30->input = drv_data->input;

	error = rmi_f30_initialize(fn, f30);
	if (error)
		return error;

	dev_set_drvdata(&fn->dev, f30);
	return 0;
}

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