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");