[linux-2.6-block.git] / drivers / input / serio / olpc_apsp.c

/*
 * OLPC serio driver for multiplexed input from Marvell MMP security processor
 *
 * Copyright (C) 2011-2013 One Laptop Per Child
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/serio.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/slab.h>
#include <linux/delay.h>

/*
 * The OLPC XO-1.75 and XO-4 laptops do not have a hardware PS/2 controller.
 * Instead, the OLPC firmware runs a bit-banging PS/2 implementation on an
 * otherwise-unused slow processor which is included in the Marvell MMP2/MMP3
 * SoC, known as the "Security Processor" (SP) or "Wireless Trusted Module"
 * (WTM). This firmware then reports its results via the WTM registers,
 * which we read from the Application Processor (AP, i.e. main CPU) in this
 * driver.
 *
 * On the hardware side we have a PS/2 mouse and an AT keyboard, the data
 * is multiplexed through this system. We create a serio port for each one,
 * and demultiplex the data accordingly.
 */

/* WTM register offsets */
#define SECURE_PROCESSOR_COMMAND	0x40
#define COMMAND_RETURN_STATUS		0x80
#define COMMAND_FIFO_STATUS		0xc4
#define PJ_RST_INTERRUPT		0xc8
#define PJ_INTERRUPT_MASK		0xcc

/*
 * The upper byte of SECURE_PROCESSOR_COMMAND and COMMAND_RETURN_STATUS is
 * used to identify which port (device) is being talked to. The lower byte
 * is the data being sent/received.
 */
#define PORT_MASK	0xff00
#define DATA_MASK	0x00ff
#define PORT_SHIFT	8
#define KEYBOARD_PORT	0
#define TOUCHPAD_PORT	1

/* COMMAND_FIFO_STATUS */
#define CMD_CNTR_MASK		0x7 /* Number of pending/unprocessed commands */
#define MAX_PENDING_CMDS	4   /* from device specs */

/* PJ_RST_INTERRUPT */
#define SP_COMMAND_COMPLETE_RESET	0x1

/* PJ_INTERRUPT_MASK */
#define INT_0	(1 << 0)

/* COMMAND_FIFO_STATUS */
#define CMD_STS_MASK	0x100

struct olpc_apsp {
	struct device *dev;
	struct serio *kbio;
	struct serio *padio;
	void __iomem *base;
	int open_count;
	int irq;
};

static int olpc_apsp_write(struct serio *port, unsigned char val)
{
	struct olpc_apsp *priv = port->port_data;
	unsigned int i;
	u32 which = 0;

	if (port == priv->padio)
		which = TOUCHPAD_PORT << PORT_SHIFT;
	else
		which = KEYBOARD_PORT << PORT_SHIFT;

	dev_dbg(priv->dev, "olpc_apsp_write which=%x val=%x\n", which, val);
	for (i = 0; i < 50; i++) {
		u32 sts = readl(priv->base + COMMAND_FIFO_STATUS);
		if ((sts & CMD_CNTR_MASK) < MAX_PENDING_CMDS) {
			writel(which | val,
			       priv->base + SECURE_PROCESSOR_COMMAND);
			return 0;
		}
		/* SP busy. This has not been seen in practice. */
		mdelay(1);
	}

	dev_dbg(priv->dev, "olpc_apsp_write timeout, status=%x\n",
		readl(priv->base + COMMAND_FIFO_STATUS));

	return -ETIMEDOUT;
}

static irqreturn_t olpc_apsp_rx(int irq, void *dev_id)
{
	struct olpc_apsp *priv = dev_id;
	unsigned int w, tmp;
	struct serio *serio;

	/*
	 * Write 1 to PJ_RST_INTERRUPT to acknowledge and clear the interrupt
	 * Write 0xff00 to SECURE_PROCESSOR_COMMAND.
	 */
	tmp = readl(priv->base + PJ_RST_INTERRUPT);
	if (!(tmp & SP_COMMAND_COMPLETE_RESET)) {
		dev_warn(priv->dev, "spurious interrupt?\n");
		return IRQ_NONE;
	}

	w = readl(priv->base + COMMAND_RETURN_STATUS);
	dev_dbg(priv->dev, "olpc_apsp_rx %x\n", w);

	if (w >> PORT_SHIFT == KEYBOARD_PORT)
		serio = priv->kbio;
	else
		serio = priv->padio;

	serio_interrupt(serio, w & DATA_MASK, 0);

	/* Ack and clear interrupt */
	writel(tmp | SP_COMMAND_COMPLETE_RESET, priv->base + PJ_RST_INTERRUPT);
	writel(PORT_MASK, priv->base + SECURE_PROCESSOR_COMMAND);

	pm_wakeup_event(priv->dev, 1000);
	return IRQ_HANDLED;
}

