]>
Commit | Line | Data |
---|---|---|
bc95df78 RK |
1 | /* |
2 | * SPEAr Keyboard Driver | |
3 | * Based on omap-keypad driver | |
4 | * | |
5 | * Copyright (C) 2010 ST Microelectronics | |
6 | * Rajeev Kumar<rajeev-dlh.kumar@st.com> | |
7 | * | |
8 | * This file is licensed under the terms of the GNU General Public | |
9 | * License version 2. This program is licensed "as is" without any | |
10 | * warranty of any kind, whether express or implied. | |
11 | */ | |
12 | ||
13 | #include <linux/clk.h> | |
14 | #include <linux/errno.h> | |
15 | #include <linux/init.h> | |
16 | #include <linux/interrupt.h> | |
17 | #include <linux/input.h> | |
18 | #include <linux/io.h> | |
19 | #include <linux/irq.h> | |
20 | #include <linux/kernel.h> | |
21 | #include <linux/module.h> | |
22 | #include <linux/platform_device.h> | |
23 | #include <linux/pm_wakeup.h> | |
24 | #include <linux/slab.h> | |
25 | #include <linux/types.h> | |
26 | #include <plat/keyboard.h> | |
27 | ||
28 | /* Keyboard Registers */ | |
29 | #define MODE_REG 0x00 /* 16 bit reg */ | |
30 | #define STATUS_REG 0x0C /* 2 bit reg */ | |
31 | #define DATA_REG 0x10 /* 8 bit reg */ | |
32 | #define INTR_MASK 0x54 | |
33 | ||
34 | /* Register Values */ | |
35 | /* | |
36 | * pclk freq mask = (APB FEQ -1)= 82 MHZ.Programme bit 15-9 in mode | |
37 | * control register as 1010010(82MHZ) | |
38 | */ | |
39 | #define PCLK_FREQ_MSK 0xA400 /* 82 MHz */ | |
40 | #define START_SCAN 0x0100 | |
41 | #define SCAN_RATE_10 0x0000 | |
42 | #define SCAN_RATE_20 0x0004 | |
43 | #define SCAN_RATE_40 0x0008 | |
44 | #define SCAN_RATE_80 0x000C | |
45 | #define MODE_KEYBOARD 0x0002 | |
46 | #define DATA_AVAIL 0x2 | |
47 | ||
48 | #define KEY_MASK 0xFF000000 | |
49 | #define KEY_VALUE 0x00FFFFFF | |
50 | #define ROW_MASK 0xF0 | |
51 | #define COLUMN_MASK 0x0F | |
52 | #define ROW_SHIFT 4 | |
f8354c60 | 53 | #define KEY_MATRIX_SHIFT 6 |
bc95df78 RK |
54 | |
55 | struct spear_kbd { | |
56 | struct input_dev *input; | |
57 | struct resource *res; | |
58 | void __iomem *io_base; | |
59 | struct clk *clk; | |
60 | unsigned int irq; | |
f8354c60 | 61 | unsigned int mode; |
bc95df78 RK |
62 | unsigned short last_key; |
63 | unsigned short keycodes[256]; | |
64 | }; | |
65 | ||
66 | static irqreturn_t spear_kbd_interrupt(int irq, void *dev_id) | |
67 | { | |
68 | struct spear_kbd *kbd = dev_id; | |
69 | struct input_dev *input = kbd->input; | |
70 | unsigned int key; | |
71 | u8 sts, val; | |
72 | ||
73 | sts = readb(kbd->io_base + STATUS_REG); | |
799a2a21 | 74 | if (!(sts & DATA_AVAIL)) |
bc95df78 RK |
75 | return IRQ_NONE; |
76 | ||
77 | if (kbd->last_key != KEY_RESERVED) { | |
78 | input_report_key(input, kbd->last_key, 0); | |
79 | kbd->last_key = KEY_RESERVED; | |
80 | } | |
81 | ||
82 | /* following reads active (row, col) pair */ | |
83 | val = readb(kbd->io_base + DATA_REG); | |
84 | key = kbd->keycodes[val]; | |
85 | ||
86 | input_event(input, EV_MSC, MSC_SCAN, val); | |
87 | input_report_key(input, key, 1); | |
88 | input_sync(input); | |
89 | ||
90 | kbd->last_key = key; | |
91 | ||
92 | /* clear interrupt */ | |
93 | writeb(0, kbd->io_base + STATUS_REG); | |
94 | ||
95 | return IRQ_HANDLED; | |
96 | } | |
97 | ||
98 | static int spear_kbd_open(struct input_dev *dev) | |
99 | { | |
100 | struct spear_kbd *kbd = input_get_drvdata(dev); | |
101 | int error; | |
102 | u16 val; | |
103 | ||
104 | kbd->last_key = KEY_RESERVED; | |
105 | ||
106 | error = clk_enable(kbd->clk); | |
107 | if (error) | |
108 | return error; | |
109 | ||
110 | /* program keyboard */ | |
f8354c60 RK |
111 | val = SCAN_RATE_80 | MODE_KEYBOARD | PCLK_FREQ_MSK | |
112 | (kbd->mode << KEY_MATRIX_SHIFT); | |
bc95df78 RK |
113 | writew(val, kbd->io_base + MODE_REG); |
114 | writeb(1, kbd->io_base + STATUS_REG); | |
115 | ||
116 | /* start key scan */ | |
117 | val = readw(kbd->io_base + MODE_REG); | |
118 | val |= START_SCAN; | |
119 | writew(val, kbd->io_base + MODE_REG); | |
120 | ||
121 | return 0; | |
122 | } | |
123 | ||
124 | static void spear_kbd_close(struct input_dev *dev) | |
125 | { | |
126 | struct spear_kbd *kbd = input_get_drvdata(dev); | |
127 | u16 val; | |
128 | ||
129 | /* stop key scan */ | |
130 | val = readw(kbd->io_base + MODE_REG); | |
131 | val &= ~START_SCAN; | |
132 | writew(val, kbd->io_base + MODE_REG); | |
133 | ||
134 | clk_disable(kbd->clk); | |
135 | ||
136 | kbd->last_key = KEY_RESERVED; | |
137 | } | |
138 | ||
139 | static int __devinit spear_kbd_probe(struct platform_device *pdev) | |
140 | { | |
141 | const struct kbd_platform_data *pdata = pdev->dev.platform_data; | |
142 | const struct matrix_keymap_data *keymap; | |
143 | struct spear_kbd *kbd; | |
144 | struct input_dev *input_dev; | |
145 | struct resource *res; | |
146 | int irq; | |
147 | int error; | |
148 | ||
149 | if (!pdata) { | |
150 | dev_err(&pdev->dev, "Invalid platform data\n"); | |
151 | return -EINVAL; | |
152 | } | |
153 | ||
154 | keymap = pdata->keymap; | |
155 | if (!keymap) { | |
156 | dev_err(&pdev->dev, "no keymap defined\n"); | |
157 | return -EINVAL; | |
158 | } | |
159 | ||
160 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
161 | if (!res) { | |
162 | dev_err(&pdev->dev, "no keyboard resource defined\n"); | |
163 | return -EBUSY; | |
164 | } | |
165 | ||
166 | irq = platform_get_irq(pdev, 0); | |
167 | if (irq < 0) { | |
168 | dev_err(&pdev->dev, "not able to get irq for the device\n"); | |
169 | return irq; | |
170 | } | |
171 | ||
172 | kbd = kzalloc(sizeof(*kbd), GFP_KERNEL); | |
173 | input_dev = input_allocate_device(); | |
174 | if (!kbd || !input_dev) { | |
175 | dev_err(&pdev->dev, "out of memory\n"); | |
176 | error = -ENOMEM; | |
177 | goto err_free_mem; | |
178 | } | |
179 | ||
180 | kbd->input = input_dev; | |
181 | kbd->irq = irq; | |
f8354c60 RK |
182 | kbd->mode = pdata->mode; |
183 | ||
bc95df78 RK |
184 | kbd->res = request_mem_region(res->start, resource_size(res), |
185 | pdev->name); | |
186 | if (!kbd->res) { | |
187 | dev_err(&pdev->dev, "keyboard region already claimed\n"); | |
188 | error = -EBUSY; | |
189 | goto err_free_mem; | |
190 | } | |
191 | ||
192 | kbd->io_base = ioremap(res->start, resource_size(res)); | |
193 | if (!kbd->io_base) { | |
194 | dev_err(&pdev->dev, "ioremap failed for kbd_region\n"); | |
195 | error = -ENOMEM; | |
196 | goto err_release_mem_region; | |
197 | } | |
198 | ||
199 | kbd->clk = clk_get(&pdev->dev, NULL); | |
200 | if (IS_ERR(kbd->clk)) { | |
201 | error = PTR_ERR(kbd->clk); | |
202 | goto err_iounmap; | |
203 | } | |
204 | ||
205 | input_dev->name = "Spear Keyboard"; | |
206 | input_dev->phys = "keyboard/input0"; | |
207 | input_dev->dev.parent = &pdev->dev; | |
208 | input_dev->id.bustype = BUS_HOST; | |
209 | input_dev->id.vendor = 0x0001; | |
210 | input_dev->id.product = 0x0001; | |
211 | input_dev->id.version = 0x0100; | |
212 | input_dev->open = spear_kbd_open; | |
213 | input_dev->close = spear_kbd_close; | |
214 | ||
215 | __set_bit(EV_KEY, input_dev->evbit); | |
216 | if (pdata->rep) | |
217 | __set_bit(EV_REP, input_dev->evbit); | |
218 | input_set_capability(input_dev, EV_MSC, MSC_SCAN); | |
219 | ||
220 | input_dev->keycode = kbd->keycodes; | |
221 | input_dev->keycodesize = sizeof(kbd->keycodes[0]); | |
222 | input_dev->keycodemax = ARRAY_SIZE(kbd->keycodes); | |
223 | ||
224 | matrix_keypad_build_keymap(keymap, ROW_SHIFT, | |
225 | input_dev->keycode, input_dev->keybit); | |
226 | ||
227 | input_set_drvdata(input_dev, kbd); | |
228 | ||
229 | error = request_irq(irq, spear_kbd_interrupt, 0, "keyboard", kbd); | |
230 | if (error) { | |
231 | dev_err(&pdev->dev, "request_irq fail\n"); | |
232 | goto err_put_clk; | |
233 | } | |
234 | ||
235 | error = input_register_device(input_dev); | |
236 | if (error) { | |
237 | dev_err(&pdev->dev, "Unable to register keyboard device\n"); | |
238 | goto err_free_irq; | |
239 | } | |
240 | ||
241 | device_init_wakeup(&pdev->dev, 1); | |
242 | platform_set_drvdata(pdev, kbd); | |
243 | ||
244 | return 0; | |
245 | ||
246 | err_free_irq: | |
247 | free_irq(kbd->irq, kbd); | |
248 | err_put_clk: | |
249 | clk_put(kbd->clk); | |
250 | err_iounmap: | |
251 | iounmap(kbd->io_base); | |
252 | err_release_mem_region: | |
253 | release_mem_region(res->start, resource_size(res)); | |
254 | err_free_mem: | |
255 | input_free_device(input_dev); | |
256 | kfree(kbd); | |
257 | ||
258 | return error; | |
259 | } | |
260 | ||
261 | static int __devexit spear_kbd_remove(struct platform_device *pdev) | |
262 | { | |
263 | struct spear_kbd *kbd = platform_get_drvdata(pdev); | |
264 | ||
265 | free_irq(kbd->irq, kbd); | |
266 | input_unregister_device(kbd->input); | |
267 | clk_put(kbd->clk); | |
268 | iounmap(kbd->io_base); | |
269 | release_mem_region(kbd->res->start, resource_size(kbd->res)); | |
270 | kfree(kbd); | |
271 | ||
272 | device_init_wakeup(&pdev->dev, 1); | |
273 | platform_set_drvdata(pdev, NULL); | |
274 | ||
275 | return 0; | |
276 | } | |
277 | ||
278 | #ifdef CONFIG_PM | |
279 | static int spear_kbd_suspend(struct device *dev) | |
280 | { | |
281 | struct platform_device *pdev = to_platform_device(dev); | |
282 | struct spear_kbd *kbd = platform_get_drvdata(pdev); | |
283 | struct input_dev *input_dev = kbd->input; | |
284 | ||
285 | mutex_lock(&input_dev->mutex); | |
286 | ||
287 | if (input_dev->users) | |
288 | clk_enable(kbd->clk); | |
289 | ||
290 | if (device_may_wakeup(&pdev->dev)) | |
291 | enable_irq_wake(kbd->irq); | |
292 | ||
293 | mutex_unlock(&input_dev->mutex); | |
294 | ||
295 | return 0; | |
296 | } | |
297 | ||
298 | static int spear_kbd_resume(struct device *dev) | |
299 | { | |
300 | struct platform_device *pdev = to_platform_device(dev); | |
301 | struct spear_kbd *kbd = platform_get_drvdata(pdev); | |
302 | struct input_dev *input_dev = kbd->input; | |
303 | ||
304 | mutex_lock(&input_dev->mutex); | |
305 | ||
306 | if (device_may_wakeup(&pdev->dev)) | |
307 | disable_irq_wake(kbd->irq); | |
308 | ||
309 | if (input_dev->users) | |
310 | clk_enable(kbd->clk); | |
311 | ||
312 | mutex_unlock(&input_dev->mutex); | |
313 | ||
314 | return 0; | |
315 | } | |
bc95df78 RK |
316 | #endif |
317 | ||
f79e30a8 VK |
318 | static SIMPLE_DEV_PM_OPS(spear_kbd_pm_ops, spear_kbd_suspend, spear_kbd_resume); |
319 | ||
bc95df78 RK |
320 | static struct platform_driver spear_kbd_driver = { |
321 | .probe = spear_kbd_probe, | |
322 | .remove = __devexit_p(spear_kbd_remove), | |
323 | .driver = { | |
324 | .name = "keyboard", | |
325 | .owner = THIS_MODULE, | |
bc95df78 | 326 | .pm = &spear_kbd_pm_ops, |
bc95df78 RK |
327 | }, |
328 | }; | |
5146c84f | 329 | module_platform_driver(spear_kbd_driver); |
bc95df78 RK |
330 | |
331 | MODULE_AUTHOR("Rajeev Kumar"); | |
332 | MODULE_DESCRIPTION("SPEAr Keyboard Driver"); | |
333 | MODULE_LICENSE("GPL"); |