2 * File: drivers/input/keyboard/bf54x-keys.c
4 * Author: Michael Hennerich <hennerich@blackfin.uclinux.org>
7 * Description: keypad driver for Analog Devices Blackfin BF54x Processors
11 * Copyright 2007 Analog Devices Inc.
13 * Bugs: Enter bugs at http://blackfin.uclinux.org/
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.
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.
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
31 #include <linux/module.h>
33 #include <linux/init.h>
35 #include <linux/interrupt.h>
36 #include <linux/irq.h>
37 #include <linux/sched.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>
45 #include <asm/portmux.h>
46 #include <mach/bf54x_keys.h>
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 */
53 static const u16 per_rows[] = {
65 static const u16 per_cols[] = {
78 struct input_dev *input;
80 unsigned short lastkey;
81 unsigned short *keycode;
82 struct timer_list timer;
83 unsigned int keyup_test_jiffies;
86 static inline int bfin_kpad_find_key(struct bf54x_kpad *bf54x_kpad,
87 struct input_dev *input, u16 keyident)
91 for (i = 0; i < input->keycodemax; i++)
92 if (bf54x_kpad->keycode[i + input->keycodemax] == keyident)
93 return bf54x_kpad->keycode[i];
97 static inline void bfin_keycodecpy(unsigned short *keycode,
98 const unsigned int *pdata_kc,
99 unsigned short keymapsize)
103 for (i = 0; i < keymapsize; i++) {
104 keycode[i] = pdata_kc[i] & 0xffff;
105 keycode[i + keymapsize] = pdata_kc[i] >> 16;
109 static inline u16 bfin_kpad_get_prescale(u32 timescale)
111 u32 sclk = get_sclk();
113 return ((((sclk / 1000) * timescale) / 1024) - 1);
116 static inline u16 bfin_kpad_get_keypressed(struct bf54x_kpad *bf54x_kpad)
118 return (bfin_read_KPAD_STAT() & KPAD_PRESSED);
121 static inline void bfin_kpad_clear_irq(void)
123 bfin_write_KPAD_STAT(0xFFFF);
124 bfin_write_KPAD_ROWCOL(0xFFFF);
127 static void bfin_kpad_timer(unsigned long data)
129 struct platform_device *pdev = (struct platform_device *) data;
130 struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
132 if (bfin_kpad_get_keypressed(bf54x_kpad)) {
133 /* Try again later */
134 mod_timer(&bf54x_kpad->timer,
135 jiffies + bf54x_kpad->keyup_test_jiffies);
139 input_report_key(bf54x_kpad->input, bf54x_kpad->lastkey, 0);
140 input_sync(bf54x_kpad->input);
142 /* Clear IRQ Status */
144 bfin_kpad_clear_irq();
145 enable_irq(bf54x_kpad->irq);
148 static irqreturn_t bfin_kpad_isr(int irq, void *dev_id)
150 struct platform_device *pdev = dev_id;
151 struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
152 struct input_dev *input = bf54x_kpad->input;
154 u16 rowcol = bfin_read_KPAD_ROWCOL();
156 key = bfin_kpad_find_key(bf54x_kpad, input, rowcol);
158 input_report_key(input, key, 1);
161 if (bfin_kpad_get_keypressed(bf54x_kpad)) {
162 disable_irq(bf54x_kpad->irq);
163 bf54x_kpad->lastkey = key;
164 mod_timer(&bf54x_kpad->timer,
165 jiffies + bf54x_kpad->keyup_test_jiffies);
167 input_report_key(input, key, 0);
170 bfin_kpad_clear_irq();
176 static int __devinit bfin_kpad_probe(struct platform_device *pdev)
178 struct bf54x_kpad *bf54x_kpad;
179 struct bfin_kpad_platform_data *pdata = pdev->dev.platform_data;
180 struct input_dev *input;
183 if (!pdata->rows || !pdata->cols || !pdata->keymap) {
184 printk(KERN_ERR DRV_NAME
185 ": No rows, cols or keymap from pdata\n");
189 if (!pdata->keymapsize ||
190 pdata->keymapsize > (pdata->rows * pdata->cols)) {
191 printk(KERN_ERR DRV_NAME ": Invalid keymapsize\n");
195 bf54x_kpad = kzalloc(sizeof(struct bf54x_kpad), GFP_KERNEL);
199 platform_set_drvdata(pdev, bf54x_kpad);
201 /* Allocate memory for keymap followed by private LUT */
202 bf54x_kpad->keycode = kmalloc(pdata->keymapsize *
203 sizeof(unsigned short) * 2, GFP_KERNEL);
204 if (!bf54x_kpad->keycode) {
209 if (!pdata->debounce_time || !pdata->debounce_time > MAX_MULT ||
210 !pdata->coldrive_time || !pdata->coldrive_time > MAX_MULT) {
211 printk(KERN_ERR DRV_NAME
212 ": Invalid Debounce/Columdrive Time from pdata\n");
213 bfin_write_KPAD_MSEL(0xFF0); /* Default MSEL */
215 bfin_write_KPAD_MSEL(
216 ((pdata->debounce_time / TIME_SCALE)
218 (((pdata->coldrive_time / TIME_SCALE) << 8)
223 if (!pdata->keyup_test_interval)
224 bf54x_kpad->keyup_test_jiffies = msecs_to_jiffies(50);
226 bf54x_kpad->keyup_test_jiffies =
227 msecs_to_jiffies(pdata->keyup_test_interval);
229 if (peripheral_request_list((u16 *)&per_rows[MAX_RC - pdata->rows],
231 printk(KERN_ERR DRV_NAME
232 ": Requesting Peripherals failed\n");
237 if (peripheral_request_list((u16 *)&per_cols[MAX_RC - pdata->cols],
239 printk(KERN_ERR DRV_NAME
240 ": Requesting Peripherals failed\n");
245 bf54x_kpad->irq = platform_get_irq(pdev, 0);
246 if (bf54x_kpad->irq < 0) {
251 error = request_irq(bf54x_kpad->irq, bfin_kpad_isr,
252 IRQF_SAMPLE_RANDOM, DRV_NAME, pdev);
254 printk(KERN_ERR DRV_NAME
255 ": unable to claim irq %d; error %d\n",
256 bf54x_kpad->irq, error);
260 input = input_allocate_device();
266 bf54x_kpad->input = input;
268 input->name = pdev->name;
269 input->phys = "bf54x-keys/input0";
270 input->dev.parent = &pdev->dev;
272 input_set_drvdata(input, bf54x_kpad);
274 input->id.bustype = BUS_HOST;
275 input->id.vendor = 0x0001;
276 input->id.product = 0x0001;
277 input->id.version = 0x0100;
279 input->keycodesize = sizeof(unsigned short);
280 input->keycodemax = pdata->keymapsize;
281 input->keycode = bf54x_kpad->keycode;
283 bfin_keycodecpy(bf54x_kpad->keycode, pdata->keymap, pdata->keymapsize);
285 /* setup input device */
286 __set_bit(EV_KEY, input->evbit);
289 __set_bit(EV_REP, input->evbit);
291 for (i = 0; i < input->keycodemax; i++)
292 __set_bit(bf54x_kpad->keycode[i] & KEY_MAX, input->keybit);
293 __clear_bit(KEY_RESERVED, input->keybit);
295 error = input_register_device(input);
297 printk(KERN_ERR DRV_NAME
298 ": Unable to register input device (%d)\n", error);
302 /* Init Keypad Key Up/Release test timer */
304 setup_timer(&bf54x_kpad->timer, bfin_kpad_timer, (unsigned long) pdev);
306 bfin_write_KPAD_PRESCALE(bfin_kpad_get_prescale(TIME_SCALE));
308 bfin_write_KPAD_CTL((((pdata->cols - 1) << 13) & KPAD_COLEN) |
309 (((pdata->rows - 1) << 10) & KPAD_ROWEN) |
312 bfin_write_KPAD_CTL(bfin_read_KPAD_CTL() | KPAD_EN);
314 device_init_wakeup(&pdev->dev, 1);
316 printk(KERN_ERR DRV_NAME
317 ": Blackfin BF54x Keypad registered IRQ %d\n", bf54x_kpad->irq);
322 input_free_device(input);
324 free_irq(bf54x_kpad->irq, pdev);
326 peripheral_free_list((u16 *)&per_cols[MAX_RC - pdata->cols]);
328 peripheral_free_list((u16 *)&per_rows[MAX_RC - pdata->rows]);
330 kfree(bf54x_kpad->keycode);
333 platform_set_drvdata(pdev, NULL);
338 static int __devexit bfin_kpad_remove(struct platform_device *pdev)
340 struct bfin_kpad_platform_data *pdata = pdev->dev.platform_data;
341 struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
343 del_timer_sync(&bf54x_kpad->timer);
344 free_irq(bf54x_kpad->irq, pdev);
346 input_unregister_device(bf54x_kpad->input);
348 peripheral_free_list((u16 *)&per_rows[MAX_RC - pdata->rows]);
349 peripheral_free_list((u16 *)&per_cols[MAX_RC - pdata->cols]);
351 kfree(bf54x_kpad->keycode);
353 platform_set_drvdata(pdev, NULL);
359 static int bfin_kpad_suspend(struct platform_device *pdev, pm_message_t state)
361 struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
363 if (device_may_wakeup(&pdev->dev))
364 enable_irq_wake(bf54x_kpad->irq);
369 static int bfin_kpad_resume(struct platform_device *pdev)
371 struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
373 if (device_may_wakeup(&pdev->dev))
374 disable_irq_wake(bf54x_kpad->irq);
379 # define bfin_kpad_suspend NULL
380 # define bfin_kpad_resume NULL
383 struct platform_driver bfin_kpad_device_driver = {
386 .owner = THIS_MODULE,
388 .probe = bfin_kpad_probe,
389 .remove = __devexit_p(bfin_kpad_remove),
390 .suspend = bfin_kpad_suspend,
391 .resume = bfin_kpad_resume,
394 static int __init bfin_kpad_init(void)
396 return platform_driver_register(&bfin_kpad_device_driver);
399 static void __exit bfin_kpad_exit(void)
401 platform_driver_unregister(&bfin_kpad_device_driver);
404 module_init(bfin_kpad_init);
405 module_exit(bfin_kpad_exit);
407 MODULE_LICENSE("GPL");
408 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
409 MODULE_DESCRIPTION("Keypad driver for BF54x Processors");
410 MODULE_ALIAS("platform:bf54x-keys");