static int olpc_apsp_open(struct serio *port)
{
	struct olpc_apsp *priv = port->port_data;
	unsigned int tmp;
	unsigned long l;

	if (priv->open_count++ == 0) {
		l = readl(priv->base + COMMAND_FIFO_STATUS);
		if (!(l & CMD_STS_MASK)) {
			dev_err(priv->dev, "SP cannot accept commands.\n");
			return -EIO;
		}

		/* Enable interrupt 0 by clearing its bit */
		tmp = readl(priv->base + PJ_INTERRUPT_MASK);
		writel(tmp & ~INT_0, priv->base + PJ_INTERRUPT_MASK);
	}

	return 0;
}

static void olpc_apsp_close(struct serio *port)
{
	struct olpc_apsp *priv = port->port_data;
	unsigned int tmp;

	if (--priv->open_count == 0) {
		/* Disable interrupt 0 */
		tmp = readl(priv->base + PJ_INTERRUPT_MASK);
		writel(tmp | INT_0, priv->base + PJ_INTERRUPT_MASK);
	}
}

static int olpc_apsp_probe(struct platform_device *pdev)
{
	struct serio *kb_serio, *pad_serio;
	struct olpc_apsp *priv;
	struct resource *res;
	int error;

	priv = devm_kzalloc(&pdev->dev, sizeof(struct olpc_apsp), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	priv->dev = &pdev->dev;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	priv->base = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(priv->base)) {
		dev_err(&pdev->dev, "Failed to map WTM registers\n");
		return PTR_ERR(priv->base);
	}

	priv->irq = platform_get_irq(pdev, 0);
	if (priv->irq < 0)
		return priv->irq;

	/* KEYBOARD */
	kb_serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
	if (!kb_serio)
		return -ENOMEM;
	kb_serio->id.type	= SERIO_8042_XL;
	kb_serio->write		= olpc_apsp_write;
	kb_serio->open		= olpc_apsp_open;
	kb_serio->close		= olpc_apsp_close;
	kb_serio->port_data	= priv;
	kb_serio->dev.parent	= &pdev->dev;
	strlcpy(kb_serio->name, "sp keyboard", sizeof(kb_serio->name));
	strlcpy(kb_serio->phys, "sp/serio0", sizeof(kb_serio->phys));
	priv->kbio		= kb_serio;
	serio_register_port(kb_serio);

	/* TOUCHPAD */
	pad_serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
	if (!pad_serio) {
		error = -ENOMEM;
		goto err_pad;
	}
	pad_serio->id.type	= SERIO_8042;
	pad_serio->write	= olpc_apsp_write;
	pad_serio->open		= olpc_apsp_open;
	pad_serio->close	= olpc_apsp_close;
	pad_serio->port_data	= priv;
	pad_serio->dev.parent	= &pdev->dev;
	strlcpy(pad_serio->name, "sp touchpad", sizeof(pad_serio->name));
	strlcpy(pad_serio->phys, "sp/serio1", sizeof(pad_serio->phys));
	priv->padio		= pad_serio;
	serio_register_port(pad_serio);

	error = request_irq(priv->irq, olpc_apsp_rx, 0, "olpc-apsp", priv);
	if (error) {
		dev_err(&pdev->dev, "Failed to request IRQ\n");
		goto err_irq;
	}

	device_init_wakeup(priv->dev, 1);
	platform_set_drvdata(pdev, priv);

	dev_dbg(&pdev->dev, "probed successfully.\n");
	return 0;

err_irq:
	serio_unregister_port(pad_serio);
err_pad:
	serio_unregister_port(kb_serio);
	return error;
}

