[thirdparty/kernel/stable.git] / drivers / input / rmi4 / rmi_f03.c

/*
 * Copyright (C) 2015-2016 Red Hat
 * Copyright (C) 2015 Lyude Paul <thatslyude@gmail.com>
 *
 * 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/slab.h>
#include <linux/serio.h>
#include <linux/notifier.h>
#include "rmi_driver.h"

#define RMI_F03_RX_DATA_OFB		0x01
#define RMI_F03_OB_SIZE			2

#define RMI_F03_OB_OFFSET		2
#define RMI_F03_OB_DATA_OFFSET		1
#define RMI_F03_OB_FLAG_TIMEOUT		BIT(6)
#define RMI_F03_OB_FLAG_PARITY		BIT(7)

#define RMI_F03_DEVICE_COUNT		0x07
#define RMI_F03_BYTES_PER_DEVICE	0x07
#define RMI_F03_BYTES_PER_DEVICE_SHIFT	4
#define RMI_F03_QUEUE_LENGTH		0x0F

#define PSMOUSE_OOB_EXTRA_BTNS		0x01

struct f03_data {
	struct rmi_function *fn;

	struct serio *serio;
	bool serio_registered;

	unsigned int overwrite_buttons;

	u8 device_count;
	u8 rx_queue_length;
};

int rmi_f03_overwrite_button(struct rmi_function *fn, unsigned int button,
			     int value)
{
	struct f03_data *f03 = dev_get_drvdata(&fn->dev);
	unsigned int bit;

	if (button < BTN_LEFT || button > BTN_MIDDLE)
		return -EINVAL;

	bit = BIT(button - BTN_LEFT);

	if (value)
		f03->overwrite_buttons |= bit;
	else
		f03->overwrite_buttons &= ~bit;

	return 0;
}

void rmi_f03_commit_buttons(struct rmi_function *fn)
{
	struct f03_data *f03 = dev_get_drvdata(&fn->dev);
	struct serio *serio = f03->serio;

	serio_pause_rx(serio);
	if (serio->drv) {
		serio->drv->interrupt(serio, PSMOUSE_OOB_EXTRA_BTNS,
				      SERIO_OOB_DATA);
		serio->drv->interrupt(serio, f03->overwrite_buttons,
				      SERIO_OOB_DATA);
	}
	serio_continue_rx(serio);
}

static int rmi_f03_pt_write(struct serio *id, unsigned char val)
{
	struct f03_data *f03 = id->port_data;
	int error;

	rmi_dbg(RMI_DEBUG_FN, &f03->fn->dev,
		"%s: Wrote %.2hhx to PS/2 passthrough address",
		__func__, val);

	error = rmi_write(f03->fn->rmi_dev, f03->fn->fd.data_base_addr, val);
	if (error) {
		dev_err(&f03->fn->dev,
			"%s: Failed to write to F03 TX register (%d).\n",
			__func__, error);
		return error;
	}

	return 0;
}

static int rmi_f03_initialize(struct f03_data *f03)
{
	struct rmi_function *fn = f03->fn;
	struct device *dev = &fn->dev;
	int error;
	u8 bytes_per_device;
	u8 query1;
	u8 query2[RMI_F03_DEVICE_COUNT * RMI_F03_BYTES_PER_DEVICE];
	size_t query2_len;

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

	f03->device_count = query1 & RMI_F03_DEVICE_COUNT;
	bytes_per_device = (query1 >> RMI_F03_BYTES_PER_DEVICE_SHIFT) &
				RMI_F03_BYTES_PER_DEVICE;

	query2_len = f03->device_count * bytes_per_device;

	/*
	 * The first generation of image sensors don't have a second part to
	 * their f03 query, as such we have to set some of these values manually
	 */
	if (query2_len < 1) {
		f03->device_count = 1;
		f03->rx_queue_length = 7;
	} else {
		error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr + 1,
				       query2, query2_len);
		if (error) {
			dev_err(dev,
				"Failed to read second set of query registers (%d).\n",
				error);
			return error;
		}

		f03->rx_queue_length = query2[0] & RMI_F03_QUEUE_LENGTH;
	}

	return 0;
}

