rmi_f30.c 10.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * 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
19 20 21 22 23 24
#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)
25 26 27 28 29 30

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

/* Defs for Control Registers */
#define RMI_F30_CTRL_1_GPIO_DEBOUNCE		0x01
31 32
#define RMI_F30_CTRL_1_HALT			BIT(4)
#define RMI_F30_CTRL_1_HALTED			BIT(5)
33 34 35
#define RMI_F30_CTRL_10_NUM_MECH_MOUSE_BTNS	0x03

#define RMI_F30_CTRL_MAX_REGS		32
36
#define RMI_F30_CTRL_MAX_BYTES		DIV_ROUND_UP(RMI_F30_CTRL_MAX_REGS, 8)
37 38 39 40 41 42 43 44 45 46 47 48 49 50
#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)

51 52 53
#define TRACKSTICK_RANGE_START		3
#define TRACKSTICK_RANGE_END		6

54 55 56 57 58 59
struct rmi_f30_ctrl_data {
	int address;
	int length;
	u8 *regs;
};

60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
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;
82 83 84

	struct rmi_function *f03;
	bool trackstick_buttons;
85 86 87 88 89
};

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

92 93
	error = rmi_read_block(fn->rmi_dev, fn->fd.control_base_addr,
			       f30->ctrl_regs, f30->ctrl_regs_size);
94
	if (error) {
95 96
		dev_err(&fn->dev,
			"%s: Could not read control registers at 0x%x: %d\n",
97 98 99 100 101 102 103
			__func__, fn->fd.control_base_addr, error);
		return error;
	}

	return 0;
}

104 105 106 107 108
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;
109
	u16 key_code = f30->gpioled_key_map[button];
110 111
	bool key_down = !(f30->data_regs[reg_num] & BIT(bit_num));

112 113 114 115 116 117 118 119
	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);
120

121 122
		input_report_key(f30->input, key_code, key_down);
	}
123 124
}

125
static irqreturn_t rmi_f30_attention(int irq, void *ctx)
126
{
127
	struct rmi_function *fn = ctx;
128
	struct f30_data *f30 = dev_get_drvdata(&fn->dev);
129 130
	struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev);
	int error;
131 132 133
	int i;

	/* Read the gpi led data. */
134 135
	if (drvdata->attn_data.data) {
		if (drvdata->attn_data.size < f30->register_count) {
136 137
			dev_warn(&fn->dev,
				 "F30 interrupted, but data is missing\n");
138
			return IRQ_HANDLED;
139
		}
140
		memcpy(f30->data_regs, drvdata->attn_data.data,
141
			f30->register_count);
142 143
		drvdata->attn_data.data += f30->register_count;
		drvdata->attn_data.size -= f30->register_count;
144
	} else {
145 146 147 148 149 150
		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);
151
			return IRQ_RETVAL(error);
152 153 154
		}
	}

155
	if (f30->has_gpio) {
156 157 158
		for (i = 0; i < f30->gpioled_count; i++)
			if (f30->gpioled_key_map[i] != KEY_RESERVED)
				rmi_f30_report_button(fn, f30, i);
159 160 161
		if (f30->trackstick_buttons)
			rmi_f03_commit_buttons(f30->f03);
	}
162

163
	return IRQ_HANDLED;
164 165 166 167 168 169 170 171 172 173
}

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;

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

178 179 180 181 182 183
	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;
	}

184
	if (pdata->f30_data.disable) {
185 186 187 188 189 190
		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) {
191 192
			dev_err(&fn->dev,
				"%s: Could not write control registers at 0x%x: %d\n",
193 194 195 196 197 198
				__func__, fn->fd.control_base_addr, error);
			return error;
		}

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

200 201 202
	return 0;
}

203 204
static void rmi_f30_set_ctrl_data(struct rmi_f30_ctrl_data *ctrl,
				  int *ctrl_addr, int len, u8 **reg)
205 206 207 208 209 210 211 212
{
	ctrl->address = *ctrl_addr;
	ctrl->length = len;
	ctrl->regs = *reg;
	*ctrl_addr += len;
	*reg += len;
}

213
static bool rmi_f30_is_valid_button(int button, struct rmi_f30_ctrl_data *ctrl)
214 215 216 217 218 219 220 221 222 223 224 225
{
	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));
}

226 227
static int rmi_f30_map_gpios(struct rmi_function *fn,
			     struct f30_data *f30)
228
{
229 230 231 232
	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;
233 234
	unsigned int trackstick_button = BTN_LEFT;
	bool button_mapped = false;
235
	int i;
236
	int button_count = min_t(u8, f30->gpioled_count, TRACKSTICK_RANGE_END);
237

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

247
	for (i = 0; i < button_count; i++) {
248 249 250 251 252 253 254
		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) {
255 256
			f30->gpioled_key_map[i] = button;
			input_set_capability(input, EV_KEY, button++);
257
			button_mapped = true;
258 259 260 261 262 263 264
		}
	}

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

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

273 274
	return 0;
}
275

276 277 278 279 280 281
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;
282

283 284 285 286 287
	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;
288 289 290 291 292 293 294 295 296 297 298
	}

	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;

299
	f30->register_count = DIV_ROUND_UP(f30->gpioled_count, 8);
300 301 302

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

305 306
	rmi_f30_set_ctrl_data(&f30->ctrl[1], &control_address,
			      sizeof(u8), &ctrl_reg);
307 308 309

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

		rmi_f30_set_ctrl_data(&f30->ctrl[3], &control_address,
313
				      f30->register_count, &ctrl_reg);
314 315 316 317
	}

	if (f30->has_led) {
		rmi_f30_set_ctrl_data(&f30->ctrl[4], &control_address,
318
				      f30->register_count, &ctrl_reg);
319 320

		rmi_f30_set_ctrl_data(&f30->ctrl[5], &control_address,
321 322
				      f30->has_extended_pattern ? 6 : 2,
				      &ctrl_reg);
323 324 325 326 327
	}

	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,
328
				      f30->gpioled_count, &ctrl_reg);
329 330 331 332 333
	}

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

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

		rmi_f30_set_ctrl_data(&f30->ctrl[9], &control_address,
342
				      sizeof(u8), &ctrl_reg);
343 344 345 346
	}

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

349 350
	f30->ctrl_regs_size = ctrl_reg -
				f30->ctrl_regs ?: RMI_F30_CTRL_REGS_MAX_SIZE;
351

352 353
	error = rmi_f30_read_control_parameters(fn, f30);
	if (error) {
354
		dev_err(&fn->dev,
355 356 357
			"Failed to initialize F30 control params: %d\n",
			error);
		return error;
358 359
	}

360
	if (f30->has_gpio) {
361 362 363
		error = rmi_f30_map_gpios(fn, f30);
		if (error)
			return error;
364 365 366 367 368 369 370
	}

	return 0;
}

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

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

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

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

390
	f30->input = drv_data->input;
391

392 393 394
	error = rmi_f30_initialize(fn, f30);
	if (error)
		return error;
395

396 397
	dev_set_drvdata(&fn->dev, f30);
	return 0;
398 399 400 401 402 403 404 405 406 407 408
}

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,
};