xref: /linux/drivers/input/serio/sa1111ps2.c (revision 7f4f3b14e8079ecde096bd734af10e30d40c27b7) 
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(ps2if->io, scancode, 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 	guard(spinlock)(&ps2if->lock);
96 
97 	status = readl_relaxed(ps2if->base + PS2STAT);
98 	if (ps2if->head == ps2if->tail) {
99 		disable_irq_nosync(irq);
100 		/* done */
101 	} else if (status & PS2STAT_TXE) {
102 		writel_relaxed(ps2if->buf[ps2if->tail], ps2if->base + PS2DATA);
103 		ps2if->tail = (ps2if->tail + 1) & (sizeof(ps2if->buf) - 1);
104 	}
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 int head;
117 
118 	guard(spinlock_irqsave)(&ps2if->lock);
119 
120 	/*
121 	 * If the TX register is empty, we can go straight out.
122 	 */
123 	if (readl_relaxed(ps2if->base + PS2STAT) & PS2STAT_TXE) {
124 		writel_relaxed(val, ps2if->base + PS2DATA);
125 	} else {
126 		if (ps2if->head == ps2if->tail)
127 			enable_irq(ps2if->tx_irq);
128 		head = (ps2if->head + 1) & (sizeof(ps2if->buf) - 1);
129 		if (head != ps2if->tail) {
130 			ps2if->buf[ps2if->head] = val;
131 			ps2if->head = head;
132 		}
133 	}
134 
135 	return 0;
136 }
137 
138 static int ps2_open(struct serio *io)
139 {
140 	struct ps2if *ps2if = io->port_data;
141 	int ret;
142 
143 	ret = sa1111_enable_device(ps2if->dev);
144 	if (ret)
145 		return ret;
146 
147 	ret = request_irq(ps2if->rx_irq, ps2_rxint, 0,
148 			  SA1111_DRIVER_NAME(ps2if->dev), ps2if);
149 	if (ret) {
150 		printk(KERN_ERR "sa1111ps2: could not allocate IRQ%d: %d\n",
151 			ps2if->rx_irq, ret);
152 		sa1111_disable_device(ps2if->dev);
153 		return ret;
154 	}
155 
156 	ret = request_irq(ps2if->tx_irq, ps2_txint, 0,
157 			  SA1111_DRIVER_NAME(ps2if->dev), ps2if);
158 	if (ret) {
159 		printk(KERN_ERR "sa1111ps2: could not allocate IRQ%d: %d\n",
160 			ps2if->tx_irq, ret);
161 		free_irq(ps2if->rx_irq, ps2if);
162 		sa1111_disable_device(ps2if->dev);
163 		return ret;
164 	}
165 
166 	ps2if->open = 1;
167 
168 	enable_irq_wake(ps2if->rx_irq);
169 
170 	writel_relaxed(PS2CR_ENA, ps2if->base + PS2CR);
171 	return 0;
172 }
173 
174 static void ps2_close(struct serio *io)
175 {
176 	struct ps2if *ps2if = io->port_data;
177 
178 	writel_relaxed(0, ps2if->base + PS2CR);
179 
180 	disable_irq_wake(ps2if->rx_irq);
181 
182 	ps2if->open = 0;
183 
184 	free_irq(ps2if->tx_irq, ps2if);
185 	free_irq(ps2if->rx_irq, ps2if);
186 
187 	sa1111_disable_device(ps2if->dev);
188 }
189 
190 /*
191  * Clear the input buffer.
192  */
193 static void ps2_clear_input(struct ps2if *ps2if)
194 {
195 	int maxread = 100;
196 
197 	while (maxread--) {
198 		if ((readl_relaxed(ps2if->base + PS2DATA) & 0xff) == 0xff)
199 			break;
200 	}
201 }
202 
203 static unsigned int ps2_test_one(struct ps2if *ps2if,
204 					   unsigned int mask)
205 {
206 	unsigned int val;
207 
208 	writel_relaxed(PS2CR_ENA | mask, ps2if->base + PS2CR);
209 
210 	udelay(10);
211 
212 	val = readl_relaxed(ps2if->base + PS2STAT);
213 	return val & (PS2STAT_KBC | PS2STAT_KBD);
214 }
215 
216 /*
217  * Test the keyboard interface.  We basically check to make sure that
218  * we can drive each line to the keyboard independently of each other.
219  */
220 static int ps2_test(struct ps2if *ps2if)
221 {
222 	unsigned int stat;
223 	int ret = 0;
224 
225 	stat = ps2_test_one(ps2if, PS2CR_FKC);
226 	if (stat != PS2STAT_KBD) {
227 		printk("PS/2 interface test failed[1]: %02x\n", stat);
228 		ret = -ENODEV;
229 	}
230 
231 	stat = ps2_test_one(ps2if, 0);
232 	if (stat != (PS2STAT_KBC | PS2STAT_KBD)) {
233 		printk("PS/2 interface test failed[2]: %02x\n", stat);
234 		ret = -ENODEV;
235 	}
236 
237 	stat = ps2_test_one(ps2if, PS2CR_FKD);
238 	if (stat != PS2STAT_KBC) {
239 		printk("PS/2 interface test failed[3]: %02x\n", stat);
240 		ret = -ENODEV;
241 	}
242 
243 	writel_relaxed(0, ps2if->base + PS2CR);
244 
245 	return ret;
246 }
247 
248 /*
249  * Add one device to this driver.
250  */
251 static int ps2_probe(struct sa1111_dev *dev)
252 {
253 	struct ps2if *ps2if;
254 	struct serio *serio;
255 	int ret;
256 
257 	ps2if = kzalloc(sizeof(*ps2if), GFP_KERNEL);
258 	serio = kzalloc(sizeof(*serio), GFP_KERNEL);
259 	if (!ps2if || !serio) {
260 		ret = -ENOMEM;
261 		goto free;
262 	}
263 
264 	serio->id.type		= SERIO_8042;
265 	serio->write		= ps2_write;
266 	serio->open		= ps2_open;
267 	serio->close		= ps2_close;
268 	strscpy(serio->name, dev_name(&dev->dev), sizeof(serio->name));
269 	strscpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys));
270 	serio->port_data	= ps2if;
271 	serio->dev.parent	= &dev->dev;
272 	ps2if->io		= serio;
273 	ps2if->dev		= dev;
274 	sa1111_set_drvdata(dev, ps2if);
275 
276 	spin_lock_init(&ps2if->lock);
277 
278 	ps2if->rx_irq = sa1111_get_irq(dev, 0);
279 	if (ps2if->rx_irq <= 0) {
280 		ret = ps2if->rx_irq ? : -ENXIO;
281 		goto free;
282 	}
283 
284 	ps2if->tx_irq = sa1111_get_irq(dev, 1);
285 	if (ps2if->tx_irq <= 0) {
286 		ret = ps2if->tx_irq ? : -ENXIO;
287 		goto free;
288 	}
289 
290 	/*
291 	 * Request the physical region for this PS2 port.
292 	 */
293 	if (!request_mem_region(dev->res.start,
294 				dev->res.end - dev->res.start + 1,
295 				SA1111_DRIVER_NAME(dev))) {
296 		ret = -EBUSY;
297 		goto free;
298 	}
299 
300 	/*
301 	 * Our parent device has already mapped the region.
302 	 */
303 	ps2if->base = dev->mapbase;
304 
305 	sa1111_enable_device(ps2if->dev);
306 
307 	/* Incoming clock is 8MHz */
308 	writel_relaxed(0, ps2if->base + PS2CLKDIV);
309 	writel_relaxed(127, ps2if->base + PS2PRECNT);
310 
311 	/*
312 	 * Flush any pending input.
313 	 */
314 	ps2_clear_input(ps2if);
315 
316 	/*
317 	 * Test the keyboard interface.
318 	 */
319 	ret = ps2_test(ps2if);
320 	if (ret)
321 		goto out;
322 
323 	/*
324 	 * Flush any pending input.
325 	 */
326 	ps2_clear_input(ps2if);
327 
328 	sa1111_disable_device(ps2if->dev);
329 	serio_register_port(ps2if->io);
330 	return 0;
331 
332  out:
333 	sa1111_disable_device(ps2if->dev);
334 	release_mem_region(dev->res.start, resource_size(&dev->res));
335  free:
336 	sa1111_set_drvdata(dev, NULL);
337 	kfree(ps2if);
338 	kfree(serio);
339 	return ret;
340 }
341 
342 /*
343  * Remove one device from this driver.
344  */
345 static void ps2_remove(struct sa1111_dev *dev)
346 {
347 	struct ps2if *ps2if = sa1111_get_drvdata(dev);
348 
349 	serio_unregister_port(ps2if->io);
350 	release_mem_region(dev->res.start, resource_size(&dev->res));
351 	sa1111_set_drvdata(dev, NULL);
352 
353 	kfree(ps2if);
354 }
355 
356 /*
357  * Our device driver structure
358  */
359 static struct sa1111_driver ps2_driver = {
360 	.drv = {
361 		.name	= "sa1111-ps2",
362 		.owner	= THIS_MODULE,
363 	},
364 	.devid		= SA1111_DEVID_PS2,
365 	.probe		= ps2_probe,
366 	.remove		= ps2_remove,
367 };
368 
369 static int __init ps2_init(void)
370 {
371 	return sa1111_driver_register(&ps2_driver);
372 }
373 
374 static void __exit ps2_exit(void)
375 {
376 	sa1111_driver_unregister(&ps2_driver);
377 }
378 
379 module_init(ps2_init);
380 module_exit(ps2_exit);
381 
382 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
383 MODULE_DESCRIPTION("SA1111 PS2 controller driver");
384 MODULE_LICENSE("GPL");
385