1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * linux/drivers/input/serio/sa1111ps2.c |
4 | * |
5 | * Copyright (C) 2002 Russell King |
6 | */ |
7 | #include <linux/module.h> |
8 | #include <linux/init.h> |
9 | #include <linux/input.h> |
10 | #include <linux/serio.h> |
11 | #include <linux/errno.h> |
12 | #include <linux/interrupt.h> |
13 | #include <linux/ioport.h> |
14 | #include <linux/delay.h> |
15 | #include <linux/device.h> |
16 | #include <linux/slab.h> |
17 | #include <linux/spinlock.h> |
18 | |
19 | #include <asm/io.h> |
20 | |
21 | #include <asm/hardware/sa1111.h> |
22 | |
23 | #define PS2CR 0x0000 |
24 | #define PS2STAT 0x0004 |
25 | #define PS2DATA 0x0008 |
26 | #define PS2CLKDIV 0x000c |
27 | #define PS2PRECNT 0x0010 |
28 | |
29 | #define PS2CR_ENA 0x08 |
30 | #define PS2CR_FKD 0x02 |
31 | #define PS2CR_FKC 0x01 |
32 | |
33 | #define PS2STAT_STP 0x0100 |
34 | #define PS2STAT_TXE 0x0080 |
35 | #define PS2STAT_TXB 0x0040 |
36 | #define PS2STAT_RXF 0x0020 |
37 | #define PS2STAT_RXB 0x0010 |
38 | #define PS2STAT_ENA 0x0008 |
39 | #define PS2STAT_RXP 0x0004 |
40 | #define PS2STAT_KBD 0x0002 |
41 | #define PS2STAT_KBC 0x0001 |
42 | |
43 | struct ps2if { |
44 | struct serio *io; |
45 | struct sa1111_dev *dev; |
46 | void __iomem *base; |
47 | int rx_irq; |
48 | int tx_irq; |
49 | unsigned int open; |
50 | spinlock_t lock; |
51 | unsigned int head; |
52 | unsigned int tail; |
53 | unsigned char buf[4]; |
54 | }; |
55 | |
56 | /* |
57 | * Read all bytes waiting in the PS2 port. There should be |
58 | * at the most one, but we loop for safety. If there was a |
59 | * framing error, we have to manually clear the status. |
60 | */ |
61 | static irqreturn_t ps2_rxint(int irq, void *dev_id) |
62 | { |
63 | struct ps2if *ps2if = dev_id; |
64 | unsigned int scancode, flag, status; |
65 | |
66 | status = readl_relaxed(ps2if->base + PS2STAT); |
67 | while (status & PS2STAT_RXF) { |
68 | if (status & PS2STAT_STP) |
69 | writel_relaxed(PS2STAT_STP, ps2if->base + PS2STAT); |
70 | |
71 | flag = (status & PS2STAT_STP ? SERIO_FRAME : 0) | |
72 | (status & PS2STAT_RXP ? 0 : SERIO_PARITY); |
73 | |
74 | scancode = readl_relaxed(ps2if->base + PS2DATA) & 0xff; |
75 | |
76 | if (hweight8(scancode) & 1) |
77 | flag ^= SERIO_PARITY; |
78 | |
79 | serio_interrupt(serio: ps2if->io, data: scancode, flags: flag); |
80 | |
81 | status = readl_relaxed(ps2if->base + PS2STAT); |
82 | } |
83 | |
84 | return IRQ_HANDLED; |
85 | } |
86 | |
87 | /* |
88 | * Completion of ps2 write |
89 | */ |
90 | static irqreturn_t ps2_txint(int irq, void *dev_id) |
91 | { |
92 | struct ps2if *ps2if = dev_id; |
93 | unsigned int status; |
94 | |
95 | spin_lock(lock: &ps2if->lock); |
96 | status = readl_relaxed(ps2if->base + PS2STAT); |
97 | if (ps2if->head == ps2if->tail) { |
98 | disable_irq_nosync(irq); |
99 | /* done */ |
100 | } else if (status & PS2STAT_TXE) { |
101 | writel_relaxed(ps2if->buf[ps2if->tail], ps2if->base + PS2DATA); |
102 | ps2if->tail = (ps2if->tail + 1) & (sizeof(ps2if->buf) - 1); |
103 | } |
104 | spin_unlock(lock: &ps2if->lock); |
105 | |
106 | return IRQ_HANDLED; |
107 | } |
108 | |
109 | /* |
110 | * Write a byte to the PS2 port. We have to wait for the |
111 | * port to indicate that the transmitter is empty. |
112 | */ |
113 | static int ps2_write(struct serio *io, unsigned char val) |
114 | { |
115 | struct ps2if *ps2if = io->port_data; |
116 | unsigned long flags; |
117 | unsigned int head; |
118 | |
119 | spin_lock_irqsave(&ps2if->lock, flags); |
120 | |
121 | /* |
122 | * If the TX register is empty, we can go straight out. |
123 | */ |
124 | if (readl_relaxed(ps2if->base + PS2STAT) & PS2STAT_TXE) { |
125 | writel_relaxed(val, ps2if->base + PS2DATA); |
126 | } else { |
127 | if (ps2if->head == ps2if->tail) |
128 | enable_irq(irq: ps2if->tx_irq); |
129 | head = (ps2if->head + 1) & (sizeof(ps2if->buf) - 1); |
130 | if (head != ps2if->tail) { |
131 | ps2if->buf[ps2if->head] = val; |
132 | ps2if->head = head; |
133 | } |
134 | } |
135 | |
136 | spin_unlock_irqrestore(lock: &ps2if->lock, flags); |
137 | return 0; |
138 | } |
139 | |
140 | static int ps2_open(struct serio *io) |
141 | { |
142 | struct ps2if *ps2if = io->port_data; |
143 | int ret; |
144 | |
145 | ret = sa1111_enable_device(ps2if->dev); |
146 | if (ret) |
147 | return ret; |
148 | |
149 | ret = request_irq(irq: ps2if->rx_irq, handler: ps2_rxint, flags: 0, |
150 | name: SA1111_DRIVER_NAME(ps2if->dev), dev: ps2if); |
151 | if (ret) { |
152 | printk(KERN_ERR "sa1111ps2: could not allocate IRQ%d: %d\n" , |
153 | ps2if->rx_irq, ret); |
154 | sa1111_disable_device(ps2if->dev); |
155 | return ret; |
156 | } |
157 | |
158 | ret = request_irq(irq: ps2if->tx_irq, handler: ps2_txint, flags: 0, |
159 | name: SA1111_DRIVER_NAME(ps2if->dev), dev: ps2if); |
160 | if (ret) { |
161 | printk(KERN_ERR "sa1111ps2: could not allocate IRQ%d: %d\n" , |
162 | ps2if->tx_irq, ret); |
163 | free_irq(ps2if->rx_irq, ps2if); |
164 | sa1111_disable_device(ps2if->dev); |
165 | return ret; |
166 | } |
167 | |
168 | ps2if->open = 1; |
169 | |
170 | enable_irq_wake(irq: ps2if->rx_irq); |
171 | |
172 | writel_relaxed(PS2CR_ENA, ps2if->base + PS2CR); |
173 | return 0; |
174 | } |
175 | |
176 | static void ps2_close(struct serio *io) |
177 | { |
178 | struct ps2if *ps2if = io->port_data; |
179 | |
180 | writel_relaxed(0, ps2if->base + PS2CR); |
181 | |
182 | disable_irq_wake(irq: ps2if->rx_irq); |
183 | |
184 | ps2if->open = 0; |
185 | |
186 | free_irq(ps2if->tx_irq, ps2if); |
187 | free_irq(ps2if->rx_irq, ps2if); |
188 | |
189 | sa1111_disable_device(ps2if->dev); |
190 | } |
191 | |
192 | /* |
193 | * Clear the input buffer. |
194 | */ |
195 | static void ps2_clear_input(struct ps2if *ps2if) |
196 | { |
197 | int maxread = 100; |
198 | |
199 | while (maxread--) { |
200 | if ((readl_relaxed(ps2if->base + PS2DATA) & 0xff) == 0xff) |
201 | break; |
202 | } |
203 | } |
204 | |
205 | static unsigned int ps2_test_one(struct ps2if *ps2if, |
206 | unsigned int mask) |
207 | { |
208 | unsigned int val; |
209 | |
210 | writel_relaxed(PS2CR_ENA | mask, ps2if->base + PS2CR); |
211 | |
212 | udelay(10); |
213 | |
214 | val = readl_relaxed(ps2if->base + PS2STAT); |
215 | return val & (PS2STAT_KBC | PS2STAT_KBD); |
216 | } |
217 | |
218 | /* |
219 | * Test the keyboard interface. We basically check to make sure that |
220 | * we can drive each line to the keyboard independently of each other. |
221 | */ |
222 | static int ps2_test(struct ps2if *ps2if) |
223 | { |
224 | unsigned int stat; |
225 | int ret = 0; |
226 | |
227 | stat = ps2_test_one(ps2if, PS2CR_FKC); |
228 | if (stat != PS2STAT_KBD) { |
229 | printk("PS/2 interface test failed[1]: %02x\n" , stat); |
230 | ret = -ENODEV; |
231 | } |
232 | |
233 | stat = ps2_test_one(ps2if, mask: 0); |
234 | if (stat != (PS2STAT_KBC | PS2STAT_KBD)) { |
235 | printk("PS/2 interface test failed[2]: %02x\n" , stat); |
236 | ret = -ENODEV; |
237 | } |
238 | |
239 | stat = ps2_test_one(ps2if, PS2CR_FKD); |
240 | if (stat != PS2STAT_KBC) { |
241 | printk("PS/2 interface test failed[3]: %02x\n" , stat); |
242 | ret = -ENODEV; |
243 | } |
244 | |
245 | writel_relaxed(0, ps2if->base + PS2CR); |
246 | |
247 | return ret; |
248 | } |
249 | |
250 | /* |
251 | * Add one device to this driver. |
252 | */ |
253 | static int ps2_probe(struct sa1111_dev *dev) |
254 | { |
255 | struct ps2if *ps2if; |
256 | struct serio *serio; |
257 | int ret; |
258 | |
259 | ps2if = kzalloc(size: sizeof(struct ps2if), GFP_KERNEL); |
260 | serio = kzalloc(size: sizeof(struct serio), GFP_KERNEL); |
261 | if (!ps2if || !serio) { |
262 | ret = -ENOMEM; |
263 | goto free; |
264 | } |
265 | |
266 | serio->id.type = SERIO_8042; |
267 | serio->write = ps2_write; |
268 | serio->open = ps2_open; |
269 | serio->close = ps2_close; |
270 | strscpy(serio->name, dev_name(dev: &dev->dev), sizeof(serio->name)); |
271 | strscpy(serio->phys, dev_name(dev: &dev->dev), sizeof(serio->phys)); |
272 | serio->port_data = ps2if; |
273 | serio->dev.parent = &dev->dev; |
274 | ps2if->io = serio; |
275 | ps2if->dev = dev; |
276 | sa1111_set_drvdata(dev, ps2if); |
277 | |
278 | spin_lock_init(&ps2if->lock); |
279 | |
280 | ps2if->rx_irq = sa1111_get_irq(dev, 0); |
281 | if (ps2if->rx_irq <= 0) { |
282 | ret = ps2if->rx_irq ? : -ENXIO; |
283 | goto free; |
284 | } |
285 | |
286 | ps2if->tx_irq = sa1111_get_irq(dev, 1); |
287 | if (ps2if->tx_irq <= 0) { |
288 | ret = ps2if->tx_irq ? : -ENXIO; |
289 | goto free; |
290 | } |
291 | |
292 | /* |
293 | * Request the physical region for this PS2 port. |
294 | */ |
295 | if (!request_mem_region(dev->res.start, |
296 | dev->res.end - dev->res.start + 1, |
297 | SA1111_DRIVER_NAME(dev))) { |
298 | ret = -EBUSY; |
299 | goto free; |
300 | } |
301 | |
302 | /* |
303 | * Our parent device has already mapped the region. |
304 | */ |
305 | ps2if->base = dev->mapbase; |
306 | |
307 | sa1111_enable_device(ps2if->dev); |
308 | |
309 | /* Incoming clock is 8MHz */ |
310 | writel_relaxed(0, ps2if->base + PS2CLKDIV); |
311 | writel_relaxed(127, ps2if->base + PS2PRECNT); |
312 | |
313 | /* |
314 | * Flush any pending input. |
315 | */ |
316 | ps2_clear_input(ps2if); |
317 | |
318 | /* |
319 | * Test the keyboard interface. |
320 | */ |
321 | ret = ps2_test(ps2if); |
322 | if (ret) |
323 | goto out; |
324 | |
325 | /* |
326 | * Flush any pending input. |
327 | */ |
328 | ps2_clear_input(ps2if); |
329 | |
330 | sa1111_disable_device(ps2if->dev); |
331 | serio_register_port(ps2if->io); |
332 | return 0; |
333 | |
334 | out: |
335 | sa1111_disable_device(ps2if->dev); |
336 | release_mem_region(dev->res.start, resource_size(&dev->res)); |
337 | free: |
338 | sa1111_set_drvdata(dev, NULL); |
339 | kfree(objp: ps2if); |
340 | kfree(objp: serio); |
341 | return ret; |
342 | } |
343 | |
344 | /* |
345 | * Remove one device from this driver. |
346 | */ |
347 | static void ps2_remove(struct sa1111_dev *dev) |
348 | { |
349 | struct ps2if *ps2if = sa1111_get_drvdata(dev); |
350 | |
351 | serio_unregister_port(serio: ps2if->io); |
352 | release_mem_region(dev->res.start, resource_size(&dev->res)); |
353 | sa1111_set_drvdata(dev, NULL); |
354 | |
355 | kfree(objp: ps2if); |
356 | } |
357 | |
358 | /* |
359 | * Our device driver structure |
360 | */ |
361 | static struct sa1111_driver ps2_driver = { |
362 | .drv = { |
363 | .name = "sa1111-ps2" , |
364 | .owner = THIS_MODULE, |
365 | }, |
366 | .devid = SA1111_DEVID_PS2, |
367 | .probe = ps2_probe, |
368 | .remove = ps2_remove, |
369 | }; |
370 | |
371 | static int __init ps2_init(void) |
372 | { |
373 | return sa1111_driver_register(&ps2_driver); |
374 | } |
375 | |
376 | static void __exit ps2_exit(void) |
377 | { |
378 | sa1111_driver_unregister(&ps2_driver); |
379 | } |
380 | |
381 | module_init(ps2_init); |
382 | module_exit(ps2_exit); |
383 | |
384 | MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>" ); |
385 | MODULE_DESCRIPTION("SA1111 PS2 controller driver" ); |
386 | MODULE_LICENSE("GPL" ); |
387 | |