]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/drivers/input/serio/ambakmi.c | |
3 | * | |
4 | * Copyright (C) 2000-2003 Deep Blue Solutions Ltd. | |
5 | * Copyright (C) 2002 Russell King. | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | */ | |
12 | #include <linux/module.h> | |
13 | #include <linux/init.h> | |
14 | #include <linux/serio.h> | |
15 | #include <linux/errno.h> | |
16 | #include <linux/interrupt.h> | |
17 | #include <linux/ioport.h> | |
18 | #include <linux/device.h> | |
19 | #include <linux/delay.h> | |
20 | #include <linux/slab.h> | |
21 | #include <linux/err.h> | |
a62c80e5 RK |
22 | #include <linux/amba/bus.h> |
23 | #include <linux/amba/kmi.h> | |
f8ce2547 | 24 | #include <linux/clk.h> |
1da177e4 LT |
25 | |
26 | #include <asm/io.h> | |
27 | #include <asm/irq.h> | |
1da177e4 LT |
28 | |
29 | #define KMI_BASE (kmi->base) | |
30 | ||
31 | struct amba_kmi_port { | |
32 | struct serio *io; | |
33 | struct clk *clk; | |
34 | void __iomem *base; | |
35 | unsigned int irq; | |
36 | unsigned int divisor; | |
37 | unsigned int open; | |
38 | }; | |
39 | ||
7d12e780 | 40 | static irqreturn_t amba_kmi_int(int irq, void *dev_id) |
1da177e4 LT |
41 | { |
42 | struct amba_kmi_port *kmi = dev_id; | |
43 | unsigned int status = readb(KMIIR); | |
44 | int handled = IRQ_NONE; | |
45 | ||
46 | while (status & KMIIR_RXINTR) { | |
7d12e780 | 47 | serio_interrupt(kmi->io, readb(KMIDATA), 0); |
1da177e4 LT |
48 | status = readb(KMIIR); |
49 | handled = IRQ_HANDLED; | |
50 | } | |
51 | ||
52 | return handled; | |
53 | } | |
54 | ||
55 | static int amba_kmi_write(struct serio *io, unsigned char val) | |
56 | { | |
57 | struct amba_kmi_port *kmi = io->port_data; | |
58 | unsigned int timeleft = 10000; /* timeout in 100ms */ | |
59 | ||
60 | while ((readb(KMISTAT) & KMISTAT_TXEMPTY) == 0 && timeleft--) | |
61 | udelay(10); | |
62 | ||
63 | if (timeleft) | |
64 | writeb(val, KMIDATA); | |
65 | ||
66 | return timeleft ? 0 : SERIO_TIMEOUT; | |
67 | } | |
68 | ||
69 | static int amba_kmi_open(struct serio *io) | |
70 | { | |
71 | struct amba_kmi_port *kmi = io->port_data; | |
72 | unsigned int divisor; | |
73 | int ret; | |
74 | ||
1da177e4 LT |
75 | ret = clk_enable(kmi->clk); |
76 | if (ret) | |
a8d3584a | 77 | goto out; |
1da177e4 LT |
78 | |
79 | divisor = clk_get_rate(kmi->clk) / 8000000 - 1; | |
80 | writeb(divisor, KMICLKDIV); | |
81 | writeb(KMICR_EN, KMICR); | |
82 | ||
83 | ret = request_irq(kmi->irq, amba_kmi_int, 0, "kmi-pl050", kmi); | |
84 | if (ret) { | |
85 | printk(KERN_ERR "kmi: failed to claim IRQ%d\n", kmi->irq); | |
86 | writeb(0, KMICR); | |
87 | goto clk_disable; | |
88 | } | |
89 | ||
90 | writeb(KMICR_EN | KMICR_RXINTREN, KMICR); | |
91 | ||
92 | return 0; | |
93 | ||
94 | clk_disable: | |
95 | clk_disable(kmi->clk); | |
1da177e4 LT |
96 | out: |
97 | return ret; | |
98 | } | |
99 | ||
100 | static void amba_kmi_close(struct serio *io) | |
101 | { | |
102 | struct amba_kmi_port *kmi = io->port_data; | |
103 | ||
104 | writeb(0, KMICR); | |
105 | ||
106 | free_irq(kmi->irq, kmi); | |
107 | clk_disable(kmi->clk); | |
1da177e4 LT |
108 | } |
109 | ||
110 | static int amba_kmi_probe(struct amba_device *dev, void *id) | |
111 | { | |
112 | struct amba_kmi_port *kmi; | |
113 | struct serio *io; | |
114 | int ret; | |
115 | ||
116 | ret = amba_request_regions(dev, NULL); | |
117 | if (ret) | |
118 | return ret; | |
119 | ||
120 | kmi = kmalloc(sizeof(struct amba_kmi_port), GFP_KERNEL); | |
121 | io = kmalloc(sizeof(struct serio), GFP_KERNEL); | |
122 | if (!kmi || !io) { | |
123 | ret = -ENOMEM; | |
124 | goto out; | |
125 | } | |
126 | ||
127 | memset(kmi, 0, sizeof(struct amba_kmi_port)); | |
128 | memset(io, 0, sizeof(struct serio)); | |
129 | ||
130 | io->id.type = SERIO_8042; | |
131 | io->write = amba_kmi_write; | |
132 | io->open = amba_kmi_open; | |
133 | io->close = amba_kmi_close; | |
134 | strlcpy(io->name, dev->dev.bus_id, sizeof(io->name)); | |
135 | strlcpy(io->phys, dev->dev.bus_id, sizeof(io->phys)); | |
136 | io->port_data = kmi; | |
137 | io->dev.parent = &dev->dev; | |
138 | ||
139 | kmi->io = io; | |
140 | kmi->base = ioremap(dev->res.start, KMI_SIZE); | |
141 | if (!kmi->base) { | |
142 | ret = -ENOMEM; | |
143 | goto out; | |
144 | } | |
145 | ||
146 | kmi->clk = clk_get(&dev->dev, "KMIREFCLK"); | |
147 | if (IS_ERR(kmi->clk)) { | |
148 | ret = PTR_ERR(kmi->clk); | |
149 | goto unmap; | |
150 | } | |
151 | ||
152 | kmi->irq = dev->irq[0]; | |
153 | amba_set_drvdata(dev, kmi); | |
154 | ||
155 | serio_register_port(kmi->io); | |
156 | return 0; | |
157 | ||
158 | unmap: | |
159 | iounmap(kmi->base); | |
160 | out: | |
161 | kfree(kmi); | |
162 | kfree(io); | |
163 | amba_release_regions(dev); | |
164 | return ret; | |
165 | } | |
166 | ||
167 | static int amba_kmi_remove(struct amba_device *dev) | |
168 | { | |
169 | struct amba_kmi_port *kmi = amba_get_drvdata(dev); | |
170 | ||
171 | amba_set_drvdata(dev, NULL); | |
172 | ||
173 | serio_unregister_port(kmi->io); | |
174 | clk_put(kmi->clk); | |
175 | iounmap(kmi->base); | |
176 | kfree(kmi); | |
177 | amba_release_regions(dev); | |
178 | return 0; | |
179 | } | |
180 | ||
181 | static int amba_kmi_resume(struct amba_device *dev) | |
182 | { | |
183 | struct amba_kmi_port *kmi = amba_get_drvdata(dev); | |
184 | ||
185 | /* kick the serio layer to rescan this port */ | |
186 | serio_reconnect(kmi->io); | |
187 | ||
188 | return 0; | |
189 | } | |
190 | ||
191 | static struct amba_id amba_kmi_idtable[] = { | |
192 | { | |
193 | .id = 0x00041050, | |
194 | .mask = 0x000fffff, | |
195 | }, | |
196 | { 0, 0 } | |
197 | }; | |
198 | ||
199 | static struct amba_driver ambakmi_driver = { | |
200 | .drv = { | |
201 | .name = "kmi-pl050", | |
202 | }, | |
203 | .id_table = amba_kmi_idtable, | |
204 | .probe = amba_kmi_probe, | |
205 | .remove = amba_kmi_remove, | |
206 | .resume = amba_kmi_resume, | |
207 | }; | |
208 | ||
209 | static int __init amba_kmi_init(void) | |
210 | { | |
211 | return amba_driver_register(&ambakmi_driver); | |
212 | } | |
213 | ||
214 | static void __exit amba_kmi_exit(void) | |
215 | { | |
216 | amba_driver_unregister(&ambakmi_driver); | |
217 | } | |
218 | ||
219 | module_init(amba_kmi_init); | |
220 | module_exit(amba_kmi_exit); | |
221 | ||
222 | MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); | |
223 | MODULE_DESCRIPTION("AMBA KMI controller driver"); | |
224 | MODULE_LICENSE("GPL"); |