2 * linux/drivers/input/serio/sa1111ps2.c
4 * Copyright (C) 2002 Russell King
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License.
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/input.h>
13 #include <linux/serio.h>
14 #include <linux/errno.h>
15 #include <linux/interrupt.h>
16 #include <linux/ioport.h>
17 #include <linux/delay.h>
18 #include <linux/device.h>
19 #include <linux/slab.h>
20 #include <linux/spinlock.h>
24 #include <asm/hardware/sa1111.h>
27 #define PS2STAT 0x0004
28 #define PS2DATA 0x0008
29 #define PS2CLKDIV 0x000c
30 #define PS2PRECNT 0x0010
32 #define PS2CR_ENA 0x08
33 #define PS2CR_FKD 0x02
34 #define PS2CR_FKC 0x01
36 #define PS2STAT_STP 0x0100
37 #define PS2STAT_TXE 0x0080
38 #define PS2STAT_TXB 0x0040
39 #define PS2STAT_RXF 0x0020
40 #define PS2STAT_RXB 0x0010
41 #define PS2STAT_ENA 0x0008
42 #define PS2STAT_RXP 0x0004
43 #define PS2STAT_KBD 0x0002
44 #define PS2STAT_KBC 0x0001
48 struct sa1111_dev *dev;
60 * Read all bytes waiting in the PS2 port. There should be
61 * at the most one, but we loop for safety. If there was a
62 * framing error, we have to manually clear the status.
64 static irqreturn_t ps2_rxint(int irq, void *dev_id)
66 struct ps2if *ps2if = dev_id;
67 unsigned int scancode, flag, status;
69 status = readl_relaxed(ps2if->base + PS2STAT);
70 while (status & PS2STAT_RXF) {
71 if (status & PS2STAT_STP)
72 writel_relaxed(PS2STAT_STP, ps2if->base + PS2STAT);
74 flag = (status & PS2STAT_STP ? SERIO_FRAME : 0) |
75 (status & PS2STAT_RXP ? 0 : SERIO_PARITY);
77 scancode = readl_relaxed(ps2if->base + PS2DATA) & 0xff;
79 if (hweight8(scancode) & 1)
82 serio_interrupt(ps2if->io, scancode, flag);
84 status = readl_relaxed(ps2if->base + PS2STAT);
91 * Completion of ps2 write
93 static irqreturn_t ps2_txint(int irq, void *dev_id)
95 struct ps2if *ps2if = dev_id;
98 spin_lock(&ps2if->lock);
99 status = readl_relaxed(ps2if->base + PS2STAT);
100 if (ps2if->head == ps2if->tail) {
101 disable_irq_nosync(irq);
103 } else if (status & PS2STAT_TXE) {
104 writel_relaxed(ps2if->buf[ps2if->tail], ps2if->base + PS2DATA);
105 ps2if->tail = (ps2if->tail + 1) & (sizeof(ps2if->buf) - 1);
107 spin_unlock(&ps2if->lock);
113 * Write a byte to the PS2 port. We have to wait for the
114 * port to indicate that the transmitter is empty.
116 static int ps2_write(struct serio *io, unsigned char val)
118 struct ps2if *ps2if = io->port_data;
122 spin_lock_irqsave(&ps2if->lock, flags);
125 * If the TX register is empty, we can go straight out.
127 if (readl_relaxed(ps2if->base + PS2STAT) & PS2STAT_TXE) {
128 writel_relaxed(val, ps2if->base + PS2DATA);
130 if (ps2if->head == ps2if->tail)
131 enable_irq(ps2if->tx_irq);
132 head = (ps2if->head + 1) & (sizeof(ps2if->buf) - 1);
133 if (head != ps2if->tail) {
134 ps2if->buf[ps2if->head] = val;
139 spin_unlock_irqrestore(&ps2if->lock, flags);
143 static int ps2_open(struct serio *io)
145 struct ps2if *ps2if = io->port_data;
148 ret = sa1111_enable_device(ps2if->dev);
152 ret = request_irq(ps2if->rx_irq, ps2_rxint, 0,
153 SA1111_DRIVER_NAME(ps2if->dev), ps2if);
155 printk(KERN_ERR "sa1111ps2: could not allocate IRQ%d: %d\n",
157 sa1111_disable_device(ps2if->dev);
161 ret = request_irq(ps2if->tx_irq, ps2_txint, 0,
162 SA1111_DRIVER_NAME(ps2if->dev), ps2if);
164 printk(KERN_ERR "sa1111ps2: could not allocate IRQ%d: %d\n",
166 free_irq(ps2if->rx_irq, ps2if);
167 sa1111_disable_device(ps2if->dev);
173 enable_irq_wake(ps2if->rx_irq);
175 writel_relaxed(PS2CR_ENA, ps2if->base + PS2CR);
179 static void ps2_close(struct serio *io)
181 struct ps2if *ps2if = io->port_data;
183 writel_relaxed(0, ps2if->base + PS2CR);
185 disable_irq_wake(ps2if->rx_irq);
189 free_irq(ps2if->tx_irq, ps2if);
190 free_irq(ps2if->rx_irq, ps2if);
192 sa1111_disable_device(ps2if->dev);
196 * Clear the input buffer.
198 static void ps2_clear_input(struct ps2if *ps2if)
203 if ((readl_relaxed(ps2if->base + PS2DATA) & 0xff) == 0xff)
208 static unsigned int ps2_test_one(struct ps2if *ps2if,
213 writel_relaxed(PS2CR_ENA | mask, ps2if->base + PS2CR);
217 val = readl_relaxed(ps2if->base + PS2STAT);
218 return val & (PS2STAT_KBC | PS2STAT_KBD);
222 * Test the keyboard interface. We basically check to make sure that
223 * we can drive each line to the keyboard independently of each other.
225 static int ps2_test(struct ps2if *ps2if)
230 stat = ps2_test_one(ps2if, PS2CR_FKC);
231 if (stat != PS2STAT_KBD) {
232 printk("PS/2 interface test failed[1]: %02x\n", stat);
236 stat = ps2_test_one(ps2if, 0);
237 if (stat != (PS2STAT_KBC | PS2STAT_KBD)) {
238 printk("PS/2 interface test failed[2]: %02x\n", stat);
242 stat = ps2_test_one(ps2if, PS2CR_FKD);
243 if (stat != PS2STAT_KBC) {
244 printk("PS/2 interface test failed[3]: %02x\n", stat);
248 writel_relaxed(0, ps2if->base + PS2CR);
254 * Add one device to this driver.
256 static int ps2_probe(struct sa1111_dev *dev)
262 ps2if = kzalloc(sizeof(struct ps2if), GFP_KERNEL);
263 serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
264 if (!ps2if || !serio) {
269 serio->id.type = SERIO_8042;
270 serio->write = ps2_write;
271 serio->open = ps2_open;
272 serio->close = ps2_close;
273 strlcpy(serio->name, dev_name(&dev->dev), sizeof(serio->name));
274 strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys));
275 serio->port_data = ps2if;
276 serio->dev.parent = &dev->dev;
279 sa1111_set_drvdata(dev, ps2if);
281 spin_lock_init(&ps2if->lock);
283 ps2if->rx_irq = sa1111_get_irq(dev, 0);
284 if (ps2if->rx_irq <= 0) {
285 ret = ps2if->rx_irq ? : -ENXIO;
289 ps2if->tx_irq = sa1111_get_irq(dev, 1);
290 if (ps2if->tx_irq <= 0) {
291 ret = ps2if->tx_irq ? : -ENXIO;
296 * Request the physical region for this PS2 port.
298 if (!request_mem_region(dev->res.start,
299 dev->res.end - dev->res.start + 1,
300 SA1111_DRIVER_NAME(dev))) {
306 * Our parent device has already mapped the region.
308 ps2if->base = dev->mapbase;
310 sa1111_enable_device(ps2if->dev);
312 /* Incoming clock is 8MHz */
313 writel_relaxed(0, ps2if->base + PS2CLKDIV);
314 writel_relaxed(127, ps2if->base + PS2PRECNT);
317 * Flush any pending input.
319 ps2_clear_input(ps2if);
322 * Test the keyboard interface.
324 ret = ps2_test(ps2if);
329 * Flush any pending input.
331 ps2_clear_input(ps2if);
333 sa1111_disable_device(ps2if->dev);
334 serio_register_port(ps2if->io);
338 sa1111_disable_device(ps2if->dev);
339 release_mem_region(dev->res.start, resource_size(&dev->res));
341 sa1111_set_drvdata(dev, NULL);
348 * Remove one device from this driver.
350 static int ps2_remove(struct sa1111_dev *dev)
352 struct ps2if *ps2if = sa1111_get_drvdata(dev);
354 serio_unregister_port(ps2if->io);
355 release_mem_region(dev->res.start, resource_size(&dev->res));
356 sa1111_set_drvdata(dev, NULL);
364 * Our device driver structure
366 static struct sa1111_driver ps2_driver = {
368 .name = "sa1111-ps2",
369 .owner = THIS_MODULE,
371 .devid = SA1111_DEVID_PS2,
373 .remove = ps2_remove,
376 static int __init ps2_init(void)
378 return sa1111_driver_register(&ps2_driver);
381 static void __exit ps2_exit(void)
383 sa1111_driver_unregister(&ps2_driver);
386 module_init(ps2_init);
387 module_exit(ps2_exit);
389 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
390 MODULE_DESCRIPTION("SA1111 PS2 controller driver");
391 MODULE_LICENSE("GPL");