]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/input/keyboard/matrix_keypad.c
Merge branch 'for-linus' of git://git390.marist.edu/pub/scm/linux-2.6
[~shefty/rdma-dev.git] / drivers / input / keyboard / matrix_keypad.c
1 /*
2  *  GPIO driven matrix keyboard driver
3  *
4  *  Copyright (c) 2008 Marek Vasut <marek.vasut@gmail.com>
5  *
6  *  Based on corgikbd.c
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  */
13
14 #include <linux/types.h>
15 #include <linux/delay.h>
16 #include <linux/platform_device.h>
17 #include <linux/init.h>
18 #include <linux/input.h>
19 #include <linux/irq.h>
20 #include <linux/interrupt.h>
21 #include <linux/jiffies.h>
22 #include <linux/module.h>
23 #include <linux/gpio.h>
24 #include <linux/input/matrix_keypad.h>
25
26 struct matrix_keypad {
27         const struct matrix_keypad_platform_data *pdata;
28         struct input_dev *input_dev;
29         unsigned short *keycodes;
30         unsigned int row_shift;
31
32         uint32_t last_key_state[MATRIX_MAX_COLS];
33         struct delayed_work work;
34         bool scan_pending;
35         bool stopped;
36         spinlock_t lock;
37 };
38
39 /*
40  * NOTE: normally the GPIO has to be put into HiZ when de-activated to cause
41  * minmal side effect when scanning other columns, here it is configured to
42  * be input, and it should work on most platforms.
43  */
44 static void __activate_col(const struct matrix_keypad_platform_data *pdata,
45                            int col, bool on)
46 {
47         bool level_on = !pdata->active_low;
48
49         if (on) {
50                 gpio_direction_output(pdata->col_gpios[col], level_on);
51         } else {
52                 gpio_set_value_cansleep(pdata->col_gpios[col], !level_on);
53                 gpio_direction_input(pdata->col_gpios[col]);
54         }
55 }
56
57 static void activate_col(const struct matrix_keypad_platform_data *pdata,
58                          int col, bool on)
59 {
60         __activate_col(pdata, col, on);
61
62         if (on && pdata->col_scan_delay_us)
63                 udelay(pdata->col_scan_delay_us);
64 }
65
66 static void activate_all_cols(const struct matrix_keypad_platform_data *pdata,
67                               bool on)
68 {
69         int col;
70
71         for (col = 0; col < pdata->num_col_gpios; col++)
72                 __activate_col(pdata, col, on);
73 }
74
75 static bool row_asserted(const struct matrix_keypad_platform_data *pdata,
76                          int row)
77 {
78         return gpio_get_value_cansleep(pdata->row_gpios[row]) ?
79                         !pdata->active_low : pdata->active_low;
80 }
81
82 static void enable_row_irqs(struct matrix_keypad *keypad)
83 {
84         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
85         int i;
86
87         for (i = 0; i < pdata->num_row_gpios; i++)
88                 enable_irq(gpio_to_irq(pdata->row_gpios[i]));
89 }
90
91 static void disable_row_irqs(struct matrix_keypad *keypad)
92 {
93         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
94         int i;
95
96         for (i = 0; i < pdata->num_row_gpios; i++)
97                 disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i]));
98 }
99
100 /*
101  * This gets the keys from keyboard and reports it to input subsystem
102  */
103 static void matrix_keypad_scan(struct work_struct *work)
104 {
105         struct matrix_keypad *keypad =
106                 container_of(work, struct matrix_keypad, work.work);
107         struct input_dev *input_dev = keypad->input_dev;
108         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
109         uint32_t new_state[MATRIX_MAX_COLS];
110         int row, col, code;
111
112         /* de-activate all columns for scanning */
113         activate_all_cols(pdata, false);
114
115         memset(new_state, 0, sizeof(new_state));
116
117         /* assert each column and read the row status out */
118         for (col = 0; col < pdata->num_col_gpios; col++) {
119
120                 activate_col(pdata, col, true);
121
122                 for (row = 0; row < pdata->num_row_gpios; row++)
123                         new_state[col] |=
124                                 row_asserted(pdata, row) ? (1 << row) : 0;
125
126                 activate_col(pdata, col, false);
127         }
128
129         for (col = 0; col < pdata->num_col_gpios; col++) {
130                 uint32_t bits_changed;
131
132                 bits_changed = keypad->last_key_state[col] ^ new_state[col];
133                 if (bits_changed == 0)
134                         continue;
135
136                 for (row = 0; row < pdata->num_row_gpios; row++) {
137                         if ((bits_changed & (1 << row)) == 0)
138                                 continue;
139
140                         code = MATRIX_SCAN_CODE(row, col, keypad->row_shift);
141                         input_event(input_dev, EV_MSC, MSC_SCAN, code);
142                         input_report_key(input_dev,
143                                          keypad->keycodes[code],
144                                          new_state[col] & (1 << row));
145                 }
146         }
147         input_sync(input_dev);
148
149         memcpy(keypad->last_key_state, new_state, sizeof(new_state));
150
151         activate_all_cols(pdata, true);
152
153         /* Enable IRQs again */
154         spin_lock_irq(&keypad->lock);
155         keypad->scan_pending = false;
156         enable_row_irqs(keypad);
157         spin_unlock_irq(&keypad->lock);
158 }
159
160 static irqreturn_t matrix_keypad_interrupt(int irq, void *id)
161 {
162         struct matrix_keypad *keypad = id;
163         unsigned long flags;
164
165         spin_lock_irqsave(&keypad->lock, flags);
166
167         /*
168          * See if another IRQ beaten us to it and scheduled the
169          * scan already. In that case we should not try to
170          * disable IRQs again.
171          */
172         if (unlikely(keypad->scan_pending || keypad->stopped))
173                 goto out;
174
175         disable_row_irqs(keypad);
176         keypad->scan_pending = true;
177         schedule_delayed_work(&keypad->work,
178                 msecs_to_jiffies(keypad->pdata->debounce_ms));
179
180 out:
181         spin_unlock_irqrestore(&keypad->lock, flags);
182         return IRQ_HANDLED;
183 }
184
185 static int matrix_keypad_start(struct input_dev *dev)
186 {
187         struct matrix_keypad *keypad = input_get_drvdata(dev);
188
189         keypad->stopped = false;
190         mb();
191
192         /*
193          * Schedule an immediate key scan to capture current key state;
194          * columns will be activated and IRQs be enabled after the scan.
195          */
196         schedule_delayed_work(&keypad->work, 0);
197
198         return 0;
199 }
200
201 static void matrix_keypad_stop(struct input_dev *dev)
202 {
203         struct matrix_keypad *keypad = input_get_drvdata(dev);
204
205         keypad->stopped = true;
206         mb();
207         flush_work(&keypad->work.work);
208         /*
209          * matrix_keypad_scan() will leave IRQs enabled;
210          * we should disable them now.
211          */
212         disable_row_irqs(keypad);
213 }
214
215 #ifdef CONFIG_PM
216 static int matrix_keypad_suspend(struct platform_device *pdev, pm_message_t state)
217 {
218         struct matrix_keypad *keypad = platform_get_drvdata(pdev);
219         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
220         int i;
221
222         matrix_keypad_stop(keypad->input_dev);
223
224         if (device_may_wakeup(&pdev->dev))
225                 for (i = 0; i < pdata->num_row_gpios; i++)
226                         enable_irq_wake(gpio_to_irq(pdata->row_gpios[i]));
227
228         return 0;
229 }
230
231 static int matrix_keypad_resume(struct platform_device *pdev)
232 {
233         struct matrix_keypad *keypad = platform_get_drvdata(pdev);
234         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
235         int i;
236
237         if (device_may_wakeup(&pdev->dev))
238                 for (i = 0; i < pdata->num_row_gpios; i++)
239                         disable_irq_wake(gpio_to_irq(pdata->row_gpios[i]));
240
241         matrix_keypad_start(keypad->input_dev);
242
243         return 0;
244 }
245 #else
246 #define matrix_keypad_suspend   NULL
247 #define matrix_keypad_resume    NULL
248 #endif
249
250 static int __devinit init_matrix_gpio(struct platform_device *pdev,
251                                         struct matrix_keypad *keypad)
252 {
253         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
254         int i, err = -EINVAL;
255
256         /* initialized strobe lines as outputs, activated */
257         for (i = 0; i < pdata->num_col_gpios; i++) {
258                 err = gpio_request(pdata->col_gpios[i], "matrix_kbd_col");
259                 if (err) {
260                         dev_err(&pdev->dev,
261                                 "failed to request GPIO%d for COL%d\n",
262                                 pdata->col_gpios[i], i);
263                         goto err_free_cols;
264                 }
265
266                 gpio_direction_output(pdata->col_gpios[i], !pdata->active_low);
267         }
268
269         for (i = 0; i < pdata->num_row_gpios; i++) {
270                 err = gpio_request(pdata->row_gpios[i], "matrix_kbd_row");
271                 if (err) {
272                         dev_err(&pdev->dev,
273                                 "failed to request GPIO%d for ROW%d\n",
274                                 pdata->row_gpios[i], i);
275                         goto err_free_rows;
276                 }
277
278                 gpio_direction_input(pdata->row_gpios[i]);
279         }
280
281         for (i = 0; i < pdata->num_row_gpios; i++) {
282                 err = request_irq(gpio_to_irq(pdata->row_gpios[i]),
283                                 matrix_keypad_interrupt,
284                                 IRQF_DISABLED |
285                                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
286                                 "matrix-keypad", keypad);
287                 if (err) {
288                         dev_err(&pdev->dev,
289                                 "Unable to acquire interrupt for GPIO line %i\n",
290                                 pdata->row_gpios[i]);
291                         goto err_free_irqs;
292                 }
293         }
294
295         /* initialized as disabled - enabled by input->open */
296         disable_row_irqs(keypad);
297         return 0;
298
299 err_free_irqs:
300         while (--i >= 0)
301                 free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
302         i = pdata->num_row_gpios;
303 err_free_rows:
304         while (--i >= 0)
305                 gpio_free(pdata->row_gpios[i]);
306         i = pdata->num_col_gpios;
307 err_free_cols:
308         while (--i >= 0)
309                 gpio_free(pdata->col_gpios[i]);
310
311         return err;
312 }
313
314 static int __devinit matrix_keypad_probe(struct platform_device *pdev)
315 {
316         const struct matrix_keypad_platform_data *pdata;
317         const struct matrix_keymap_data *keymap_data;
318         struct matrix_keypad *keypad;
319         struct input_dev *input_dev;
320         unsigned short *keycodes;
321         unsigned int row_shift;
322         int i;
323         int err;
324
325         pdata = pdev->dev.platform_data;
326         if (!pdata) {
327                 dev_err(&pdev->dev, "no platform data defined\n");
328                 return -EINVAL;
329         }
330
331         keymap_data = pdata->keymap_data;
332         if (!keymap_data) {
333                 dev_err(&pdev->dev, "no keymap data defined\n");
334                 return -EINVAL;
335         }
336
337         row_shift = get_count_order(pdata->num_col_gpios);
338
339         keypad = kzalloc(sizeof(struct matrix_keypad), GFP_KERNEL);
340         keycodes = kzalloc((pdata->num_row_gpios << row_shift) *
341                                 sizeof(*keycodes),
342                            GFP_KERNEL);
343         input_dev = input_allocate_device();
344         if (!keypad || !keycodes || !input_dev) {
345                 err = -ENOMEM;
346                 goto err_free_mem;
347         }
348
349         keypad->input_dev = input_dev;
350         keypad->pdata = pdata;
351         keypad->keycodes = keycodes;
352         keypad->row_shift = row_shift;
353         keypad->stopped = true;
354         INIT_DELAYED_WORK(&keypad->work, matrix_keypad_scan);
355         spin_lock_init(&keypad->lock);
356
357         input_dev->name         = pdev->name;
358         input_dev->id.bustype   = BUS_HOST;
359         input_dev->dev.parent   = &pdev->dev;
360         input_dev->evbit[0]     = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
361         input_dev->open         = matrix_keypad_start;
362         input_dev->close        = matrix_keypad_stop;
363
364         input_dev->keycode      = keycodes;
365         input_dev->keycodesize  = sizeof(*keycodes);
366         input_dev->keycodemax   = pdata->num_row_gpios << keypad->row_shift;
367
368         for (i = 0; i < keymap_data->keymap_size; i++) {
369                 unsigned int key = keymap_data->keymap[i];
370                 unsigned int row = KEY_ROW(key);
371                 unsigned int col = KEY_COL(key);
372                 unsigned short code = KEY_VAL(key);
373
374                 keycodes[MATRIX_SCAN_CODE(row, col, row_shift)] = code;
375                 __set_bit(code, input_dev->keybit);
376         }
377         __clear_bit(KEY_RESERVED, input_dev->keybit);
378
379         input_set_capability(input_dev, EV_MSC, MSC_SCAN);
380         input_set_drvdata(input_dev, keypad);
381
382         err = init_matrix_gpio(pdev, keypad);
383         if (err)
384                 goto err_free_mem;
385
386         err = input_register_device(keypad->input_dev);
387         if (err)
388                 goto err_free_mem;
389
390         device_init_wakeup(&pdev->dev, pdata->wakeup);
391         platform_set_drvdata(pdev, keypad);
392
393         return 0;
394
395 err_free_mem:
396         input_free_device(input_dev);
397         kfree(keycodes);
398         kfree(keypad);
399         return err;
400 }
401
402 static int __devexit matrix_keypad_remove(struct platform_device *pdev)
403 {
404         struct matrix_keypad *keypad = platform_get_drvdata(pdev);
405         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
406         int i;
407
408         device_init_wakeup(&pdev->dev, 0);
409
410         for (i = 0; i < pdata->num_row_gpios; i++) {
411                 free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
412                 gpio_free(pdata->row_gpios[i]);
413         }
414
415         for (i = 0; i < pdata->num_col_gpios; i++)
416                 gpio_free(pdata->col_gpios[i]);
417
418         input_unregister_device(keypad->input_dev);
419         platform_set_drvdata(pdev, NULL);
420         kfree(keypad->keycodes);
421         kfree(keypad);
422
423         return 0;
424 }
425
426 static struct platform_driver matrix_keypad_driver = {
427         .probe          = matrix_keypad_probe,
428         .remove         = __devexit_p(matrix_keypad_remove),
429         .suspend        = matrix_keypad_suspend,
430         .resume         = matrix_keypad_resume,
431         .driver         = {
432                 .name   = "matrix-keypad",
433                 .owner  = THIS_MODULE,
434         },
435 };
436
437 static int __init matrix_keypad_init(void)
438 {
439         return platform_driver_register(&matrix_keypad_driver);
440 }
441
442 static void __exit matrix_keypad_exit(void)
443 {
444         platform_driver_unregister(&matrix_keypad_driver);
445 }
446
447 module_init(matrix_keypad_init);
448 module_exit(matrix_keypad_exit);
449
450 MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
451 MODULE_DESCRIPTION("GPIO Driven Matrix Keypad Driver");
452 MODULE_LICENSE("GPL v2");
453 MODULE_ALIAS("platform:matrix-keypad");