static int rmi_f03_pt_open(struct serio *serio)
{
	struct f03_data *f03 = serio->port_data;
	struct rmi_function *fn = f03->fn;
	const u8 ob_len = f03->rx_queue_length * RMI_F03_OB_SIZE;
	const u16 data_addr = fn->fd.data_base_addr + RMI_F03_OB_OFFSET;
	u8 obs[RMI_F03_QUEUE_LENGTH * RMI_F03_OB_SIZE];
	int error;

	/*
	 * Consume any pending data. Some devices like to spam with
	 * 0xaa 0x00 announcements which may confuse us as we try to
	 * probe the device.
	 */
	error = rmi_read_block(fn->rmi_dev, data_addr, &obs, ob_len);
	if (!error)
		rmi_dbg(RMI_DEBUG_FN, &fn->dev,
			"%s: Consumed %*ph (%d) from PS2 guest\n",
			__func__, ob_len, obs, ob_len);

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

static void rmi_f03_pt_close(struct serio *serio)
{
	struct f03_data *f03 = serio->port_data;
	struct rmi_function *fn = f03->fn;

	fn->rmi_dev->driver->clear_irq_bits(fn->rmi_dev, fn->irq_mask);
}

static int rmi_f03_register_pt(struct f03_data *f03)
{
	struct serio *serio;

	serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
	if (!serio)
		return -ENOMEM;

	serio->id.type = SERIO_PS_PSTHRU;
	serio->write = rmi_f03_pt_write;
	serio->open = rmi_f03_pt_open;
	serio->close = rmi_f03_pt_close;
	serio->port_data = f03;

	strlcpy(serio->name, "RMI4 PS/2 pass-through", sizeof(serio->name));
	snprintf(serio->phys, sizeof(serio->phys), "%s/serio0",
		 dev_name(&f03->fn->dev));
	serio->dev.parent = &f03->fn->dev;

	f03->serio = serio;

	printk(KERN_INFO "serio: %s port at %s\n",
		serio->name, dev_name(&f03->fn->dev));
	serio_register_port(serio);

	return 0;
}

static int rmi_f03_probe(struct rmi_function *fn)
{
	struct device *dev = &fn->dev;
	struct f03_data *f03;
	int error;

	f03 = devm_kzalloc(dev, sizeof(struct f03_data), GFP_KERNEL);
	if (!f03)
		return -ENOMEM;

	f03->fn = fn;

	error = rmi_f03_initialize(f03);
	if (error < 0)
		return error;

	if (f03->device_count != 1)
		dev_warn(dev, "found %d devices on PS/2 passthrough",
			 f03->device_count);

	dev_set_drvdata(dev, f03);
	return 0;
}

static int rmi_f03_config(struct rmi_function *fn)
{
	struct f03_data *f03 = dev_get_drvdata(&fn->dev);
	int error;

	if (!f03->serio_registered) {
		error = rmi_f03_register_pt(f03);
		if (error)
			return error;

		f03->serio_registered = true;
	} else {
		/*
		 * We must be re-configuring the sensor, just enable
		 * interrupts for this function.
		 */
		fn->rmi_dev->driver->set_irq_bits(fn->rmi_dev, fn->irq_mask);
	}

	return 0;
}

static irqreturn_t rmi_f03_attention(int irq, void *ctx)
{
	struct rmi_function *fn = ctx;
	struct rmi_device *rmi_dev = fn->rmi_dev;
	struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
	struct f03_data *f03 = dev_get_drvdata(&fn->dev);
	const u16 data_addr = fn->fd.data_base_addr + RMI_F03_OB_OFFSET;
	const u8 ob_len = f03->rx_queue_length * RMI_F03_OB_SIZE;
	u8 obs[RMI_F03_QUEUE_LENGTH * RMI_F03_OB_SIZE];
	u8 ob_status;
	u8 ob_data;
	unsigned int serio_flags;
	int i;
	int error;

	if (drvdata->attn_data.data) {
		/* First grab the data passed by the transport device */
		if (drvdata->attn_data.size < ob_len) {
			dev_warn(&fn->dev, "F03 interrupted, but data is missing!\n");
			return IRQ_HANDLED;
		}

		memcpy(obs, drvdata->attn_data.data, ob_len);

		drvdata->attn_data.data += ob_len;
		drvdata->attn_data.size -= ob_len;
	} else {
		/* Grab all of the data registers, and check them for data */
		error = rmi_read_block(fn->rmi_dev, data_addr, &obs, ob_len);
		if (error) {
			dev_err(&fn->dev,
				"%s: Failed to read F03 output buffers: %d\n",
				__func__, error);
			serio_interrupt(f03->serio, 0, SERIO_TIMEOUT);
			return IRQ_RETVAL(error);
		}
	}

	for (i = 0; i < ob_len; i += RMI_F03_OB_SIZE) {
		ob_status = obs[i];
		ob_data = obs[i + RMI_F03_OB_DATA_OFFSET];
		serio_flags = 0;

		if (!(ob_status & RMI_F03_RX_DATA_OFB))
			continue;

		if (ob_status & RMI_F03_OB_FLAG_TIMEOUT)
			serio_flags |= SERIO_TIMEOUT;
		if (ob_status & RMI_F03_OB_FLAG_PARITY)
			serio_flags |= SERIO_PARITY;

		rmi_dbg(RMI_DEBUG_FN, &fn->dev,
			"%s: Received %.2hhx from PS2 guest T: %c P: %c\n",
			__func__, ob_data,
			serio_flags & SERIO_TIMEOUT ?  'Y' : 'N',
			serio_flags & SERIO_PARITY ? 'Y' : 'N');

		serio_interrupt(f03->serio, ob_data, serio_flags);
	}

	return IRQ_HANDLED;
}

static void rmi_f03_remove(struct rmi_function *fn)
{
	struct f03_data *f03 = dev_get_drvdata(&fn->dev);

	if (f03->serio_registered)
		serio_unregister_port(f03->serio);
}

struct rmi_function_handler rmi_f03_handler = {
	.driver = {
		.name = "rmi4_f03",
	},
	.func = 0x03,
	.probe = rmi_f03_probe,
	.config = rmi_f03_config,
	.attention = rmi_f03_attention,
	.remove = rmi_f03_remove,
};

MODULE_AUTHOR("Lyude Paul <thatslyude@gmail.com>");
MODULE_DESCRIPTION("RMI F03 module");
MODULE_LICENSE("GPL");
Commit	Line	Data
c5e8848f LP	1	/*
	2	* Copyright (C) 2015-2016 Red Hat
	3	* Copyright (C) 2015 Lyude Paul <thatslyude@gmail.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 as published by
	7	* the Free Software Foundation.
	8	*/
	9
	10	#include <linux/kernel.h>
	11	#include <linux/slab.h>
	12	#include <linux/serio.h>
	13	#include <linux/notifier.h>
	14	#include "rmi_driver.h"
	15
	16	#define RMI_F03_RX_DATA_OFB 0x01
	17	#define RMI_F03_OB_SIZE 2
	18
	19	#define RMI_F03_OB_OFFSET 2
	20	#define RMI_F03_OB_DATA_OFFSET 1
	21	#define RMI_F03_OB_FLAG_TIMEOUT BIT(6)
	22	#define RMI_F03_OB_FLAG_PARITY BIT(7)
	23
	24	#define RMI_F03_DEVICE_COUNT 0x07
	25	#define RMI_F03_BYTES_PER_DEVICE 0x07
	26	#define RMI_F03_BYTES_PER_DEVICE_SHIFT 4
	27	#define RMI_F03_QUEUE_LENGTH 0x0F
	28
81dec809 BT	29	#define PSMOUSE_OOB_EXTRA_BTNS 0x01
81dec809 BT	30
c5e8848f LP	31	struct f03_data {
	32	struct rmi_function *fn;
	33
	34	struct serio *serio;
6abe534f	35	bool serio_registered;
c5e8848f	36
81dec809 BT	37	unsigned int overwrite_buttons;
81dec809 BT	38
c5e8848f LP	39	u8 device_count;
	40	u8 rx_queue_length;
	41	};
	42
81dec809 BT	43	int rmi_f03_overwrite_button(struct rmi_function *fn, unsigned int button,
	44	int value)
	45	{
	46	struct f03_data *f03 = dev_get_drvdata(&fn->dev);
	47	unsigned int bit;
	48
	49	if (button < BTN_LEFT \|\| button > BTN_MIDDLE)
	50	return -EINVAL;
	51
	52	bit = BIT(button - BTN_LEFT);
	53
	54	if (value)
	55	f03->overwrite_buttons \|= bit;
	56	else
	57	f03->overwrite_buttons &= ~bit;
	58
	59	return 0;
	60	}
	61
	62	void rmi_f03_commit_buttons(struct rmi_function *fn)
	63	{
	64	struct f03_data *f03 = dev_get_drvdata(&fn->dev);
	65	struct serio *serio = f03->serio;
	66
	67	serio_pause_rx(serio);
	68	if (serio->drv) {
	69	serio->drv->interrupt(serio, PSMOUSE_OOB_EXTRA_BTNS,
	70	SERIO_OOB_DATA);
	71	serio->drv->interrupt(serio, f03->overwrite_buttons,
	72	SERIO_OOB_DATA);
	73	}
	74	serio_continue_rx(serio);
	75	}
	76
c5e8848f LP	77	static int rmi_f03_pt_write(struct serio *id, unsigned char val)
	78	{
	79	struct f03_data *f03 = id->port_data;
	80	int error;
	81
	82	rmi_dbg(RMI_DEBUG_FN, &f03->fn->dev,
	83	"%s: Wrote %.2hhx to PS/2 passthrough address",
	84	__func__, val);
	85
	86	error = rmi_write(f03->fn->rmi_dev, f03->fn->fd.data_base_addr, val);
	87	if (error) {
	88	dev_err(&f03->fn->dev,
	89	"%s: Failed to write to F03 TX register (%d).\n",
	90	__func__, error);
	91	return error;
	92	}
	93
	94	return 0;
	95	}
	96
	97	static int rmi_f03_initialize(struct f03_data *f03)
	98	{
	99	struct rmi_function *fn = f03->fn;
	100	struct device *dev = &fn->dev;
	101	int error;
	102	u8 bytes_per_device;
	103	u8 query1;
	104	u8 query2[RMI_F03_DEVICE_COUNT * RMI_F03_BYTES_PER_DEVICE];
	105	size_t query2_len;
	106
	107	error = rmi_read(fn->rmi_dev, fn->fd.query_base_addr, &query1);
	108	if (error) {
	109	dev_err(dev, "Failed to read query register (%d).\n", error);
	110	return error;
	111	}
	112
	113	f03->device_count = query1 & RMI_F03_DEVICE_COUNT;
	114	bytes_per_device = (query1 >> RMI_F03_BYTES_PER_DEVICE_SHIFT) &
	115	RMI_F03_BYTES_PER_DEVICE;
	116
	117	query2_len = f03->device_count * bytes_per_device;
	118
	119	/*
	120	* The first generation of image sensors don't have a second part to
	121	* their f03 query, as such we have to set some of these values manually
	122	*/
	123	if (query2_len < 1) {
	124	f03->device_count = 1;
	125	f03->rx_queue_length = 7;
	126	} else {
	127	error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr + 1,
	128	query2, query2_len);
	129	if (error) {
	130	dev_err(dev,
	131	"Failed to read second set of query registers (%d).\n",
	132	error);
	133	return error;
	134	}
	135
	136	f03->rx_queue_length = query2[0] & RMI_F03_QUEUE_LENGTH;
	137	}
	138
	139	return 0;
	140	}
