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