static int olpc_apsp_remove(struct platform_device *pdev)
{
	struct olpc_apsp *priv = platform_get_drvdata(pdev);

	free_irq(priv->irq, priv);

	serio_unregister_port(priv->kbio);
	serio_unregister_port(priv->padio);

	return 0;
}

static const struct of_device_id olpc_apsp_dt_ids[] = {
	{ .compatible = "olpc,ap-sp", },
	{}
};
MODULE_DEVICE_TABLE(of, olpc_apsp_dt_ids);

static struct platform_driver olpc_apsp_driver = {
	.probe		= olpc_apsp_probe,
	.remove		= olpc_apsp_remove,
	.driver		= {
		.name	= "olpc-apsp",
		.of_match_table = olpc_apsp_dt_ids,
	},
};

MODULE_DESCRIPTION("OLPC AP-SP serio driver");
MODULE_LICENSE("GPL");
module_platform_driver(olpc_apsp_driver);
Commit	Line	Data
b56ece9a DD	1	/*
	2	* OLPC serio driver for multiplexed input from Marvell MMP security processor
	3	*
	4	* Copyright (C) 2011-2013 One Laptop Per Child
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*/
	16
	17	#include <linux/module.h>
	18	#include <linux/interrupt.h>
b56ece9a DD	19	#include <linux/serio.h>
	20	#include <linux/err.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/io.h>
	23	#include <linux/of.h>
	24	#include <linux/slab.h>
	25	#include <linux/delay.h>
	26
	27	/*
	28	* The OLPC XO-1.75 and XO-4 laptops do not have a hardware PS/2 controller.
	29	* Instead, the OLPC firmware runs a bit-banging PS/2 implementation on an
	30	* otherwise-unused slow processor which is included in the Marvell MMP2/MMP3
	31	* SoC, known as the "Security Processor" (SP) or "Wireless Trusted Module"
	32	* (WTM). This firmware then reports its results via the WTM registers,
	33	* which we read from the Application Processor (AP, i.e. main CPU) in this
	34	* driver.
	35	*
	36	* On the hardware side we have a PS/2 mouse and an AT keyboard, the data
	37	* is multiplexed through this system. We create a serio port for each one,
	38	* and demultiplex the data accordingly.
	39	*/
	40
	41	/* WTM register offsets */
	42	#define SECURE_PROCESSOR_COMMAND 0x40
	43	#define COMMAND_RETURN_STATUS 0x80
	44	#define COMMAND_FIFO_STATUS 0xc4
	45	#define PJ_RST_INTERRUPT 0xc8
	46	#define PJ_INTERRUPT_MASK 0xcc
	47
	48	/*
	49	* The upper byte of SECURE_PROCESSOR_COMMAND and COMMAND_RETURN_STATUS is
	50	* used to identify which port (device) is being talked to. The lower byte
	51	* is the data being sent/received.
	52	*/
	53	#define PORT_MASK 0xff00
	54	#define DATA_MASK 0x00ff
	55	#define PORT_SHIFT 8
	56	#define KEYBOARD_PORT 0
	57	#define TOUCHPAD_PORT 1
	58
	59	/* COMMAND_FIFO_STATUS */
	60	#define CMD_CNTR_MASK 0x7 /* Number of pending/unprocessed commands */
	61	#define MAX_PENDING_CMDS 4 /* from device specs */
	62
	63	/* PJ_RST_INTERRUPT */
	64	#define SP_COMMAND_COMPLETE_RESET 0x1
	65
	66	/* PJ_INTERRUPT_MASK */
	67	#define INT_0 (1 << 0)
	68
	69	/* COMMAND_FIFO_STATUS */
	70	#define CMD_STS_MASK 0x100
	71
	72	struct olpc_apsp {
	73	struct device *dev;
	74	struct serio *kbio;
	75	struct serio *padio;
	76	void __iomem *base;
	77	int open_count;
	78	int irq;
	79	};
	80
	81	static int olpc_apsp_write(struct serio *port, unsigned char val)
	82	{
83	struct olpc_apsp *priv = port->port_data;
84	unsigned int i;
85	u32 which = 0;
86
87	if (port == priv->padio)
88	which = TOUCHPAD_PORT << PORT_SHIFT;
89	else
90	which = KEYBOARD_PORT << PORT_SHIFT;
91
92	dev_dbg(priv->dev, "olpc_apsp_write which=%x val=%x\n", which, val);
93	for (i = 0; i < 50; i++) {
94	u32 sts = readl(priv->base + COMMAND_FIFO_STATUS);
95	if ((sts & CMD_CNTR_MASK) < MAX_PENDING_CMDS) {
96	writel(which \| val,
97	priv->base + SECURE_PROCESSOR_COMMAND);
98	return 0;
99	}
100	/* SP busy. This has not been seen in practice. */
101	mdelay(1);
102	}
103
104	dev_dbg(priv->dev, "olpc_apsp_write timeout, status=%x\n",
105	readl(priv->base + COMMAND_FIFO_STATUS));
106
107	return -ETIMEDOUT;
108	}
109
110	static irqreturn_t olpc_apsp_rx(int irq, void *dev_id)
111	{
112	struct olpc_apsp *priv = dev_id;
113	unsigned int w, tmp;
114	struct serio *serio;
115
116	/*
117	* Write 1 to PJ_RST_INTERRUPT to acknowledge and clear the interrupt
118	* Write 0xff00 to SECURE_PROCESSOR_COMMAND.
119	*/
120	tmp = readl(priv->base + PJ_RST_INTERRUPT);
121	if (!(tmp & SP_COMMAND_COMPLETE_RESET)) {
122	dev_warn(priv->dev, "spurious interrupt?\n");
123	return IRQ_NONE;
124	}
125
126	w = readl(priv->base + COMMAND_RETURN_STATUS);
127	dev_dbg(priv->dev, "olpc_apsp_rx %x\n", w);
128
129	if (w >> PORT_SHIFT == KEYBOARD_PORT)
130	serio = priv->kbio;
131	else
132	serio = priv->padio;
133
134	serio_interrupt(serio, w & DATA_MASK, 0);
135
136	/* Ack and clear interrupt */
137	writel(tmp \| SP_COMMAND_COMPLETE_RESET, priv->base + PJ_RST_INTERRUPT);
138	writel(PORT_MASK, priv->base + SECURE_PROCESSOR_COMMAND);
139
140	pm_wakeup_event(priv->dev, 1000);
141	return IRQ_HANDLED;
142	}
143
144	static int olpc_apsp_open(struct serio *port)
145	{
146	struct olpc_apsp *priv = port->port_data;
147	unsigned int tmp;
af518342	148	unsigned long l;
b56ece9a DD	149
b56ece9a DD	150	if (priv->open_count++ == 0) {
af518342 LR	151	l = readl(priv->base + COMMAND_FIFO_STATUS);
	152	if (!(l & CMD_STS_MASK)) {
	153	dev_err(priv->dev, "SP cannot accept commands.\n");
	154	return -EIO;
	155	}
	156
b56ece9a DD	157	/* Enable interrupt 0 by clearing its bit */
	158	tmp = readl(priv->base + PJ_INTERRUPT_MASK);
	159	writel(tmp & ~INT_0, priv->base + PJ_INTERRUPT_MASK);
	160	}
	161
	162	return 0;
	163	}
	164
	165	static void olpc_apsp_close(struct serio *port)
	166	{
	167	struct olpc_apsp *priv = port->port_data;
	168	unsigned int tmp;
	169
	170	if (--priv->open_count == 0) {
	171	/* Disable interrupt 0 */
	172	tmp = readl(priv->base + PJ_INTERRUPT_MASK);
	173	writel(tmp \| INT_0, priv->base + PJ_INTERRUPT_MASK);
	174	}
	175	}
	176
	177	static int olpc_apsp_probe(struct platform_device *pdev)
	178	{
	179	struct serio kb_serio, pad_serio;
	180	struct olpc_apsp *priv;
	181	struct resource *res;
b56ece9a DD	182	int error;
	183
	184	priv = devm_kzalloc(&pdev->dev, sizeof(struct olpc_apsp), GFP_KERNEL);
	185	if (!priv)
	186	return -ENOMEM;
	187
ec87da10 LR	188	priv->dev = &pdev->dev;
ec87da10 LR	189
b56ece9a	190	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
b56ece9a DD	191	priv->base = devm_ioremap_resource(&pdev->dev, res);
	192	if (IS_ERR(priv->base)) {
	193	dev_err(&pdev->dev, "Failed to map WTM registers\n");
	194	return PTR_ERR(priv->base);
	195	}
	196
	197	priv->irq = platform_get_irq(pdev, 0);
	198	if (priv->irq < 0)
	199	return priv->irq;
	200
b56ece9a DD	201	/* KEYBOARD */
	202	kb_serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
	203	if (!kb_serio)
	204	return -ENOMEM;
	205	kb_serio->id.type = SERIO_8042_XL;
	206	kb_serio->write = olpc_apsp_write;
	207	kb_serio->open = olpc_apsp_open;
	208	kb_serio->close = olpc_apsp_close;
	209	kb_serio->port_data = priv;
	210	kb_serio->dev.parent = &pdev->dev;
	211	strlcpy(kb_serio->name, "sp keyboard", sizeof(kb_serio->name));
	212	strlcpy(kb_serio->phys, "sp/serio0", sizeof(kb_serio->phys));
	213	priv->kbio = kb_serio;
	214	serio_register_port(kb_serio);
	215
	216	/* TOUCHPAD */
	217	pad_serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
	218	if (!pad_serio) {
	219	error = -ENOMEM;
	220	goto err_pad;
	221	}
	222	pad_serio->id.type = SERIO_8042;
	223	pad_serio->write = olpc_apsp_write;
	224	pad_serio->open = olpc_apsp_open;
	225	pad_serio->close = olpc_apsp_close;
	226	pad_serio->port_data = priv;
	227	pad_serio->dev.parent = &pdev->dev;
	228	strlcpy(pad_serio->name, "sp touchpad", sizeof(pad_serio->name));
	229	strlcpy(pad_serio->phys, "sp/serio1", sizeof(pad_serio->phys));
	230	priv->padio = pad_serio;
	231	serio_register_port(pad_serio);
	232
	233	error = request_irq(priv->irq, olpc_apsp_rx, 0, "olpc-apsp", priv);
	234	if (error) {
	235	dev_err(&pdev->dev, "Failed to request IRQ\n");
	236	goto err_irq;
	237	}
	238
b56ece9a DD	239	device_init_wakeup(priv->dev, 1);
	240	platform_set_drvdata(pdev, priv);
	241
	242	dev_dbg(&pdev->dev, "probed successfully.\n");
	243	return 0;
	244
	245	err_irq:
	246	serio_unregister_port(pad_serio);
	247	err_pad:
	248	serio_unregister_port(kb_serio);
	249	return error;
	250	}
	251
	252	static int olpc_apsp_remove(struct platform_device *pdev)
	253	{
	254	struct olpc_apsp *priv = platform_get_drvdata(pdev);
	255
	256	free_irq(priv->irq, priv);
	257
	258	serio_unregister_port(priv->kbio);
	259	serio_unregister_port(priv->padio);
	260
	261	return 0;
	262	}
	263
597173a8	264	static const struct of_device_id olpc_apsp_dt_ids[] = {
b56ece9a DD	265	{ .compatible = "olpc,ap-sp", },
	266	{}
	267	};
	268	MODULE_DEVICE_TABLE(of, olpc_apsp_dt_ids);
	269
	270	static struct platform_driver olpc_apsp_driver = {
	271	.probe = olpc_apsp_probe,
	272	.remove = olpc_apsp_remove,
	273	.driver = {
	274	.name = "olpc-apsp",
b56ece9a DD	275	.of_match_table = olpc_apsp_dt_ids,
	276	},
	277	};
	278
	279	MODULE_DESCRIPTION("OLPC AP-SP serio driver");
	280	MODULE_LICENSE("GPL");
	281	module_platform_driver(olpc_apsp_driver);