1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/module.h>
19#include <linux/serio.h>
20#include <linux/interrupt.h>
21#include <linux/errno.h>
22#include <linux/slab.h>
23#include <linux/list.h>
24#include <linux/io.h>
25#include <linux/of_address.h>
26#include <linux/of_device.h>
27#include <linux/of_irq.h>
28#include <linux/of_platform.h>
29
30#define DRIVER_NAME "xilinx_ps2"
31
32
33#define XPS2_SRST_OFFSET 0x00000000
34#define XPS2_STATUS_OFFSET 0x00000004
35#define XPS2_RX_DATA_OFFSET 0x00000008
36#define XPS2_TX_DATA_OFFSET 0x0000000C
37#define XPS2_GIER_OFFSET 0x0000002C
38#define XPS2_IPISR_OFFSET 0x00000030
39#define XPS2_IPIER_OFFSET 0x00000038
40
41
42#define XPS2_SRST_RESET 0x0000000A
43
44
45#define XPS2_STATUS_RX_FULL 0x00000001
46#define XPS2_STATUS_TX_FULL 0x00000002
47
48
49
50#define XPS2_IPIXR_WDT_TOUT 0x00000001
51#define XPS2_IPIXR_TX_NOACK 0x00000002
52#define XPS2_IPIXR_TX_ACK 0x00000004
53#define XPS2_IPIXR_RX_OVF 0x00000008
54#define XPS2_IPIXR_RX_ERR 0x00000010
55#define XPS2_IPIXR_RX_FULL 0x00000020
56
57
58#define XPS2_IPIXR_TX_ALL (XPS2_IPIXR_TX_NOACK | XPS2_IPIXR_TX_ACK)
59
60
61#define XPS2_IPIXR_RX_ALL (XPS2_IPIXR_RX_OVF | XPS2_IPIXR_RX_ERR | \
62 XPS2_IPIXR_RX_FULL)
63
64
65#define XPS2_IPIXR_ALL (XPS2_IPIXR_TX_ALL | XPS2_IPIXR_RX_ALL | \
66 XPS2_IPIXR_WDT_TOUT)
67
68
69#define XPS2_GIER_GIE_MASK 0x80000000
70
71struct xps2data {
72 int irq;
73 spinlock_t lock;
74 void __iomem *base_address;
75 unsigned int flags;
76 struct serio *serio;
77 struct device *dev;
78};
79
80
81
82
83
84
85
86
87
88
89
90
91
92static int xps2_recv(struct xps2data *drvdata, u8 *byte)
93{
94 u32 sr;
95 int status = -1;
96
97
98 sr = in_be32(drvdata->base_address + XPS2_STATUS_OFFSET);
99 if (sr & XPS2_STATUS_RX_FULL) {
100 *byte = in_be32(drvdata->base_address + XPS2_RX_DATA_OFFSET);
101 status = 0;
102 }
103
104 return status;
105}
106
107
108
109
110static irqreturn_t xps2_interrupt(int irq, void *dev_id)
111{
112 struct xps2data *drvdata = dev_id;
113 u32 intr_sr;
114 u8 c;
115 int status;
116
117
118 intr_sr = in_be32(drvdata->base_address + XPS2_IPISR_OFFSET);
119 out_be32(drvdata->base_address + XPS2_IPISR_OFFSET, intr_sr);
120
121
122 if (intr_sr & XPS2_IPIXR_RX_OVF)
123 dev_warn(drvdata->dev, "receive overrun error\n");
124
125 if (intr_sr & XPS2_IPIXR_RX_ERR)
126 drvdata->flags |= SERIO_PARITY;
127
128 if (intr_sr & (XPS2_IPIXR_TX_NOACK | XPS2_IPIXR_WDT_TOUT))
129 drvdata->flags |= SERIO_TIMEOUT;
130
131 if (intr_sr & XPS2_IPIXR_RX_FULL) {
132 status = xps2_recv(drvdata, &c);
133
134
135 if (status) {
136 dev_err(drvdata->dev,
137 "wrong rcvd byte count (%d)\n", status);
138 } else {
139 serio_interrupt(drvdata->serio, c, drvdata->flags);
140 drvdata->flags = 0;
141 }
142 }
143
144 return IRQ_HANDLED;
145}
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161static int sxps2_write(struct serio *pserio, unsigned char c)
162{
163 struct xps2data *drvdata = pserio->port_data;
164 unsigned long flags;
165 u32 sr;
166 int status = -1;
167
168 spin_lock_irqsave(&drvdata->lock, flags);
169
170
171 sr = in_be32(drvdata->base_address + XPS2_STATUS_OFFSET);
172 if (!(sr & XPS2_STATUS_TX_FULL)) {
173 out_be32(drvdata->base_address + XPS2_TX_DATA_OFFSET, c);
174 status = 0;
175 }
176
177 spin_unlock_irqrestore(&drvdata->lock, flags);
178
179 return status;
180}
181
182
183
184
185
186
187
188static int sxps2_open(struct serio *pserio)
189{
190 struct xps2data *drvdata = pserio->port_data;
191 int error;
192 u8 c;
193
194 error = request_irq(drvdata->irq, &xps2_interrupt, 0,
195 DRIVER_NAME, drvdata);
196 if (error) {
197 dev_err(drvdata->dev,
198 "Couldn't allocate interrupt %d\n", drvdata->irq);
199 return error;
200 }
201
202
203 out_be32(drvdata->base_address + XPS2_GIER_OFFSET, XPS2_GIER_GIE_MASK);
204 out_be32(drvdata->base_address + XPS2_IPIER_OFFSET, XPS2_IPIXR_RX_ALL);
205 (void)xps2_recv(drvdata, &c);
206
207 return 0;
208}
209
210
211
212
213
214
215
216static void sxps2_close(struct serio *pserio)
217{
218 struct xps2data *drvdata = pserio->port_data;
219
220
221 out_be32(drvdata->base_address + XPS2_GIER_OFFSET, 0x00);
222 out_be32(drvdata->base_address + XPS2_IPIER_OFFSET, 0x00);
223 free_irq(drvdata->irq, drvdata);
224}
225
226
227
228
229
230
231
232
233
234
235
236static int xps2_of_probe(struct platform_device *ofdev)
237{
238 struct resource r_mem;
239 struct xps2data *drvdata;
240 struct serio *serio;
241 struct device *dev = &ofdev->dev;
242 resource_size_t remap_size, phys_addr;
243 unsigned int irq;
244 int error;
245
246 dev_info(dev, "Device Tree Probing \'%s\'\n",
247 ofdev->dev.of_node->name);
248
249
250 error = of_address_to_resource(ofdev->dev.of_node, 0, &r_mem);
251 if (error) {
252 dev_err(dev, "invalid address\n");
253 return error;
254 }
255
256
257 irq = irq_of_parse_and_map(ofdev->dev.of_node, 0);
258 if (!irq) {
259 dev_err(dev, "no IRQ found\n");
260 return -ENODEV;
261 }
262
263 drvdata = kzalloc(sizeof(struct xps2data), GFP_KERNEL);
264 serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
265 if (!drvdata || !serio) {
266 error = -ENOMEM;
267 goto failed1;
268 }
269
270 spin_lock_init(&drvdata->lock);
271 drvdata->irq = irq;
272 drvdata->serio = serio;
273 drvdata->dev = dev;
274
275 phys_addr = r_mem.start;
276 remap_size = resource_size(&r_mem);
277 if (!request_mem_region(phys_addr, remap_size, DRIVER_NAME)) {
278 dev_err(dev, "Couldn't lock memory region at 0x%08llX\n",
279 (unsigned long long)phys_addr);
280 error = -EBUSY;
281 goto failed1;
282 }
283
284
285 drvdata->base_address = ioremap(phys_addr, remap_size);
286 if (drvdata->base_address == NULL) {
287 dev_err(dev, "Couldn't ioremap memory at 0x%08llX\n",
288 (unsigned long long)phys_addr);
289 error = -EFAULT;
290 goto failed2;
291 }
292
293
294 out_be32(drvdata->base_address + XPS2_IPIER_OFFSET, 0);
295
296
297
298 out_be32(drvdata->base_address + XPS2_SRST_OFFSET, XPS2_SRST_RESET);
299
300 dev_info(dev, "Xilinx PS2 at 0x%08llX mapped to 0x%p, irq=%d\n",
301 (unsigned long long)phys_addr, drvdata->base_address,
302 drvdata->irq);
303
304 serio->id.type = SERIO_8042;
305 serio->write = sxps2_write;
306 serio->open = sxps2_open;
307 serio->close = sxps2_close;
308 serio->port_data = drvdata;
309 serio->dev.parent = dev;
310 snprintf(serio->name, sizeof(serio->name),
311 "Xilinx XPS PS/2 at %08llX", (unsigned long long)phys_addr);
312 snprintf(serio->phys, sizeof(serio->phys),
313 "xilinxps2/serio at %08llX", (unsigned long long)phys_addr);
314
315 serio_register_port(serio);
316
317 platform_set_drvdata(ofdev, drvdata);
318 return 0;
319
320failed2:
321 release_mem_region(phys_addr, remap_size);
322failed1:
323 kfree(serio);
324 kfree(drvdata);
325
326 return error;
327}
328
329
330
331
332
333
334
335
336
337static int xps2_of_remove(struct platform_device *of_dev)
338{
339 struct xps2data *drvdata = platform_get_drvdata(of_dev);
340 struct resource r_mem;
341
342 serio_unregister_port(drvdata->serio);
343 iounmap(drvdata->base_address);
344
345
346 if (of_address_to_resource(of_dev->dev.of_node, 0, &r_mem))
347 dev_err(drvdata->dev, "invalid address\n");
348 else
349 release_mem_region(r_mem.start, resource_size(&r_mem));
350
351 kfree(drvdata);
352
353 return 0;
354}
355
356
357static const struct of_device_id xps2_of_match[] = {
358 { .compatible = "xlnx,xps-ps2-1.00.a", },
359 { },
360};
361MODULE_DEVICE_TABLE(of, xps2_of_match);
362
363static struct platform_driver xps2_of_driver = {
364 .driver = {
365 .name = DRIVER_NAME,
366 .of_match_table = xps2_of_match,
367 },
368 .probe = xps2_of_probe,
369 .remove = xps2_of_remove,
370};
371module_platform_driver(xps2_of_driver);
372
373MODULE_AUTHOR("Xilinx, Inc.");
374MODULE_DESCRIPTION("Xilinx XPS PS/2 driver");
375MODULE_LICENSE("GPL");
376
377