141
6abe534f DT	142	static int rmi_f03_pt_open(struct serio *serio)
	143	{
	144	struct f03_data *f03 = serio->port_data;
	145	struct rmi_function *fn = f03->fn;
	146	const u8 ob_len = f03->rx_queue_length * RMI_F03_OB_SIZE;
	147	const u16 data_addr = fn->fd.data_base_addr + RMI_F03_OB_OFFSET;
	148	u8 obs[RMI_F03_QUEUE_LENGTH * RMI_F03_OB_SIZE];
	149	int error;
	150
	151	/*
	152	* Consume any pending data. Some devices like to spam with
	153	* 0xaa 0x00 announcements which may confuse us as we try to
	154	* probe the device.
	155	*/
	156	error = rmi_read_block(fn->rmi_dev, data_addr, &obs, ob_len);
	157	if (!error)
	158	rmi_dbg(RMI_DEBUG_FN, &fn->dev,
	159	"%s: Consumed %*ph (%d) from PS2 guest\n",
	160	__func__, ob_len, obs, ob_len);
	161
	162	return fn->rmi_dev->driver->set_irq_bits(fn->rmi_dev, fn->irq_mask);
	163	}
	164
	165	static void rmi_f03_pt_close(struct serio *serio)
	166	{
	167	struct f03_data *f03 = serio->port_data;
	168	struct rmi_function *fn = f03->fn;
	169
	170	fn->rmi_dev->driver->clear_irq_bits(fn->rmi_dev, fn->irq_mask);
	171	}
	172
