blob: d427f322e2079635ab8dbfca89e2b17e5af78b06 [file] [log] [blame]
Michael Hennerich8f740ef2007-10-13 00:36:46 -04001/*
2 * File: drivers/input/keyboard/bf54x-keys.c
3 * Based on:
4 * Author: Michael Hennerich <hennerich@blackfin.uclinux.org>
5 *
6 * Created:
7 * Description: keypad driver for Analog Devices Blackfin BF54x Processors
8 *
9 *
10 * Modified:
Michael Hennerich108fcb42008-08-15 13:53:08 -040011 * Copyright 2007-2008 Analog Devices Inc.
Michael Hennerich8f740ef2007-10-13 00:36:46 -040012 *
13 * Bugs: Enter bugs at http://blackfin.uclinux.org/
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, see the file COPYING, or write
27 * to the Free Software Foundation, Inc.,
28 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
29 */
30
31#include <linux/module.h>
Michael Hennerich8f740ef2007-10-13 00:36:46 -040032
33#include <linux/init.h>
34#include <linux/fs.h>
35#include <linux/interrupt.h>
36#include <linux/irq.h>
37#include <linux/sched.h>
38#include <linux/pm.h>
39#include <linux/sysctl.h>
40#include <linux/proc_fs.h>
41#include <linux/delay.h>
42#include <linux/platform_device.h>
43#include <linux/input.h>
Michael Hennerich8f740ef2007-10-13 00:36:46 -040044
45#include <asm/portmux.h>
Bryan Wu639f6572008-08-27 10:51:02 +080046#include <mach/bf54x_keys.h>
Michael Hennerich8f740ef2007-10-13 00:36:46 -040047
48#define DRV_NAME "bf54x-keys"
49#define TIME_SCALE 100 /* 100 ns */
50#define MAX_MULT (0xFF * TIME_SCALE)
51#define MAX_RC 8 /* Max Row/Col */
52
53static const u16 per_rows[] = {
54 P_KEY_ROW7,
55 P_KEY_ROW6,
56 P_KEY_ROW5,
57 P_KEY_ROW4,
58 P_KEY_ROW3,
59 P_KEY_ROW2,
60 P_KEY_ROW1,
61 P_KEY_ROW0,
62 0
63};
64
65static const u16 per_cols[] = {
66 P_KEY_COL7,
67 P_KEY_COL6,
68 P_KEY_COL5,
69 P_KEY_COL4,
70 P_KEY_COL3,
71 P_KEY_COL2,
72 P_KEY_COL1,
73 P_KEY_COL0,
74 0
75};
76
77struct bf54x_kpad {
78 struct input_dev *input;
79 int irq;
80 unsigned short lastkey;
81 unsigned short *keycode;
82 struct timer_list timer;
83 unsigned int keyup_test_jiffies;
Michael Hennerich108fcb42008-08-15 13:53:08 -040084 unsigned short kpad_msel;
85 unsigned short kpad_prescale;
86 unsigned short kpad_ctl;
Michael Hennerich8f740ef2007-10-13 00:36:46 -040087};
88
89static inline int bfin_kpad_find_key(struct bf54x_kpad *bf54x_kpad,
90 struct input_dev *input, u16 keyident)
91{
92 u16 i;
93
94 for (i = 0; i < input->keycodemax; i++)
95 if (bf54x_kpad->keycode[i + input->keycodemax] == keyident)
96 return bf54x_kpad->keycode[i];
97 return -1;
98}
99
100static inline void bfin_keycodecpy(unsigned short *keycode,
101 const unsigned int *pdata_kc,
102 unsigned short keymapsize)
103{
104 unsigned int i;
105
106 for (i = 0; i < keymapsize; i++) {
107 keycode[i] = pdata_kc[i] & 0xffff;
108 keycode[i + keymapsize] = pdata_kc[i] >> 16;
109 }
110}
111
112static inline u16 bfin_kpad_get_prescale(u32 timescale)
113{
114 u32 sclk = get_sclk();
115
116 return ((((sclk / 1000) * timescale) / 1024) - 1);
117}
118
119static inline u16 bfin_kpad_get_keypressed(struct bf54x_kpad *bf54x_kpad)
120{
121 return (bfin_read_KPAD_STAT() & KPAD_PRESSED);
122}
123
124static inline void bfin_kpad_clear_irq(void)
125{
126 bfin_write_KPAD_STAT(0xFFFF);
127 bfin_write_KPAD_ROWCOL(0xFFFF);
128}
129
130static void bfin_kpad_timer(unsigned long data)
131{
132 struct platform_device *pdev = (struct platform_device *) data;
133 struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
134
135 if (bfin_kpad_get_keypressed(bf54x_kpad)) {
136 /* Try again later */
137 mod_timer(&bf54x_kpad->timer,
138 jiffies + bf54x_kpad->keyup_test_jiffies);
139 return;
140 }
141
142 input_report_key(bf54x_kpad->input, bf54x_kpad->lastkey, 0);
143 input_sync(bf54x_kpad->input);
144
145 /* Clear IRQ Status */
146
147 bfin_kpad_clear_irq();
148 enable_irq(bf54x_kpad->irq);
149}
150
151static irqreturn_t bfin_kpad_isr(int irq, void *dev_id)
152{
153 struct platform_device *pdev = dev_id;
154 struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
155 struct input_dev *input = bf54x_kpad->input;
156 int key;
157 u16 rowcol = bfin_read_KPAD_ROWCOL();
158
159 key = bfin_kpad_find_key(bf54x_kpad, input, rowcol);
160
161 input_report_key(input, key, 1);
162 input_sync(input);
163
164 if (bfin_kpad_get_keypressed(bf54x_kpad)) {
165 disable_irq(bf54x_kpad->irq);
166 bf54x_kpad->lastkey = key;
167 mod_timer(&bf54x_kpad->timer,
168 jiffies + bf54x_kpad->keyup_test_jiffies);
169 } else {
170 input_report_key(input, key, 0);
171 input_sync(input);
172
173 bfin_kpad_clear_irq();
174 }
175
176 return IRQ_HANDLED;
177}
178
179static int __devinit bfin_kpad_probe(struct platform_device *pdev)
180{
181 struct bf54x_kpad *bf54x_kpad;
182 struct bfin_kpad_platform_data *pdata = pdev->dev.platform_data;
183 struct input_dev *input;
184 int i, error;
185
186 if (!pdata->rows || !pdata->cols || !pdata->keymap) {
187 printk(KERN_ERR DRV_NAME
188 ": No rows, cols or keymap from pdata\n");
189 return -EINVAL;
190 }
191
192 if (!pdata->keymapsize ||
193 pdata->keymapsize > (pdata->rows * pdata->cols)) {
194 printk(KERN_ERR DRV_NAME ": Invalid keymapsize\n");
195 return -EINVAL;
196 }
197
198 bf54x_kpad = kzalloc(sizeof(struct bf54x_kpad), GFP_KERNEL);
199 if (!bf54x_kpad)
200 return -ENOMEM;
201
202 platform_set_drvdata(pdev, bf54x_kpad);
203
204 /* Allocate memory for keymap followed by private LUT */
205 bf54x_kpad->keycode = kmalloc(pdata->keymapsize *
206 sizeof(unsigned short) * 2, GFP_KERNEL);
207 if (!bf54x_kpad->keycode) {
208 error = -ENOMEM;
209 goto out;
210 }
211
Roel Kluine8e0c022009-01-29 22:56:08 -0800212 if (!pdata->debounce_time || pdata->debounce_time > MAX_MULT ||
213 !pdata->coldrive_time || pdata->coldrive_time > MAX_MULT) {
Michael Hennerich87f0fd02009-03-06 01:35:35 -0800214 printk(KERN_WARNING DRV_NAME
215 ": Invalid Debounce/Columndrive Time in platform data\n");
Michael Hennerich8f740ef2007-10-13 00:36:46 -0400216 bfin_write_KPAD_MSEL(0xFF0); /* Default MSEL */
217 } else {
218 bfin_write_KPAD_MSEL(
219 ((pdata->debounce_time / TIME_SCALE)
220 & DBON_SCALE) |
221 (((pdata->coldrive_time / TIME_SCALE) << 8)
222 & COLDRV_SCALE));
223
224 }
225
226 if (!pdata->keyup_test_interval)
227 bf54x_kpad->keyup_test_jiffies = msecs_to_jiffies(50);
228 else
229 bf54x_kpad->keyup_test_jiffies =
230 msecs_to_jiffies(pdata->keyup_test_interval);
231
232 if (peripheral_request_list((u16 *)&per_rows[MAX_RC - pdata->rows],
233 DRV_NAME)) {
234 printk(KERN_ERR DRV_NAME
235 ": Requesting Peripherals failed\n");
236 error = -EFAULT;
237 goto out0;
238 }
239
240 if (peripheral_request_list((u16 *)&per_cols[MAX_RC - pdata->cols],
241 DRV_NAME)) {
242 printk(KERN_ERR DRV_NAME
243 ": Requesting Peripherals failed\n");
244 error = -EFAULT;
245 goto out1;
246 }
247
248 bf54x_kpad->irq = platform_get_irq(pdev, 0);
249 if (bf54x_kpad->irq < 0) {
250 error = -ENODEV;
251 goto out2;
252 }
253
254 error = request_irq(bf54x_kpad->irq, bfin_kpad_isr,
Michael Hennerich3eaa7502009-04-14 10:38:36 -0700255 0, DRV_NAME, pdev);
Michael Hennerich8f740ef2007-10-13 00:36:46 -0400256 if (error) {
257 printk(KERN_ERR DRV_NAME
258 ": unable to claim irq %d; error %d\n",
259 bf54x_kpad->irq, error);
Michael Hennerich8f740ef2007-10-13 00:36:46 -0400260 goto out2;
261 }
262
263 input = input_allocate_device();
264 if (!input) {
265 error = -ENOMEM;
266 goto out3;
267 }
268
269 bf54x_kpad->input = input;
270
271 input->name = pdev->name;
272 input->phys = "bf54x-keys/input0";
273 input->dev.parent = &pdev->dev;
274
275 input_set_drvdata(input, bf54x_kpad);
276
277 input->id.bustype = BUS_HOST;
278 input->id.vendor = 0x0001;
279 input->id.product = 0x0001;
280 input->id.version = 0x0100;
281
282 input->keycodesize = sizeof(unsigned short);
283 input->keycodemax = pdata->keymapsize;
284 input->keycode = bf54x_kpad->keycode;
285
286 bfin_keycodecpy(bf54x_kpad->keycode, pdata->keymap, pdata->keymapsize);
287
288 /* setup input device */
289 __set_bit(EV_KEY, input->evbit);
290
291 if (pdata->repeat)
292 __set_bit(EV_REP, input->evbit);
293
294 for (i = 0; i < input->keycodemax; i++)
295 __set_bit(bf54x_kpad->keycode[i] & KEY_MAX, input->keybit);
296 __clear_bit(KEY_RESERVED, input->keybit);
297
298 error = input_register_device(input);
299 if (error) {
300 printk(KERN_ERR DRV_NAME
301 ": Unable to register input device (%d)\n", error);
302 goto out4;
303 }
304
305 /* Init Keypad Key Up/Release test timer */
306
307 setup_timer(&bf54x_kpad->timer, bfin_kpad_timer, (unsigned long) pdev);
308
309 bfin_write_KPAD_PRESCALE(bfin_kpad_get_prescale(TIME_SCALE));
310
311 bfin_write_KPAD_CTL((((pdata->cols - 1) << 13) & KPAD_COLEN) |
312 (((pdata->rows - 1) << 10) & KPAD_ROWEN) |
313 (2 & KPAD_IRQMODE));
314
315 bfin_write_KPAD_CTL(bfin_read_KPAD_CTL() | KPAD_EN);
316
Michael Hennerichd0478d02008-04-18 00:25:00 -0400317 device_init_wakeup(&pdev->dev, 1);
318
Michael Hennerich8f740ef2007-10-13 00:36:46 -0400319 printk(KERN_ERR DRV_NAME
320 ": Blackfin BF54x Keypad registered IRQ %d\n", bf54x_kpad->irq);
321
322 return 0;
323
324out4:
325 input_free_device(input);
326out3:
327 free_irq(bf54x_kpad->irq, pdev);
328out2:
329 peripheral_free_list((u16 *)&per_cols[MAX_RC - pdata->cols]);
330out1:
331 peripheral_free_list((u16 *)&per_rows[MAX_RC - pdata->rows]);
332out0:
333 kfree(bf54x_kpad->keycode);
334out:
335 kfree(bf54x_kpad);
336 platform_set_drvdata(pdev, NULL);
337
338 return error;
339}
340
341static int __devexit bfin_kpad_remove(struct platform_device *pdev)
342{
343 struct bfin_kpad_platform_data *pdata = pdev->dev.platform_data;
344 struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
345
346 del_timer_sync(&bf54x_kpad->timer);
347 free_irq(bf54x_kpad->irq, pdev);
348
349 input_unregister_device(bf54x_kpad->input);
350
351 peripheral_free_list((u16 *)&per_rows[MAX_RC - pdata->rows]);
352 peripheral_free_list((u16 *)&per_cols[MAX_RC - pdata->cols]);
353
354 kfree(bf54x_kpad->keycode);
355 kfree(bf54x_kpad);
356 platform_set_drvdata(pdev, NULL);
357
358 return 0;
359}
360
Michael Hennerichd0478d02008-04-18 00:25:00 -0400361#ifdef CONFIG_PM
362static int bfin_kpad_suspend(struct platform_device *pdev, pm_message_t state)
363{
364 struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
365
Michael Hennerich108fcb42008-08-15 13:53:08 -0400366 bf54x_kpad->kpad_msel = bfin_read_KPAD_MSEL();
367 bf54x_kpad->kpad_prescale = bfin_read_KPAD_PRESCALE();
368 bf54x_kpad->kpad_ctl = bfin_read_KPAD_CTL();
369
Michael Hennerichd0478d02008-04-18 00:25:00 -0400370 if (device_may_wakeup(&pdev->dev))
371 enable_irq_wake(bf54x_kpad->irq);
372
373 return 0;
374}
375
376static int bfin_kpad_resume(struct platform_device *pdev)
377{
378 struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
379
Michael Hennerich108fcb42008-08-15 13:53:08 -0400380 bfin_write_KPAD_MSEL(bf54x_kpad->kpad_msel);
381 bfin_write_KPAD_PRESCALE(bf54x_kpad->kpad_prescale);
382 bfin_write_KPAD_CTL(bf54x_kpad->kpad_ctl);
383
Michael Hennerichd0478d02008-04-18 00:25:00 -0400384 if (device_may_wakeup(&pdev->dev))
385 disable_irq_wake(bf54x_kpad->irq);
386
387 return 0;
388}
389#else
390# define bfin_kpad_suspend NULL
391# define bfin_kpad_resume NULL
392#endif
393
Michael Hennerich8f740ef2007-10-13 00:36:46 -0400394struct platform_driver bfin_kpad_device_driver = {
Michael Hennerich8f740ef2007-10-13 00:36:46 -0400395 .driver = {
396 .name = DRV_NAME,
Kay Sieversd7b52472008-04-18 00:24:42 -0400397 .owner = THIS_MODULE,
Michael Hennerichd0478d02008-04-18 00:25:00 -0400398 },
399 .probe = bfin_kpad_probe,
400 .remove = __devexit_p(bfin_kpad_remove),
401 .suspend = bfin_kpad_suspend,
402 .resume = bfin_kpad_resume,
Michael Hennerich8f740ef2007-10-13 00:36:46 -0400403};
404
405static int __init bfin_kpad_init(void)
406{
407 return platform_driver_register(&bfin_kpad_device_driver);
408}
409
410static void __exit bfin_kpad_exit(void)
411{
412 platform_driver_unregister(&bfin_kpad_device_driver);
413}
414
415module_init(bfin_kpad_init);
416module_exit(bfin_kpad_exit);
417
418MODULE_LICENSE("GPL");
419MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
420MODULE_DESCRIPTION("Keypad driver for BF54x Processors");
Kay Sieversd7b52472008-04-18 00:24:42 -0400421MODULE_ALIAS("platform:bf54x-keys");