tizen 2.4 release
[profile/mobile/platform/kernel/linux-3.10-sc7730.git] / drivers / input / misc / gpio_matrix.c
1 /* drivers/input/misc/gpio_matrix.c
2  *
3  * Copyright (C) 2007 Google, Inc.
4  *
5  * This software is licensed under the terms of the GNU General Public
6  * License version 2, as published by the Free Software Foundation, and
7  * may be copied, distributed, and modified under those terms.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  */
15
16 #include <linux/kernel.h>
17 #include <linux/gpio.h>
18 #include <linux/gpio_event.h>
19 #include <linux/hrtimer.h>
20 #include <linux/interrupt.h>
21 #include <linux/slab.h>
22 #include <linux/wakelock.h>
23
24 struct gpio_kp {
25         struct gpio_event_input_devs *input_devs;
26         struct gpio_event_matrix_info *keypad_info;
27         struct hrtimer timer;
28         struct wake_lock wake_lock;
29         int current_output;
30         unsigned int use_irq:1;
31         unsigned int key_state_changed:1;
32         unsigned int last_key_state_changed:1;
33         unsigned int some_keys_pressed:2;
34         unsigned int disabled_irq:1;
35         unsigned long keys_pressed[0];
36 };
37
38 static void clear_phantom_key(struct gpio_kp *kp, int out, int in)
39 {
40         struct gpio_event_matrix_info *mi = kp->keypad_info;
41         int key_index = out * mi->ninputs + in;
42         unsigned short keyentry = mi->keymap[key_index];
43         unsigned short keycode = keyentry & MATRIX_KEY_MASK;
44         unsigned short dev = keyentry >> MATRIX_CODE_BITS;
45
46         if (!test_bit(keycode, kp->input_devs->dev[dev]->key)) {
47                 if (mi->flags & GPIOKPF_PRINT_PHANTOM_KEYS)
48                         pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
49                                 "cleared\n", keycode, out, in,
50                                 mi->output_gpios[out], mi->input_gpios[in]);
51                 __clear_bit(key_index, kp->keys_pressed);
52         } else {
53                 if (mi->flags & GPIOKPF_PRINT_PHANTOM_KEYS)
54                         pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
55                                 "not cleared\n", keycode, out, in,
56                                 mi->output_gpios[out], mi->input_gpios[in]);
57         }
58 }
59
60 static int restore_keys_for_input(struct gpio_kp *kp, int out, int in)
61 {
62         int rv = 0;
63         int key_index;
64
65         key_index = out * kp->keypad_info->ninputs + in;
66         while (out < kp->keypad_info->noutputs) {
67                 if (test_bit(key_index, kp->keys_pressed)) {
68                         rv = 1;
69                         clear_phantom_key(kp, out, in);
70                 }
71                 key_index += kp->keypad_info->ninputs;
72                 out++;
73         }
74         return rv;
75 }
76
77 static void remove_phantom_keys(struct gpio_kp *kp)
78 {
79         int out, in, inp;
80         int key_index;
81
82         if (kp->some_keys_pressed < 3)
83                 return;
84
85         for (out = 0; out < kp->keypad_info->noutputs; out++) {
86                 inp = -1;
87                 key_index = out * kp->keypad_info->ninputs;
88                 for (in = 0; in < kp->keypad_info->ninputs; in++, key_index++) {
89                         if (test_bit(key_index, kp->keys_pressed)) {
90                                 if (inp == -1) {
91                                         inp = in;
92                                         continue;
93                                 }
94                                 if (inp >= 0) {
95                                         if (!restore_keys_for_input(kp, out + 1,
96                                                                         inp))
97                                                 break;
98                                         clear_phantom_key(kp, out, inp);
99                                         inp = -2;
100                                 }
101                                 restore_keys_for_input(kp, out, in);
102                         }
103                 }
104         }
105 }
106
107 static void report_key(struct gpio_kp *kp, int key_index, int out, int in)
108 {
109         struct gpio_event_matrix_info *mi = kp->keypad_info;
110         int pressed = test_bit(key_index, kp->keys_pressed);
111         unsigned short keyentry = mi->keymap[key_index];
112         unsigned short keycode = keyentry & MATRIX_KEY_MASK;
113         unsigned short dev = keyentry >> MATRIX_CODE_BITS;
114
115         if (pressed != test_bit(keycode, kp->input_devs->dev[dev]->key)) {
116                 if (keycode == KEY_RESERVED) {
117                         if (mi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS)
118                                 pr_info("gpiomatrix: unmapped key, %d-%d "
119                                         "(%d-%d) changed to %d\n",
120                                         out, in, mi->output_gpios[out],
121                                         mi->input_gpios[in], pressed);
122                 } else {
123                         if (mi->flags & GPIOKPF_PRINT_MAPPED_KEYS)
124                                 pr_info("gpiomatrix: key %x, %d-%d (%d-%d) "
125                                         "changed to %d\n", keycode,
126                                         out, in, mi->output_gpios[out],
127                                         mi->input_gpios[in], pressed);
128                         input_report_key(kp->input_devs->dev[dev], keycode, pressed);
129                 }
130         }
131 }
132
133 static void report_sync(struct gpio_kp *kp)
134 {
135         int i;
136
137         for (i = 0; i < kp->input_devs->count; i++)
138                 input_sync(kp->input_devs->dev[i]);
139 }
140
141 static enum hrtimer_restart gpio_keypad_timer_func(struct hrtimer *timer)
142 {
143         int out, in;
144         int key_index;
145         int gpio;
146         struct gpio_kp *kp = container_of(timer, struct gpio_kp, timer);
147         struct gpio_event_matrix_info *mi = kp->keypad_info;
148         unsigned gpio_keypad_flags = mi->flags;
149         unsigned polarity = !!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH);
150
151         out = kp->current_output;
152         if (out == mi->noutputs) {
153                 out = 0;
154                 kp->last_key_state_changed = kp->key_state_changed;
155                 kp->key_state_changed = 0;
156                 kp->some_keys_pressed = 0;
157         } else {
158                 key_index = out * mi->ninputs;
159                 for (in = 0; in < mi->ninputs; in++, key_index++) {
160                         gpio = mi->input_gpios[in];
161                         if (gpio_get_value(gpio) ^ !polarity) {
162                                 if (kp->some_keys_pressed < 3)
163                                         kp->some_keys_pressed++;
164                                 kp->key_state_changed |= !__test_and_set_bit(
165                                                 key_index, kp->keys_pressed);
166                         } else
167                                 kp->key_state_changed |= __test_and_clear_bit(
168                                                 key_index, kp->keys_pressed);
169                 }
170                 gpio = mi->output_gpios[out];
171                 if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
172                         gpio_set_value(gpio, !polarity);
173                 else
174                         gpio_direction_input(gpio);
175                 out++;
176         }
177         kp->current_output = out;
178         if (out < mi->noutputs) {
179                 gpio = mi->output_gpios[out];
180                 if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
181                         gpio_set_value(gpio, polarity);
182                 else
183                         gpio_direction_output(gpio, polarity);
184                 hrtimer_start(timer, mi->settle_time, HRTIMER_MODE_REL);
185                 return HRTIMER_NORESTART;
186         }
187         if (gpio_keypad_flags & GPIOKPF_DEBOUNCE) {
188                 if (kp->key_state_changed) {
189                         hrtimer_start(&kp->timer, mi->debounce_delay,
190                                       HRTIMER_MODE_REL);
191                         return HRTIMER_NORESTART;
192                 }
193                 kp->key_state_changed = kp->last_key_state_changed;
194         }
195         if (kp->key_state_changed) {
196                 if (gpio_keypad_flags & GPIOKPF_REMOVE_SOME_PHANTOM_KEYS)
197                         remove_phantom_keys(kp);
198                 key_index = 0;
199                 for (out = 0; out < mi->noutputs; out++)
200                         for (in = 0; in < mi->ninputs; in++, key_index++)
201                                 report_key(kp, key_index, out, in);
202                 report_sync(kp);
203         }
204         if (!kp->use_irq || kp->some_keys_pressed) {
205                 hrtimer_start(timer, mi->poll_time, HRTIMER_MODE_REL);
206                 return HRTIMER_NORESTART;
207         }
208
209         /* No keys are pressed, reenable interrupt */
210         for (out = 0; out < mi->noutputs; out++) {
211                 if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
212                         gpio_set_value(mi->output_gpios[out], polarity);
213                 else
214                         gpio_direction_output(mi->output_gpios[out], polarity);
215         }
216         for (in = 0; in < mi->ninputs; in++)
217                 enable_irq(gpio_to_irq(mi->input_gpios[in]));
218         wake_unlock(&kp->wake_lock);
219         return HRTIMER_NORESTART;
220 }
221
222 static irqreturn_t gpio_keypad_irq_handler(int irq_in, void *dev_id)
223 {
224         int i;
225         struct gpio_kp *kp = dev_id;
226         struct gpio_event_matrix_info *mi = kp->keypad_info;
227         unsigned gpio_keypad_flags = mi->flags;
228
229         if (!kp->use_irq) {
230                 /* ignore interrupt while registering the handler */
231                 kp->disabled_irq = 1;
232                 disable_irq_nosync(irq_in);
233                 return IRQ_HANDLED;
234         }
235
236         for (i = 0; i < mi->ninputs; i++)
237                 disable_irq_nosync(gpio_to_irq(mi->input_gpios[i]));
238         for (i = 0; i < mi->noutputs; i++) {
239                 if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
240                         gpio_set_value(mi->output_gpios[i],
241                                 !(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH));
242                 else
243                         gpio_direction_input(mi->output_gpios[i]);
244         }
245         wake_lock(&kp->wake_lock);
246         hrtimer_start(&kp->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
247         return IRQ_HANDLED;
248 }
249
250 static int gpio_keypad_request_irqs(struct gpio_kp *kp)
251 {
252         int i;
253         int err;
254         unsigned int irq;
255         unsigned long request_flags;
256         struct gpio_event_matrix_info *mi = kp->keypad_info;
257
258         switch (mi->flags & (GPIOKPF_ACTIVE_HIGH|GPIOKPF_LEVEL_TRIGGERED_IRQ)) {
259         default:
260                 request_flags = IRQF_TRIGGER_FALLING;
261                 break;
262         case GPIOKPF_ACTIVE_HIGH:
263                 request_flags = IRQF_TRIGGER_RISING;
264                 break;
265         case GPIOKPF_LEVEL_TRIGGERED_IRQ:
266                 request_flags = IRQF_TRIGGER_LOW;
267                 break;
268         case GPIOKPF_LEVEL_TRIGGERED_IRQ | GPIOKPF_ACTIVE_HIGH:
269                 request_flags = IRQF_TRIGGER_HIGH;
270                 break;
271         }
272
273         for (i = 0; i < mi->ninputs; i++) {
274                 err = irq = gpio_to_irq(mi->input_gpios[i]);
275                 if (err < 0)
276                         goto err_gpio_get_irq_num_failed;
277                 err = request_irq(irq, gpio_keypad_irq_handler, request_flags,
278                                   "gpio_kp", kp);
279                 if (err) {
280                         pr_err("gpiomatrix: request_irq failed for input %d, "
281                                 "irq %d\n", mi->input_gpios[i], irq);
282                         goto err_request_irq_failed;
283                 }
284                 err = enable_irq_wake(irq);
285                 if (err) {
286                         pr_err("gpiomatrix: set_irq_wake failed for input %d, "
287                                 "irq %d\n", mi->input_gpios[i], irq);
288                 }
289                 disable_irq(irq);
290                 if (kp->disabled_irq) {
291                         kp->disabled_irq = 0;
292                         enable_irq(irq);
293                 }
294         }
295         return 0;
296
297         for (i = mi->noutputs - 1; i >= 0; i--) {
298                 free_irq(gpio_to_irq(mi->input_gpios[i]), kp);
299 err_request_irq_failed:
300 err_gpio_get_irq_num_failed:
301                 ;
302         }
303         return err;
304 }
305
306 int gpio_event_matrix_func(struct gpio_event_input_devs *input_devs,
307         struct gpio_event_info *info, void **data, int func)
308 {
309         int i;
310         int err;
311         int key_count;
312         struct gpio_kp *kp;
313         struct gpio_event_matrix_info *mi;
314
315         mi = container_of(info, struct gpio_event_matrix_info, info);
316         if (func == GPIO_EVENT_FUNC_SUSPEND || func == GPIO_EVENT_FUNC_RESUME) {
317                 /* TODO: disable scanning */
318                 return 0;
319         }
320
321         if (func == GPIO_EVENT_FUNC_INIT) {
322                 if (mi->keymap == NULL ||
323                    mi->input_gpios == NULL ||
324                    mi->output_gpios == NULL) {
325                         err = -ENODEV;
326                         pr_err("gpiomatrix: Incomplete pdata\n");
327                         goto err_invalid_platform_data;
328                 }
329                 key_count = mi->ninputs * mi->noutputs;
330
331                 *data = kp = kzalloc(sizeof(*kp) + sizeof(kp->keys_pressed[0]) *
332                                      BITS_TO_LONGS(key_count), GFP_KERNEL);
333                 if (kp == NULL) {
334                         err = -ENOMEM;
335                         pr_err("gpiomatrix: Failed to allocate private data\n");
336                         goto err_kp_alloc_failed;
337                 }
338                 kp->input_devs = input_devs;
339                 kp->keypad_info = mi;
340                 for (i = 0; i < key_count; i++) {
341                         unsigned short keyentry = mi->keymap[i];
342                         unsigned short keycode = keyentry & MATRIX_KEY_MASK;
343                         unsigned short dev = keyentry >> MATRIX_CODE_BITS;
344                         if (dev >= input_devs->count) {
345                                 pr_err("gpiomatrix: bad device index %d >= "
346                                         "%d for key code %d\n",
347                                         dev, input_devs->count, keycode);
348                                 err = -EINVAL;
349                                 goto err_bad_keymap;
350                         }
351                         if (keycode && keycode <= KEY_MAX)
352                                 input_set_capability(input_devs->dev[dev],
353                                                         EV_KEY, keycode);
354                 }
355
356                 for (i = 0; i < mi->noutputs; i++) {
357                         err = gpio_request(mi->output_gpios[i], "gpio_kp_out");
358                         if (err) {
359                                 pr_err("gpiomatrix: gpio_request failed for "
360                                         "output %d\n", mi->output_gpios[i]);
361                                 goto err_request_output_gpio_failed;
362                         }
363                         if (gpio_cansleep(mi->output_gpios[i])) {
364                                 pr_err("gpiomatrix: unsupported output gpio %d,"
365                                         " can sleep\n", mi->output_gpios[i]);
366                                 err = -EINVAL;
367                                 goto err_output_gpio_configure_failed;
368                         }
369                         if (mi->flags & GPIOKPF_DRIVE_INACTIVE)
370                                 err = gpio_direction_output(mi->output_gpios[i],
371                                         !(mi->flags & GPIOKPF_ACTIVE_HIGH));
372                         else
373                                 err = gpio_direction_input(mi->output_gpios[i]);
374                         if (err) {
375                                 pr_err("gpiomatrix: gpio_configure failed for "
376                                         "output %d\n", mi->output_gpios[i]);
377                                 goto err_output_gpio_configure_failed;
378                         }
379                 }
380                 for (i = 0; i < mi->ninputs; i++) {
381                         err = gpio_request(mi->input_gpios[i], "gpio_kp_in");
382                         if (err) {
383                                 pr_err("gpiomatrix: gpio_request failed for "
384                                         "input %d\n", mi->input_gpios[i]);
385                                 goto err_request_input_gpio_failed;
386                         }
387                         err = gpio_direction_input(mi->input_gpios[i]);
388                         if (err) {
389                                 pr_err("gpiomatrix: gpio_direction_input failed"
390                                         " for input %d\n", mi->input_gpios[i]);
391                                 goto err_gpio_direction_input_failed;
392                         }
393                 }
394                 kp->current_output = mi->noutputs;
395                 kp->key_state_changed = 1;
396
397                 hrtimer_init(&kp->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
398                 kp->timer.function = gpio_keypad_timer_func;
399                 wake_lock_init(&kp->wake_lock, WAKE_LOCK_SUSPEND, "gpio_kp");
400                 err = gpio_keypad_request_irqs(kp);
401                 kp->use_irq = err == 0;
402
403                 pr_info("GPIO Matrix Keypad Driver: Start keypad matrix for "
404                         "%s%s in %s mode\n", input_devs->dev[0]->name,
405                         (input_devs->count > 1) ? "..." : "",
406                         kp->use_irq ? "interrupt" : "polling");
407
408                 if (kp->use_irq)
409                         wake_lock(&kp->wake_lock);
410                 hrtimer_start(&kp->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
411
412                 return 0;
413         }
414
415         err = 0;
416         kp = *data;
417
418         if (kp->use_irq)
419                 for (i = mi->noutputs - 1; i >= 0; i--)
420                         free_irq(gpio_to_irq(mi->input_gpios[i]), kp);
421
422         hrtimer_cancel(&kp->timer);
423         wake_lock_destroy(&kp->wake_lock);
424         for (i = mi->noutputs - 1; i >= 0; i--) {
425 err_gpio_direction_input_failed:
426                 gpio_free(mi->input_gpios[i]);
427 err_request_input_gpio_failed:
428                 ;
429         }
430         for (i = mi->noutputs - 1; i >= 0; i--) {
431 err_output_gpio_configure_failed:
432                 gpio_free(mi->output_gpios[i]);
433 err_request_output_gpio_failed:
434                 ;
435         }
436 err_bad_keymap:
437         kfree(kp);
438 err_kp_alloc_failed:
439 err_invalid_platform_data:
440         return err;
441 }