c5e8848f LP	173	static int rmi_f03_register_pt(struct f03_data *f03)
	174	{
	175	struct serio *serio;
	176
	177	serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
	178	if (!serio)
	179	return -ENOMEM;
	180
a0897d5f	181	serio->id.type = SERIO_PS_PSTHRU;
c5e8848f	182	serio->write = rmi_f03_pt_write;
6abe534f DT	183	serio->open = rmi_f03_pt_open;
6abe534f DT	184	serio->close = rmi_f03_pt_close;
c5e8848f LP	185	serio->port_data = f03;
c5e8848f LP	186
9f87b9fc DT	187	strlcpy(serio->name, "RMI4 PS/2 pass-through", sizeof(serio->name));
	188	snprintf(serio->phys, sizeof(serio->phys), "%s/serio0",
	189	dev_name(&f03->fn->dev));
c5e8848f LP	190	serio->dev.parent = &f03->fn->dev;
	191
	192	f03->serio = serio;
	193
9f87b9fc DT	194	printk(KERN_INFO "serio: %s port at %s\n",
9f87b9fc DT	195	serio->name, dev_name(&f03->fn->dev));
c5e8848f LP	196	serio_register_port(serio);
	197
	198	return 0;
	199	}
	200
	201	static int rmi_f03_probe(struct rmi_function *fn)
	202	{
	203	struct device *dev = &fn->dev;
	204	struct f03_data *f03;
	205	int error;
	206
	207	f03 = devm_kzalloc(dev, sizeof(struct f03_data), GFP_KERNEL);
	208	if (!f03)
	209	return -ENOMEM;
	210
	211	f03->fn = fn;
	212
	213	error = rmi_f03_initialize(f03);
	214	if (error < 0)
	215	return error;
	216
	217	if (f03->device_count != 1)
	218	dev_warn(dev, "found %d devices on PS/2 passthrough",
	219	f03->device_count);
	220
	221	dev_set_drvdata(dev, f03);
c5e8848f LP	222	return 0;
	223	}
	224
	225	static int rmi_f03_config(struct rmi_function *fn)
	226	{
6abe534f DT	227	struct f03_data *f03 = dev_get_drvdata(&fn->dev);
	228	int error;
	229
	230	if (!f03->serio_registered) {
	231	error = rmi_f03_register_pt(f03);
	232	if (error)
	233	return error;
	234
	235	f03->serio_registered = true;
	236	} else {
	237	/*
	238	* We must be re-configuring the sensor, just enable
	239	* interrupts for this function.
	240	*/
	241	fn->rmi_dev->driver->set_irq_bits(fn->rmi_dev, fn->irq_mask);
	242	}
c5e8848f LP	243
	244	return 0;
	245	}
	246
