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-2008 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>
32 #include <linux/version.h>
34 #include <linux/init.h>
36 #include <linux/interrupt.h>
37 #include <linux/irq.h>
38 #include <linux/sched.h>
40 #include <linux/sysctl.h>
41 #include <linux/proc_fs.h>
42 #include <linux/delay.h>
43 #include <linux/platform_device.h>
44 #include <linux/input.h>
46 #include <asm/portmux.h>
47 #include <asm/mach/bf54x_keys.h>
49 #define DRV_NAME "bf54x-keys"
50 #define TIME_SCALE 100 /* 100 ns */
51 #define MAX_MULT (0xFF * TIME_SCALE)
52 #define MAX_RC 8 /* Max Row/Col */
54 static const u16 per_rows
[] = {
66 static const u16 per_cols
[] = {
79 struct input_dev
*input
;
81 unsigned short lastkey
;
82 unsigned short *keycode
;
83 struct timer_list timer
;
84 unsigned int keyup_test_jiffies
;
85 unsigned short kpad_msel
;
86 unsigned short kpad_prescale
;
87 unsigned short kpad_ctl
;
90 static inline int bfin_kpad_find_key(struct bf54x_kpad
*bf54x_kpad
,
91 struct input_dev
*input
, u16 keyident
)
95 for (i
= 0; i
< input
->keycodemax
; i
++)
96 if (bf54x_kpad
->keycode
[i
+ input
->keycodemax
] == keyident
)
97 return bf54x_kpad
->keycode
[i
];
101 static inline void bfin_keycodecpy(unsigned short *keycode
,
102 const unsigned int *pdata_kc
,
103 unsigned short keymapsize
)
107 for (i
= 0; i
< keymapsize
; i
++) {
108 keycode
[i
] = pdata_kc
[i
] & 0xffff;
109 keycode
[i
+ keymapsize
] = pdata_kc
[i
] >> 16;
113 static inline u16
bfin_kpad_get_prescale(u32 timescale
)
115 u32 sclk
= get_sclk();
117 return ((((sclk
/ 1000) * timescale
) / 1024) - 1);
120 static inline u16
bfin_kpad_get_keypressed(struct bf54x_kpad
*bf54x_kpad
)
122 return (bfin_read_KPAD_STAT() & KPAD_PRESSED
);
125 static inline void bfin_kpad_clear_irq(void)
127 bfin_write_KPAD_STAT(0xFFFF);
128 bfin_write_KPAD_ROWCOL(0xFFFF);
131 static void bfin_kpad_timer(unsigned long data
)
133 struct platform_device
*pdev
= (struct platform_device
*) data
;
134 struct bf54x_kpad
*bf54x_kpad
= platform_get_drvdata(pdev
);
136 if (bfin_kpad_get_keypressed(bf54x_kpad
)) {
137 /* Try again later */
138 mod_timer(&bf54x_kpad
->timer
,
139 jiffies
+ bf54x_kpad
->keyup_test_jiffies
);
143 input_report_key(bf54x_kpad
->input
, bf54x_kpad
->lastkey
, 0);
144 input_sync(bf54x_kpad
->input
);
146 /* Clear IRQ Status */
148 bfin_kpad_clear_irq();
149 enable_irq(bf54x_kpad
->irq
);
152 static irqreturn_t
bfin_kpad_isr(int irq
, void *dev_id
)
154 struct platform_device
*pdev
= dev_id
;
155 struct bf54x_kpad
*bf54x_kpad
= platform_get_drvdata(pdev
);
156 struct input_dev
*input
= bf54x_kpad
->input
;
158 u16 rowcol
= bfin_read_KPAD_ROWCOL();
160 key
= bfin_kpad_find_key(bf54x_kpad
, input
, rowcol
);
162 input_report_key(input
, key
, 1);
165 if (bfin_kpad_get_keypressed(bf54x_kpad
)) {
166 disable_irq(bf54x_kpad
->irq
);
167 bf54x_kpad
->lastkey
= key
;
168 mod_timer(&bf54x_kpad
->timer
,
169 jiffies
+ bf54x_kpad
->keyup_test_jiffies
);
171 input_report_key(input
, key
, 0);
174 bfin_kpad_clear_irq();
180 static int __devinit
bfin_kpad_probe(struct platform_device
*pdev
)
182 struct bf54x_kpad
*bf54x_kpad
;
183 struct bfin_kpad_platform_data
*pdata
= pdev
->dev
.platform_data
;
184 struct input_dev
*input
;
187 if (!pdata
->rows
|| !pdata
->cols
|| !pdata
->keymap
) {
188 printk(KERN_ERR DRV_NAME
189 ": No rows, cols or keymap from pdata\n");
193 if (!pdata
->keymapsize
||
194 pdata
->keymapsize
> (pdata
->rows
* pdata
->cols
)) {
195 printk(KERN_ERR DRV_NAME
": Invalid keymapsize\n");
199 bf54x_kpad
= kzalloc(sizeof(struct bf54x_kpad
), GFP_KERNEL
);
203 platform_set_drvdata(pdev
, bf54x_kpad
);
205 /* Allocate memory for keymap followed by private LUT */
206 bf54x_kpad
->keycode
= kmalloc(pdata
->keymapsize
*
207 sizeof(unsigned short) * 2, GFP_KERNEL
);
208 if (!bf54x_kpad
->keycode
) {
213 if (!pdata
->debounce_time
|| !pdata
->debounce_time
> MAX_MULT
||
214 !pdata
->coldrive_time
|| !pdata
->coldrive_time
> MAX_MULT
) {
215 printk(KERN_ERR DRV_NAME
216 ": Invalid Debounce/Columdrive Time from pdata\n");
217 bfin_write_KPAD_MSEL(0xFF0); /* Default MSEL */
219 bfin_write_KPAD_MSEL(
220 ((pdata
->debounce_time
/ TIME_SCALE
)
222 (((pdata
->coldrive_time
/ TIME_SCALE
) << 8)
227 if (!pdata
->keyup_test_interval
)
228 bf54x_kpad
->keyup_test_jiffies
= msecs_to_jiffies(50);
230 bf54x_kpad
->keyup_test_jiffies
=
231 msecs_to_jiffies(pdata
->keyup_test_interval
);
233 if (peripheral_request_list((u16
*)&per_rows
[MAX_RC
- pdata
->rows
],
235 printk(KERN_ERR DRV_NAME
236 ": Requesting Peripherals failed\n");
241 if (peripheral_request_list((u16
*)&per_cols
[MAX_RC
- pdata
->cols
],
243 printk(KERN_ERR DRV_NAME
244 ": Requesting Peripherals failed\n");
249 bf54x_kpad
->irq
= platform_get_irq(pdev
, 0);
250 if (bf54x_kpad
->irq
< 0) {
255 error
= request_irq(bf54x_kpad
->irq
, bfin_kpad_isr
,
256 IRQF_SAMPLE_RANDOM
, DRV_NAME
, pdev
);
258 printk(KERN_ERR DRV_NAME
259 ": unable to claim irq %d; error %d\n",
260 bf54x_kpad
->irq
, error
);
264 input
= input_allocate_device();
270 bf54x_kpad
->input
= input
;
272 input
->name
= pdev
->name
;
273 input
->phys
= "bf54x-keys/input0";
274 input
->dev
.parent
= &pdev
->dev
;
276 input_set_drvdata(input
, bf54x_kpad
);
278 input
->id
.bustype
= BUS_HOST
;
279 input
->id
.vendor
= 0x0001;
280 input
->id
.product
= 0x0001;
281 input
->id
.version
= 0x0100;
283 input
->keycodesize
= sizeof(unsigned short);
284 input
->keycodemax
= pdata
->keymapsize
;
285 input
->keycode
= bf54x_kpad
->keycode
;
287 bfin_keycodecpy(bf54x_kpad
->keycode
, pdata
->keymap
, pdata
->keymapsize
);
289 /* setup input device */
290 __set_bit(EV_KEY
, input
->evbit
);
293 __set_bit(EV_REP
, input
->evbit
);
295 for (i
= 0; i
< input
->keycodemax
; i
++)
296 __set_bit(bf54x_kpad
->keycode
[i
] & KEY_MAX
, input
->keybit
);
297 __clear_bit(KEY_RESERVED
, input
->keybit
);
299 error
= input_register_device(input
);
301 printk(KERN_ERR DRV_NAME
302 ": Unable to register input device (%d)\n", error
);
306 /* Init Keypad Key Up/Release test timer */
308 setup_timer(&bf54x_kpad
->timer
, bfin_kpad_timer
, (unsigned long) pdev
);
310 bfin_write_KPAD_PRESCALE(bfin_kpad_get_prescale(TIME_SCALE
));
312 bfin_write_KPAD_CTL((((pdata
->cols
- 1) << 13) & KPAD_COLEN
) |
313 (((pdata
->rows
- 1) << 10) & KPAD_ROWEN
) |
316 bfin_write_KPAD_CTL(bfin_read_KPAD_CTL() | KPAD_EN
);
318 device_init_wakeup(&pdev
->dev
, 1);
320 printk(KERN_ERR DRV_NAME
321 ": Blackfin BF54x Keypad registered IRQ %d\n", bf54x_kpad
->irq
);
326 input_free_device(input
);
328 free_irq(bf54x_kpad
->irq
, pdev
);
330 peripheral_free_list((u16
*)&per_cols
[MAX_RC
- pdata
->cols
]);
332 peripheral_free_list((u16
*)&per_rows
[MAX_RC
- pdata
->rows
]);
334 kfree(bf54x_kpad
->keycode
);
337 platform_set_drvdata(pdev
, NULL
);
342 static int __devexit
bfin_kpad_remove(struct platform_device
*pdev
)
344 struct bfin_kpad_platform_data
*pdata
= pdev
->dev
.platform_data
;
345 struct bf54x_kpad
*bf54x_kpad
= platform_get_drvdata(pdev
);
347 del_timer_sync(&bf54x_kpad
->timer
);
348 free_irq(bf54x_kpad
->irq
, pdev
);
350 input_unregister_device(bf54x_kpad
->input
);
352 peripheral_free_list((u16
*)&per_rows
[MAX_RC
- pdata
->rows
]);
353 peripheral_free_list((u16
*)&per_cols
[MAX_RC
- pdata
->cols
]);
355 kfree(bf54x_kpad
->keycode
);
357 platform_set_drvdata(pdev
, NULL
);
363 static int bfin_kpad_suspend(struct platform_device
*pdev
, pm_message_t state
)
365 struct bf54x_kpad
*bf54x_kpad
= platform_get_drvdata(pdev
);
367 bf54x_kpad
->kpad_msel
= bfin_read_KPAD_MSEL();
368 bf54x_kpad
->kpad_prescale
= bfin_read_KPAD_PRESCALE();
369 bf54x_kpad
->kpad_ctl
= bfin_read_KPAD_CTL();
371 if (device_may_wakeup(&pdev
->dev
))
372 enable_irq_wake(bf54x_kpad
->irq
);
377 static int bfin_kpad_resume(struct platform_device
*pdev
)
379 struct bf54x_kpad
*bf54x_kpad
= platform_get_drvdata(pdev
);
381 bfin_write_KPAD_MSEL(bf54x_kpad
->kpad_msel
);
382 bfin_write_KPAD_PRESCALE(bf54x_kpad
->kpad_prescale
);
383 bfin_write_KPAD_CTL(bf54x_kpad
->kpad_ctl
);
385 if (device_may_wakeup(&pdev
->dev
))
386 disable_irq_wake(bf54x_kpad
->irq
);
391 # define bfin_kpad_suspend NULL
392 # define bfin_kpad_resume NULL
395 struct platform_driver bfin_kpad_device_driver
= {
398 .owner
= THIS_MODULE
,
400 .probe
= bfin_kpad_probe
,
401 .remove
= __devexit_p(bfin_kpad_remove
),
402 .suspend
= bfin_kpad_suspend
,
403 .resume
= bfin_kpad_resume
,
406 static int __init
bfin_kpad_init(void)
408 return platform_driver_register(&bfin_kpad_device_driver
);
411 static void __exit
bfin_kpad_exit(void)
413 platform_driver_unregister(&bfin_kpad_device_driver
);
416 module_init(bfin_kpad_init
);
417 module_exit(bfin_kpad_exit
);
419 MODULE_LICENSE("GPL");
420 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
421 MODULE_DESCRIPTION("Keypad driver for BF54x Processors");
422 MODULE_ALIAS("platform:bf54x-keys");