Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/input/keyboard/ep93xx_keypad.c

  1 /*
  2  * Driver for the Cirrus EP93xx matrix keypad controller.
  3  *
  4  * Copyright (c) 2008 H Hartley Sweeten <hsweeten@visionengravers.com>
  5  *
  6  * Based on the pxa27x matrix keypad controller by Rodolfo Giometti.
  7  *
  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.
 11  *
 12  * NOTE:
 13  *
 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.
 17  *
 18  * Normal operation for the matrix does not autorepeat the key press.
 19  * This action can be enabled by setting the EP93XX_KEYPAD_AUTOREPEAT
 20  * flag.
 21  */
 22 
 23 #include <linux/module.h>
 24 #include <linux/platform_device.h>
 25 #include <linux/interrupt.h>
 26 #include <linux/clk.h>
 27 #include <linux/io.h>
 28 #include <linux/input/matrix_keypad.h>
 29 #include <linux/slab.h>
 30 
 31 #include <mach/hardware.h>
 32 #include <linux/platform_data/keypad-ep93xx.h>
 33 
 34 /*
 35  * Keypad Interface Register offsets
 36  */
 37 #define KEY_INIT                0x00    /* Key Scan Initialization register */
 38 #define KEY_DIAG                0x04    /* Key Scan Diagnostic register */
 39 #define KEY_REG                 0x08    /* Key Value Capture register */
 40 
 41 /* Key Scan Initialization Register bit defines */
 42 #define KEY_INIT_DBNC_MASK      (0x00ff0000)
 43 #define KEY_INIT_DBNC_SHIFT     (16)
 44 #define KEY_INIT_DIS3KY         (1<<15)
 45 #define KEY_INIT_DIAG           (1<<14)
 46 #define KEY_INIT_BACK           (1<<13)
 47 #define KEY_INIT_T2             (1<<12)
 48 #define KEY_INIT_PRSCL_MASK     (0x000003ff)
 49 #define KEY_INIT_PRSCL_SHIFT    (0)
 50 
 51 /* Key Scan Diagnostic Register bit defines */
 52 #define KEY_DIAG_MASK           (0x0000003f)
 53 #define KEY_DIAG_SHIFT          (0)
 54 
 55 /* Key Value Capture Register bit defines */
 56 #define KEY_REG_K               (1<<15)
 57 #define KEY_REG_INT             (1<<14)
 58 #define KEY_REG_2KEYS           (1<<13)
 59 #define KEY_REG_1KEY            (1<<12)
 60 #define KEY_REG_KEY2_MASK       (0x00000fc0)
 61 #define KEY_REG_KEY2_SHIFT      (6)
 62 #define KEY_REG_KEY1_MASK       (0x0000003f)
 63 #define KEY_REG_KEY1_SHIFT      (0)
 64 
 65 #define EP93XX_MATRIX_SIZE      (EP93XX_MATRIX_ROWS * EP93XX_MATRIX_COLS)
 66 
 67 struct ep93xx_keypad {
 68         struct ep93xx_keypad_platform_data *pdata;
 69         struct input_dev *input_dev;
 70         struct clk *clk;
 71 
 72         void __iomem *mmio_base;
 73 
 74         unsigned short keycodes[EP93XX_MATRIX_SIZE];
 75 
 76         int key1;
 77         int key2;
 78 
 79         int irq;
 80 
 81         bool enabled;
 82 };
 83 
 84 static irqreturn_t ep93xx_keypad_irq_handler(int irq, void *dev_id)
 85 {
 86         struct ep93xx_keypad *keypad = dev_id;
 87         struct input_dev *input_dev = keypad->input_dev;
 88         unsigned int status;
 89         int keycode, key1, key2;
 90 
 91         status = __raw_readl(keypad->mmio_base + KEY_REG);
 92 
 93         keycode = (status & KEY_REG_KEY1_MASK) >> KEY_REG_KEY1_SHIFT;
 94         key1 = keypad->keycodes[keycode];
 95 
 96         keycode = (status & KEY_REG_KEY2_MASK) >> KEY_REG_KEY2_SHIFT;
 97         key2 = keypad->keycodes[keycode];
 98 
 99         if (status & KEY_REG_2KEYS) {
100                 if (keypad->key1 && key1 != keypad->key1 && key2 != keypad->key1)
101                         input_report_key(input_dev, keypad->key1, 0);
102 
103                 if (keypad->key2 && key1 != keypad->key2 && key2 != keypad->key2)
104                         input_report_key(input_dev, keypad->key2, 0);
105 
106                 input_report_key(input_dev, key1, 1);
107                 input_report_key(input_dev, key2, 1);
108 
109                 keypad->key1 = key1;
110                 keypad->key2 = key2;
111 
112         } else if (status & KEY_REG_1KEY) {
113                 if (keypad->key1 && key1 != keypad->key1)
114                         input_report_key(input_dev, keypad->key1, 0);
115 
116                 if (keypad->key2 && key1 != keypad->key2)
117                         input_report_key(input_dev, keypad->key2, 0);
118 
119                 input_report_key(input_dev, key1, 1);
120 
121                 keypad->key1 = key1;
122                 keypad->key2 = 0;
123 
124         } else {
125                 input_report_key(input_dev, keypad->key1, 0);
126                 input_report_key(input_dev, keypad->key2, 0);
127 
128                 keypad->key1 = keypad->key2 = 0;
129         }
130         input_sync(input_dev);
131 
132         return IRQ_HANDLED;
133 }
134 
135 static void ep93xx_keypad_config(struct ep93xx_keypad *keypad)
136 {
137         struct ep93xx_keypad_platform_data *pdata = keypad->pdata;
138         unsigned int val = 0;
139 
140         if (pdata->flags & EP93XX_KEYPAD_KDIV)
141                 clk_set_rate(keypad->clk, EP93XX_KEYTCHCLK_DIV4);
142         else
143                 clk_set_rate(keypad->clk, EP93XX_KEYTCHCLK_DIV16);
144 
145         if (pdata->flags & EP93XX_KEYPAD_DISABLE_3_KEY)
146                 val |= KEY_INIT_DIS3KY;
147         if (pdata->flags & EP93XX_KEYPAD_DIAG_MODE)
148                 val |= KEY_INIT_DIAG;
149         if (pdata->flags & EP93XX_KEYPAD_BACK_DRIVE)
150                 val |= KEY_INIT_BACK;
151         if (pdata->flags & EP93XX_KEYPAD_TEST_MODE)
152                 val |= KEY_INIT_T2;
153 
154         val |= ((pdata->debounce << KEY_INIT_DBNC_SHIFT) & KEY_INIT_DBNC_MASK);
155 
156         val |= ((pdata->prescale << KEY_INIT_PRSCL_SHIFT) & KEY_INIT_PRSCL_MASK);
157 
158         __raw_writel(val, keypad->mmio_base + KEY_INIT);
159 }
160 
161 static int ep93xx_keypad_open(struct input_dev *pdev)
162 {
163         struct ep93xx_keypad *keypad = input_get_drvdata(pdev);
164 
165         if (!keypad->enabled) {
166                 ep93xx_keypad_config(keypad);
167                 clk_enable(keypad->clk);
168                 keypad->enabled = true;
169         }
170 
171         return 0;
172 }
173 
174 static void ep93xx_keypad_close(struct input_dev *pdev)
175 {
176         struct ep93xx_keypad *keypad = input_get_drvdata(pdev);
177 
178         if (keypad->enabled) {
179                 clk_disable(keypad->clk);
180                 keypad->enabled = false;
181         }
182 }
183 
184 
185 #ifdef CONFIG_PM_SLEEP
186 static int ep93xx_keypad_suspend(struct device *dev)
187 {
188         struct platform_device *pdev = to_platform_device(dev);
189         struct ep93xx_keypad *keypad = platform_get_drvdata(pdev);
190         struct input_dev *input_dev = keypad->input_dev;
191 
192         mutex_lock(&input_dev->mutex);
193 
194         if (keypad->enabled) {
195                 clk_disable(keypad->clk);
196                 keypad->enabled = false;
197         }
198 
199         mutex_unlock(&input_dev->mutex);
200 
201         if (device_may_wakeup(&pdev->dev))
202                 enable_irq_wake(keypad->irq);
203 
204         return 0;
205 }
206 
207 static int ep93xx_keypad_resume(struct device *dev)
208 {
209         struct platform_device *pdev = to_platform_device(dev);
210         struct ep93xx_keypad *keypad = platform_get_drvdata(pdev);
211         struct input_dev *input_dev = keypad->input_dev;
212 
213         if (device_may_wakeup(&pdev->dev))
214                 disable_irq_wake(keypad->irq);
215 
216         mutex_lock(&input_dev->mutex);
217 
218         if (input_dev->users) {
219                 if (!keypad->enabled) {
220                         ep93xx_keypad_config(keypad);
221                         clk_enable(keypad->clk);
222                         keypad->enabled = true;
223                 }
224         }
225 
226         mutex_unlock(&input_dev->mutex);
227 
228         return 0;
229 }
230 #endif
231 
232 static SIMPLE_DEV_PM_OPS(ep93xx_keypad_pm_ops,
233                          ep93xx_keypad_suspend, ep93xx_keypad_resume);
234 
235 static int ep93xx_keypad_probe(struct platform_device *pdev)
236 {
237         struct ep93xx_keypad *keypad;
238         const struct matrix_keymap_data *keymap_data;
239         struct input_dev *input_dev;
240         struct resource *res;
241         int err;
242 
243         keypad = kzalloc(sizeof(struct ep93xx_keypad), GFP_KERNEL);
244         if (!keypad)
245                 return -ENOMEM;
246 
247         keypad->pdata = dev_get_platdata(&pdev->dev);
248         if (!keypad->pdata) {
249                 err = -EINVAL;
250                 goto failed_free;
251         }
252 
253         keymap_data = keypad->pdata->keymap_data;
254         if (!keymap_data) {
255                 err = -EINVAL;
256                 goto failed_free;
257         }
258 
259         keypad->irq = platform_get_irq(pdev, 0);
260         if (!keypad->irq) {
261                 err = -ENXIO;
262                 goto failed_free;
263         }
264 
265         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
266         if (!res) {
267                 err = -ENXIO;
268                 goto failed_free;
269         }
270 
271         res = request_mem_region(res->start, resource_size(res), pdev->name);
272         if (!res) {
273                 err = -EBUSY;
274                 goto failed_free;
275         }
276 
277         keypad->mmio_base = ioremap(res->start, resource_size(res));
278         if (keypad->mmio_base == NULL) {
279                 err = -ENXIO;
280                 goto failed_free_mem;
281         }
282 
283         err = ep93xx_keypad_acquire_gpio(pdev);
284         if (err)
285                 goto failed_free_io;
286 
287         keypad->clk = clk_get(&pdev->dev, NULL);
288         if (IS_ERR(keypad->clk)) {
289                 err = PTR_ERR(keypad->clk);
290                 goto failed_free_gpio;
291         }
292 
293         input_dev = input_allocate_device();
294         if (!input_dev) {
295                 err = -ENOMEM;
296                 goto failed_put_clk;
297         }
298 
299         keypad->input_dev = input_dev;
300 
301         input_dev->name = pdev->name;
302         input_dev->id.bustype = BUS_HOST;
303         input_dev->open = ep93xx_keypad_open;
304         input_dev->close = ep93xx_keypad_close;
305         input_dev->dev.parent = &pdev->dev;
306 
307         err = matrix_keypad_build_keymap(keymap_data, NULL,
308                                          EP93XX_MATRIX_ROWS, EP93XX_MATRIX_COLS,
309                                          keypad->keycodes, input_dev);
310         if (err)
311                 goto failed_free_dev;
312 
313         if (keypad->pdata->flags & EP93XX_KEYPAD_AUTOREPEAT)
314                 __set_bit(EV_REP, input_dev->evbit);
315         input_set_drvdata(input_dev, keypad);
316 
317         err = request_irq(keypad->irq, ep93xx_keypad_irq_handler,
318                           0, pdev->name, keypad);
319         if (err)
320                 goto failed_free_dev;
321 
322         err = input_register_device(input_dev);
323         if (err)
324                 goto failed_free_irq;
325 
326         platform_set_drvdata(pdev, keypad);
327         device_init_wakeup(&pdev->dev, 1);
328 
329         return 0;
330 
331 failed_free_irq:
332         free_irq(keypad->irq, keypad);
333 failed_free_dev:
334         input_free_device(input_dev);
335 failed_put_clk:
336         clk_put(keypad->clk);
337 failed_free_gpio:
338         ep93xx_keypad_release_gpio(pdev);
339 failed_free_io:
340         iounmap(keypad->mmio_base);
341 failed_free_mem:
342         release_mem_region(res->start, resource_size(res));
343 failed_free:
344         kfree(keypad);
345         return err;
346 }
347 
348 static int ep93xx_keypad_remove(struct platform_device *pdev)
349 {
350         struct ep93xx_keypad *keypad = platform_get_drvdata(pdev);
351         struct resource *res;
352 
353         free_irq(keypad->irq, keypad);
354 
355         if (keypad->enabled)
356                 clk_disable(keypad->clk);
357         clk_put(keypad->clk);
358 
359         input_unregister_device(keypad->input_dev);
360 
361         ep93xx_keypad_release_gpio(pdev);
362 
363         iounmap(keypad->mmio_base);
364 
365         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
366         release_mem_region(res->start, resource_size(res));
367 
368         kfree(keypad);
369 
370         return 0;
371 }
372 
373 static struct platform_driver ep93xx_keypad_driver = {
374         .driver         = {
375                 .name   = "ep93xx-keypad",
376                 .owner  = THIS_MODULE,
377                 .pm     = &ep93xx_keypad_pm_ops,
378         },
379         .probe          = ep93xx_keypad_probe,
380         .remove         = ep93xx_keypad_remove,
381 };
382 module_platform_driver(ep93xx_keypad_driver);
383 
384 MODULE_LICENSE("GPL");
385 MODULE_AUTHOR("H Hartley Sweeten <hsweeten@visionengravers.com>");
386 MODULE_DESCRIPTION("EP93xx Matrix Keypad Controller");
387 MODULE_ALIAS("platform:ep93xx-keypad");
388 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us