24d28e4f	247	static irqreturn_t rmi_f03_attention(int irq, void *ctx)
c5e8848f	248	{
24d28e4f	249	struct rmi_function *fn = ctx;
e621132f	250	struct rmi_device *rmi_dev = fn->rmi_dev;
ae9979c3	251	struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
c5e8848f	252	struct f03_data *f03 = dev_get_drvdata(&fn->dev);
6abe534f	253	const u16 data_addr = fn->fd.data_base_addr + RMI_F03_OB_OFFSET;
c5e8848f LP	254	const u8 ob_len = f03->rx_queue_length * RMI_F03_OB_SIZE;
	255	u8 obs[RMI_F03_QUEUE_LENGTH * RMI_F03_OB_SIZE];
	256	u8 ob_status;
	257	u8 ob_data;
	258	unsigned int serio_flags;
	259	int i;
	260	int error;
	261
ae9979c3	262	if (drvdata->attn_data.data) {
e621132f	263	/* First grab the data passed by the transport device */
ae9979c3	264	if (drvdata->attn_data.size < ob_len) {
e621132f	265	dev_warn(&fn->dev, "F03 interrupted, but data is missing!\n");
24d28e4f	266	return IRQ_HANDLED;
e621132f DW	267	}
e621132f DW	268
ae9979c3	269	memcpy(obs, drvdata->attn_data.data, ob_len);
e621132f	270
ae9979c3 BT	271	drvdata->attn_data.data += ob_len;
ae9979c3 BT	272	drvdata->attn_data.size -= ob_len;
e621132f DW	273	} else {
e621132f DW	274	/* Grab all of the data registers, and check them for data */
6abe534f	275	error = rmi_read_block(fn->rmi_dev, data_addr, &obs, ob_len);
e621132f DW	276	if (error) {
	277	dev_err(&fn->dev,
	278	"%s: Failed to read F03 output buffers: %d\n",
	279	__func__, error);
	280	serio_interrupt(f03->serio, 0, SERIO_TIMEOUT);
24d28e4f	281	return IRQ_RETVAL(error);
e621132f	282	}
c5e8848f LP	283	}
	284
	285	for (i = 0; i < ob_len; i += RMI_F03_OB_SIZE) {
	286	ob_status = obs[i];
	287	ob_data = obs[i + RMI_F03_OB_DATA_OFFSET];
	288	serio_flags = 0;
	289
	290	if (!(ob_status & RMI_F03_RX_DATA_OFB))
	291	continue;
	292
	293	if (ob_status & RMI_F03_OB_FLAG_TIMEOUT)
	294	serio_flags \|= SERIO_TIMEOUT;
	295	if (ob_status & RMI_F03_OB_FLAG_PARITY)
	296	serio_flags \|= SERIO_PARITY;
	297
	298	rmi_dbg(RMI_DEBUG_FN, &fn->dev,
	299	"%s: Received %.2hhx from PS2 guest T: %c P: %c\n",
	300	__func__, ob_data,
	301	serio_flags & SERIO_TIMEOUT ? 'Y' : 'N',
	302	serio_flags & SERIO_PARITY ? 'Y' : 'N');
	303
	304	serio_interrupt(f03->serio, ob_data, serio_flags);
	305	}
	306
24d28e4f	307	return IRQ_HANDLED;
c5e8848f LP	308	}
	309
	310	static void rmi_f03_remove(struct rmi_function *fn)
	311	{
	312	struct f03_data *f03 = dev_get_drvdata(&fn->dev);
	313
6abe534f DT	314	if (f03->serio_registered)
6abe534f DT	315	serio_unregister_port(f03->serio);
c5e8848f LP	316	}
	317
	318	struct rmi_function_handler rmi_f03_handler = {
	319	.driver = {
	320	.name = "rmi4_f03",
	321	},
	322	.func = 0x03,
	323	.probe = rmi_f03_probe,
	324	.config = rmi_f03_config,
	325	.attention = rmi_f03_attention,
	326	.remove = rmi_f03_remove,
	327	};
	328
	329	MODULE_AUTHOR("Lyude Paul <thatslyude@gmail.com>");
	330	MODULE_DESCRIPTION("RMI F03 module");
	331	MODULE_LICENSE("GPL");