2 * Driver for the Cirrus EP93xx matrix keypad controller.
4 * Copyright (c) 2008 H Hartley Sweeten <hsweeten@visionengravers.com>
6 * Based on the pxa27x matrix keypad controller by Rodolfo Giometti.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
14 * The 3-key reset is triggered by pressing the 3 keys in
15 * Row 0, Columns 2, 4, and 7 at the same time. This action can
16 * be disabled by setting the EP93XX_KEYPAD_DISABLE_3_KEY flag.
18 * Normal operation for the matrix does not autorepeat the key press.
19 * This action can be enabled by setting the EP93XX_KEYPAD_AUTOREPEAT
23 #include <linux/platform_device.h>
24 #include <linux/interrupt.h>
25 #include <linux/clk.h>
27 #include <linux/input/matrix_keypad.h>
29 #include <mach/hardware.h>
30 #include <mach/ep93xx_keypad.h>
33 * Keypad Interface Register offsets
35 #define KEY_INIT 0x00 /* Key Scan Initialization register */
36 #define KEY_DIAG 0x04 /* Key Scan Diagnostic register */
37 #define KEY_REG 0x08 /* Key Value Capture register */
39 /* Key Scan Initialization Register bit defines */
40 #define KEY_INIT_DBNC_MASK (0x00ff0000)
41 #define KEY_INIT_DBNC_SHIFT (16)
42 #define KEY_INIT_DIS3KY (1<<15)
43 #define KEY_INIT_DIAG (1<<14)
44 #define KEY_INIT_BACK (1<<13)
45 #define KEY_INIT_T2 (1<<12)
46 #define KEY_INIT_PRSCL_MASK (0x000003ff)
47 #define KEY_INIT_PRSCL_SHIFT (0)
49 /* Key Scan Diagnostic Register bit defines */
50 #define KEY_DIAG_MASK (0x0000003f)
51 #define KEY_DIAG_SHIFT (0)
53 /* Key Value Capture Register bit defines */
54 #define KEY_REG_K (1<<15)
55 #define KEY_REG_INT (1<<14)
56 #define KEY_REG_2KEYS (1<<13)
57 #define KEY_REG_1KEY (1<<12)
58 #define KEY_REG_KEY2_MASK (0x00000fc0)
59 #define KEY_REG_KEY2_SHIFT (6)
60 #define KEY_REG_KEY1_MASK (0x0000003f)
61 #define KEY_REG_KEY1_SHIFT (0)
63 #define EP93XX_MATRIX_SIZE (EP93XX_MATRIX_ROWS * EP93XX_MATRIX_COLS)
65 struct ep93xx_keypad
{
66 struct ep93xx_keypad_platform_data
*pdata
;
67 struct input_dev
*input_dev
;
70 void __iomem
*mmio_base
;
72 unsigned int matrix_keycodes
[EP93XX_MATRIX_SIZE
];
82 static void ep93xx_keypad_build_keycode(struct ep93xx_keypad
*keypad
)
84 struct ep93xx_keypad_platform_data
*pdata
= keypad
->pdata
;
85 struct input_dev
*input_dev
= keypad
->input_dev
;
89 key
= &pdata
->matrix_key_map
[0];
90 for (i
= 0; i
< pdata
->matrix_key_map_size
; i
++, key
++) {
91 int row
= KEY_ROW(*key
);
92 int col
= KEY_COL(*key
);
93 int code
= KEY_VAL(*key
);
95 keypad
->matrix_keycodes
[(row
<< 3) + col
] = code
;
96 __set_bit(code
, input_dev
->keybit
);
100 static irqreturn_t
ep93xx_keypad_irq_handler(int irq
, void *dev_id
)
102 struct ep93xx_keypad
*keypad
= dev_id
;
103 struct input_dev
*input_dev
= keypad
->input_dev
;
105 int keycode
, key1
, key2
;
107 status
= __raw_readl(keypad
->mmio_base
+ KEY_REG
);
109 keycode
= (status
& KEY_REG_KEY1_MASK
) >> KEY_REG_KEY1_SHIFT
;
110 key1
= keypad
->matrix_keycodes
[keycode
];
112 keycode
= (status
& KEY_REG_KEY2_MASK
) >> KEY_REG_KEY2_SHIFT
;
113 key2
= keypad
->matrix_keycodes
[keycode
];
115 if (status
& KEY_REG_2KEYS
) {
116 if (keypad
->key1
&& key1
!= keypad
->key1
&& key2
!= keypad
->key1
)
117 input_report_key(input_dev
, keypad
->key1
, 0);
119 if (keypad
->key2
&& key1
!= keypad
->key2
&& key2
!= keypad
->key2
)
120 input_report_key(input_dev
, keypad
->key2
, 0);
122 input_report_key(input_dev
, key1
, 1);
123 input_report_key(input_dev
, key2
, 1);
128 } else if (status
& KEY_REG_1KEY
) {
129 if (keypad
->key1
&& key1
!= keypad
->key1
)
130 input_report_key(input_dev
, keypad
->key1
, 0);
132 if (keypad
->key2
&& key1
!= keypad
->key2
)
133 input_report_key(input_dev
, keypad
->key2
, 0);
135 input_report_key(input_dev
, key1
, 1);
141 input_report_key(input_dev
, keypad
->key1
, 0);
142 input_report_key(input_dev
, keypad
->key2
, 0);
144 keypad
->key1
= keypad
->key2
= 0;
146 input_sync(input_dev
);
151 static void ep93xx_keypad_config(struct ep93xx_keypad
*keypad
)
153 struct ep93xx_keypad_platform_data
*pdata
= keypad
->pdata
;
154 unsigned int val
= 0;
156 if (pdata
->flags
& EP93XX_KEYPAD_KDIV
)
157 clk_set_rate(keypad
->clk
, EP93XX_KEYTCHCLK_DIV4
);
159 clk_set_rate(keypad
->clk
, EP93XX_KEYTCHCLK_DIV16
);
161 if (pdata
->flags
& EP93XX_KEYPAD_DISABLE_3_KEY
)
162 val
|= KEY_INIT_DIS3KY
;
163 if (pdata
->flags
& EP93XX_KEYPAD_DIAG_MODE
)
164 val
|= KEY_INIT_DIAG
;
165 if (pdata
->flags
& EP93XX_KEYPAD_BACK_DRIVE
)
166 val
|= KEY_INIT_BACK
;
167 if (pdata
->flags
& EP93XX_KEYPAD_TEST_MODE
)
170 val
|= ((pdata
->debounce
<< KEY_INIT_DBNC_SHIFT
) & KEY_INIT_DBNC_MASK
);
172 val
|= ((pdata
->prescale
<< KEY_INIT_PRSCL_SHIFT
) & KEY_INIT_PRSCL_MASK
);
174 __raw_writel(val
, keypad
->mmio_base
+ KEY_INIT
);
177 static int ep93xx_keypad_open(struct input_dev
*pdev
)
179 struct ep93xx_keypad
*keypad
= input_get_drvdata(pdev
);
181 if (!keypad
->enabled
) {
182 ep93xx_keypad_config(keypad
);
183 clk_enable(keypad
->clk
);
184 keypad
->enabled
= true;
190 static void ep93xx_keypad_close(struct input_dev
*pdev
)
192 struct ep93xx_keypad
*keypad
= input_get_drvdata(pdev
);
194 if (keypad
->enabled
) {
195 clk_disable(keypad
->clk
);
196 keypad
->enabled
= false;
203 * NOTE: I don't know if this is correct, or will work on the ep93xx.
205 * None of the existing ep93xx drivers have power management support.
206 * But, this is basically what the pxa27x_keypad driver does.
208 static int ep93xx_keypad_suspend(struct platform_device
*pdev
,
211 struct ep93xx_keypad
*keypad
= platform_get_drvdata(pdev
);
212 struct input_dev
*input_dev
= keypad
->input_dev
;
214 mutex_lock(&input_dev
->mutex
);
216 if (keypad
->enabled
) {
217 clk_disable(keypad
->clk
);
218 keypad
->enabled
= false;
221 mutex_unlock(&input_dev
->mutex
);
223 if (device_may_wakeup(&pdev
->dev
))
224 enable_irq_wake(keypad
->irq
);
229 static int ep93xx_keypad_resume(struct platform_device
*pdev
)
231 struct ep93xx_keypad
*keypad
= platform_get_drvdata(pdev
);
232 struct input_dev
*input_dev
= keypad
->input_dev
;
234 if (device_may_wakeup(&pdev
->dev
))
235 disable_irq_wake(keypad
->irq
);
237 mutex_lock(&input_dev
->mutex
);
239 if (input_dev
->users
) {
240 if (!keypad
->enabled
) {
241 ep93xx_keypad_config(keypad
);
242 clk_enable(keypad
->clk
);
243 keypad
->enabled
= true;
247 mutex_unlock(&input_dev
->mutex
);
251 #else /* !CONFIG_PM */
252 #define ep93xx_keypad_suspend NULL
253 #define ep93xx_keypad_resume NULL
254 #endif /* !CONFIG_PM */
256 static int __devinit
ep93xx_keypad_probe(struct platform_device
*pdev
)
258 struct ep93xx_keypad
*keypad
;
259 struct input_dev
*input_dev
;
260 struct resource
*res
;
263 keypad
= kzalloc(sizeof(struct ep93xx_keypad
), GFP_KERNEL
);
267 keypad
->pdata
= pdev
->dev
.platform_data
;
268 if (!keypad
->pdata
) {
273 keypad
->irq
= platform_get_irq(pdev
, 0);
279 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
285 res
= request_mem_region(res
->start
, resource_size(res
), pdev
->name
);
291 keypad
->mmio_base
= ioremap(res
->start
, resource_size(res
));
292 if (keypad
->mmio_base
== NULL
) {
294 goto failed_free_mem
;
297 err
= ep93xx_keypad_acquire_gpio(pdev
);
301 keypad
->clk
= clk_get(&pdev
->dev
, NULL
);
302 if (IS_ERR(keypad
->clk
)) {
303 err
= PTR_ERR(keypad
->clk
);
304 goto failed_free_gpio
;
307 input_dev
= input_allocate_device();
313 keypad
->input_dev
= input_dev
;
315 input_dev
->name
= pdev
->name
;
316 input_dev
->id
.bustype
= BUS_HOST
;
317 input_dev
->open
= ep93xx_keypad_open
;
318 input_dev
->close
= ep93xx_keypad_close
;
319 input_dev
->dev
.parent
= &pdev
->dev
;
320 input_dev
->keycode
= keypad
->matrix_keycodes
;
321 input_dev
->keycodesize
= sizeof(keypad
->matrix_keycodes
[0]);
322 input_dev
->keycodemax
= ARRAY_SIZE(keypad
->matrix_keycodes
);
324 input_set_drvdata(input_dev
, keypad
);
326 input_dev
->evbit
[0] = BIT_MASK(EV_KEY
);
327 if (keypad
->pdata
->flags
& EP93XX_KEYPAD_AUTOREPEAT
)
328 input_dev
->evbit
[0] |= BIT_MASK(EV_REP
);
330 ep93xx_keypad_build_keycode(keypad
);
331 platform_set_drvdata(pdev
, keypad
);
333 err
= request_irq(keypad
->irq
, ep93xx_keypad_irq_handler
,
334 IRQF_DISABLED
, pdev
->name
, keypad
);
336 goto failed_free_dev
;
338 err
= input_register_device(input_dev
);
340 goto failed_free_irq
;
342 device_init_wakeup(&pdev
->dev
, 1);
347 free_irq(keypad
->irq
, pdev
);
348 platform_set_drvdata(pdev
, NULL
);
350 input_free_device(input_dev
);
352 clk_put(keypad
->clk
);
354 ep93xx_keypad_release_gpio(pdev
);
356 iounmap(keypad
->mmio_base
);
358 release_mem_region(res
->start
, resource_size(res
));
364 static int __devexit
ep93xx_keypad_remove(struct platform_device
*pdev
)
366 struct ep93xx_keypad
*keypad
= platform_get_drvdata(pdev
);
367 struct resource
*res
;
369 free_irq(keypad
->irq
, pdev
);
371 platform_set_drvdata(pdev
, NULL
);
374 clk_disable(keypad
->clk
);
375 clk_put(keypad
->clk
);
377 input_unregister_device(keypad
->input_dev
);
379 ep93xx_keypad_release_gpio(pdev
);
381 iounmap(keypad
->mmio_base
);
383 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
384 release_mem_region(res
->start
, resource_size(res
));
391 static struct platform_driver ep93xx_keypad_driver
= {
393 .name
= "ep93xx-keypad",
394 .owner
= THIS_MODULE
,
396 .probe
= ep93xx_keypad_probe
,
397 .remove
= __devexit_p(ep93xx_keypad_remove
),
398 .suspend
= ep93xx_keypad_suspend
,
399 .resume
= ep93xx_keypad_resume
,
402 static int __init
ep93xx_keypad_init(void)
404 return platform_driver_register(&ep93xx_keypad_driver
);
407 static void __exit
ep93xx_keypad_exit(void)
409 platform_driver_unregister(&ep93xx_keypad_driver
);
412 module_init(ep93xx_keypad_init
);
413 module_exit(ep93xx_keypad_exit
);
415 MODULE_LICENSE("GPL");
416 MODULE_AUTHOR("H Hartley Sweeten <hsweeten@visionengravers.com>");
417 MODULE_DESCRIPTION("EP93xx Matrix Keypad Controller");
418 MODULE_ALIAS("platform:ep93xx-keypad");