1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/module.h>
18#include <linux/interrupt.h>
19#include <linux/init.h>
20#include <linux/serio.h>
21#include <linux/err.h>
22#include <linux/platform_device.h>
23#include <linux/io.h>
24#include <linux/of.h>
25#include <linux/slab.h>
26#include <linux/delay.h>
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43#define SECURE_PROCESSOR_COMMAND 0x40
44#define COMMAND_RETURN_STATUS 0x80
45#define COMMAND_FIFO_STATUS 0xc4
46#define PJ_RST_INTERRUPT 0xc8
47#define PJ_INTERRUPT_MASK 0xcc
48
49
50
51
52
53
54#define PORT_MASK 0xff00
55#define DATA_MASK 0x00ff
56#define PORT_SHIFT 8
57#define KEYBOARD_PORT 0
58#define TOUCHPAD_PORT 1
59
60
61#define CMD_CNTR_MASK 0x7
62#define MAX_PENDING_CMDS 4
63
64
65#define SP_COMMAND_COMPLETE_RESET 0x1
66
67
68#define INT_0 (1 << 0)
69
70
71#define CMD_STS_MASK 0x100
72
73struct olpc_apsp {
74 struct device *dev;
75 struct serio *kbio;
76 struct serio *padio;
77 void __iomem *base;
78 int open_count;
79 int irq;
80};
81
82static int olpc_apsp_write(struct serio *port, unsigned char val)
83{
84 struct olpc_apsp *priv = port->port_data;
85 unsigned int i;
86 u32 which = 0;
87
88 if (port == priv->padio)
89 which = TOUCHPAD_PORT << PORT_SHIFT;
90 else
91 which = KEYBOARD_PORT << PORT_SHIFT;
92
93 dev_dbg(priv->dev, "olpc_apsp_write which=%x val=%x\n", which, val);
94 for (i = 0; i < 50; i++) {
95 u32 sts = readl(priv->base + COMMAND_FIFO_STATUS);
96 if ((sts & CMD_CNTR_MASK) < MAX_PENDING_CMDS) {
97 writel(which | val,
98 priv->base + SECURE_PROCESSOR_COMMAND);
99 return 0;
100 }
101
102 mdelay(1);
103 }
104
105 dev_dbg(priv->dev, "olpc_apsp_write timeout, status=%x\n",
106 readl(priv->base + COMMAND_FIFO_STATUS));
107
108 return -ETIMEDOUT;
109}
110
111static irqreturn_t olpc_apsp_rx(int irq, void *dev_id)
112{
113 struct olpc_apsp *priv = dev_id;
114 unsigned int w, tmp;
115 struct serio *serio;
116
117
118
119
120
121 tmp = readl(priv->base + PJ_RST_INTERRUPT);
122 if (!(tmp & SP_COMMAND_COMPLETE_RESET)) {
123 dev_warn(priv->dev, "spurious interrupt?\n");
124 return IRQ_NONE;
125 }
126
127 w = readl(priv->base + COMMAND_RETURN_STATUS);
128 dev_dbg(priv->dev, "olpc_apsp_rx %x\n", w);
129
130 if (w >> PORT_SHIFT == KEYBOARD_PORT)
131 serio = priv->kbio;
132 else
133 serio = priv->padio;
134
135 serio_interrupt(serio, w & DATA_MASK, 0);
136
137
138 writel(tmp | SP_COMMAND_COMPLETE_RESET, priv->base + PJ_RST_INTERRUPT);
139 writel(PORT_MASK, priv->base + SECURE_PROCESSOR_COMMAND);
140
141 pm_wakeup_event(priv->dev, 1000);
142 return IRQ_HANDLED;
143}
144
145static int olpc_apsp_open(struct serio *port)
146{
147 struct olpc_apsp *priv = port->port_data;
148 unsigned int tmp;
149
150 if (priv->open_count++ == 0) {
151
152 tmp = readl(priv->base + PJ_INTERRUPT_MASK);
153 writel(tmp & ~INT_0, priv->base + PJ_INTERRUPT_MASK);
154 }
155
156 return 0;
157}
158
159static void olpc_apsp_close(struct serio *port)
160{
161 struct olpc_apsp *priv = port->port_data;
162 unsigned int tmp;
163
164 if (--priv->open_count == 0) {
165
166 tmp = readl(priv->base + PJ_INTERRUPT_MASK);
167 writel(tmp | INT_0, priv->base + PJ_INTERRUPT_MASK);
168 }
169}
170
171static int olpc_apsp_probe(struct platform_device *pdev)
172{
173 struct serio *kb_serio, *pad_serio;
174 struct olpc_apsp *priv;
175 struct resource *res;
176 struct device_node *np;
177 unsigned long l;
178 int error;
179
180 priv = devm_kzalloc(&pdev->dev, sizeof(struct olpc_apsp), GFP_KERNEL);
181 if (!priv)
182 return -ENOMEM;
183
184 np = pdev->dev.of_node;
185 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
186 priv->base = devm_ioremap_resource(&pdev->dev, res);
187 if (IS_ERR(priv->base)) {
188 dev_err(&pdev->dev, "Failed to map WTM registers\n");
189 return PTR_ERR(priv->base);
190 }
191
192 priv->irq = platform_get_irq(pdev, 0);
193 if (priv->irq < 0)
194 return priv->irq;
195
196 l = readl(priv->base + COMMAND_FIFO_STATUS);
197 if (!(l & CMD_STS_MASK)) {
198 dev_err(&pdev->dev, "SP cannot accept commands.\n");
199 return -EIO;
200 }
201
202
203 kb_serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
204 if (!kb_serio)
205 return -ENOMEM;
206 kb_serio->id.type = SERIO_8042_XL;
207 kb_serio->write = olpc_apsp_write;
208 kb_serio->open = olpc_apsp_open;
209 kb_serio->close = olpc_apsp_close;
210 kb_serio->port_data = priv;
211 kb_serio->dev.parent = &pdev->dev;
212 strlcpy(kb_serio->name, "sp keyboard", sizeof(kb_serio->name));
213 strlcpy(kb_serio->phys, "sp/serio0", sizeof(kb_serio->phys));
214 priv->kbio = kb_serio;
215 serio_register_port(kb_serio);
216
217
218 pad_serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
219 if (!pad_serio) {
220 error = -ENOMEM;
221 goto err_pad;
222 }
223 pad_serio->id.type = SERIO_8042;
224 pad_serio->write = olpc_apsp_write;
225 pad_serio->open = olpc_apsp_open;
226 pad_serio->close = olpc_apsp_close;
227 pad_serio->port_data = priv;
228 pad_serio->dev.parent = &pdev->dev;
229 strlcpy(pad_serio->name, "sp touchpad", sizeof(pad_serio->name));
230 strlcpy(pad_serio->phys, "sp/serio1", sizeof(pad_serio->phys));
231 priv->padio = pad_serio;
232 serio_register_port(pad_serio);
233
234 error = request_irq(priv->irq, olpc_apsp_rx, 0, "olpc-apsp", priv);
235 if (error) {
236 dev_err(&pdev->dev, "Failed to request IRQ\n");
237 goto err_irq;
238 }
239
240 priv->dev = &pdev->dev;
241 device_init_wakeup(priv->dev, 1);
242 platform_set_drvdata(pdev, priv);
243
244 dev_dbg(&pdev->dev, "probed successfully.\n");
245 return 0;
246
247err_irq:
248 serio_unregister_port(pad_serio);
249err_pad:
250 serio_unregister_port(kb_serio);
251 return error;
252}
253
254static int olpc_apsp_remove(struct platform_device *pdev)
255{
256 struct olpc_apsp *priv = platform_get_drvdata(pdev);
257
258 free_irq(priv->irq, priv);
259
260 serio_unregister_port(priv->kbio);
261 serio_unregister_port(priv->padio);
262
263 return 0;
264}
265
266static struct of_device_id olpc_apsp_dt_ids[] = {
267 { .compatible = "olpc,ap-sp", },
268 {}
269};
270MODULE_DEVICE_TABLE(of, olpc_apsp_dt_ids);
271
272static struct platform_driver olpc_apsp_driver = {
273 .probe = olpc_apsp_probe,
274 .remove = olpc_apsp_remove,
275 .driver = {
276 .name = "olpc-apsp",
277 .owner = THIS_MODULE,
278 .of_match_table = olpc_apsp_dt_ids,
279 },
280};
281
282MODULE_DESCRIPTION("OLPC AP-SP serio driver");
283MODULE_LICENSE("GPL");
284module_platform_driver(olpc_apsp_driver);
285