1 /* drivers/input/misc/gpio_matrix.c
3 * Copyright (C) 2007 Google, Inc.
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.
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.
16 #include <linux/kernel.h>
17 #include <linux/slab.h>
18 #include <linux/gpio.h>
19 #include <linux/gpio_event.h>
20 #include <linux/hrtimer.h>
21 #include <linux/interrupt.h>
24 struct input_dev
*input_dev
;
25 struct gpio_event_matrix_info
*keypad_info
;
28 unsigned int use_irq
:1;
29 unsigned int key_state_changed
:1;
30 unsigned int last_key_state_changed
:1;
31 unsigned int some_keys_pressed
:2;
32 unsigned long keys_pressed
[0];
35 static void clear_phantom_key(struct gpio_kp
*kp
, int out
, int in
)
37 struct gpio_event_matrix_info
*mi
= kp
->keypad_info
;
38 int key_index
= out
* mi
->ninputs
+ in
;
39 unsigned short keycode
= mi
->keymap
[key_index
];;
41 if (!test_bit(keycode
, kp
->input_dev
->key
)) {
42 if (mi
->flags
& GPIOKPF_PRINT_PHANTOM_KEYS
)
43 pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
44 "cleared\n", keycode
, out
, in
,
45 mi
->output_gpios
[out
], mi
->input_gpios
[in
]);
46 __clear_bit(key_index
, kp
->keys_pressed
);
48 if (mi
->flags
& GPIOKPF_PRINT_PHANTOM_KEYS
)
49 pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
50 "not cleared\n", keycode
, out
, in
,
51 mi
->output_gpios
[out
], mi
->input_gpios
[in
]);
55 static int restore_keys_for_input(struct gpio_kp
*kp
, int out
, int in
)
60 key_index
= out
* kp
->keypad_info
->ninputs
+ in
;
61 while (out
< kp
->keypad_info
->noutputs
) {
62 if (test_bit(key_index
, kp
->keys_pressed
)) {
64 clear_phantom_key(kp
, out
, in
);
66 key_index
+= kp
->keypad_info
->ninputs
;
72 static void remove_phantom_keys(struct gpio_kp
*kp
)
77 if (kp
->some_keys_pressed
< 3)
80 for (out
= 0; out
< kp
->keypad_info
->noutputs
; out
++) {
82 key_index
= out
* kp
->keypad_info
->ninputs
;
83 for (in
= 0; in
< kp
->keypad_info
->ninputs
; in
++, key_index
++) {
84 if (test_bit(key_index
, kp
->keys_pressed
)) {
90 if (!restore_keys_for_input(kp
, out
+ 1,
93 clear_phantom_key(kp
, out
, inp
);
96 restore_keys_for_input(kp
, out
, in
);
102 static void report_key(struct gpio_kp
*kp
, int key_index
, int out
, int in
)
104 struct gpio_event_matrix_info
*mi
= kp
->keypad_info
;
105 int pressed
= test_bit(key_index
, kp
->keys_pressed
);
106 unsigned short keycode
= mi
->keymap
[key_index
];
107 if (pressed
!= test_bit(keycode
, kp
->input_dev
->key
)) {
108 if (keycode
== KEY_RESERVED
) {
109 if (mi
->flags
& GPIOKPF_PRINT_UNMAPPED_KEYS
)
110 pr_info("gpiomatrix: unmapped key, %d-%d "
111 "(%d-%d) changed to %d\n",
112 out
, in
, mi
->output_gpios
[out
],
113 mi
->input_gpios
[in
], pressed
);
115 if (mi
->flags
& GPIOKPF_PRINT_MAPPED_KEYS
)
116 pr_info("gpiomatrix: key %x, %d-%d (%d-%d) "
117 "changed to %d\n", keycode
,
118 out
, in
, mi
->output_gpios
[out
],
119 mi
->input_gpios
[in
], pressed
);
120 input_report_key(kp
->input_dev
, keycode
, pressed
);
125 static enum hrtimer_restart
gpio_keypad_timer_func(struct hrtimer
*timer
)
130 struct gpio_kp
*kp
= container_of(timer
, struct gpio_kp
, timer
);
131 struct gpio_event_matrix_info
*mi
= kp
->keypad_info
;
132 unsigned gpio_keypad_flags
= mi
->flags
;
133 unsigned polarity
= !!(gpio_keypad_flags
& GPIOKPF_ACTIVE_HIGH
);
135 out
= kp
->current_output
;
136 if (out
== mi
->noutputs
) {
138 kp
->last_key_state_changed
= kp
->key_state_changed
;
139 kp
->key_state_changed
= 0;
140 kp
->some_keys_pressed
= 0;
142 key_index
= out
* mi
->ninputs
;
143 for (in
= 0; in
< mi
->ninputs
; in
++, key_index
++) {
144 gpio
= mi
->input_gpios
[in
];
145 if (gpio_get_value(gpio
) ^ !polarity
) {
146 if (kp
->some_keys_pressed
< 3)
147 kp
->some_keys_pressed
++;
148 kp
->key_state_changed
|= !__test_and_set_bit(
149 key_index
, kp
->keys_pressed
);
151 kp
->key_state_changed
|= __test_and_clear_bit(
152 key_index
, kp
->keys_pressed
);
154 gpio
= mi
->output_gpios
[out
];
155 if (gpio_keypad_flags
& GPIOKPF_DRIVE_INACTIVE
)
156 gpio_set_value(gpio
, !polarity
);
158 gpio_direction_input(gpio
);
161 kp
->current_output
= out
;
162 if (out
< mi
->noutputs
) {
163 gpio
= mi
->output_gpios
[out
];
164 if (gpio_keypad_flags
& GPIOKPF_DRIVE_INACTIVE
)
165 gpio_set_value(gpio
, polarity
);
167 gpio_direction_output(gpio
, polarity
);
168 hrtimer_start(timer
, mi
->settle_time
, HRTIMER_MODE_REL
);
169 return HRTIMER_NORESTART
;
171 if (gpio_keypad_flags
& GPIOKPF_DEBOUNCE
) {
172 if (kp
->key_state_changed
) {
173 hrtimer_start(&kp
->timer
, mi
->debounce_delay
,
175 return HRTIMER_NORESTART
;
177 kp
->key_state_changed
= kp
->last_key_state_changed
;
179 if (kp
->key_state_changed
) {
180 if (gpio_keypad_flags
& GPIOKPF_REMOVE_SOME_PHANTOM_KEYS
)
181 remove_phantom_keys(kp
);
183 for (out
= 0; out
< mi
->noutputs
; out
++)
184 for (in
= 0; in
< mi
->ninputs
; in
++, key_index
++)
185 report_key(kp
, key_index
, out
, in
);
187 if (!kp
->use_irq
|| kp
->some_keys_pressed
) {
188 hrtimer_start(timer
, mi
->poll_time
, HRTIMER_MODE_REL
);
189 return HRTIMER_NORESTART
;
192 /* No keys are pressed, reenable interrupt */
193 for (out
= 0; out
< mi
->noutputs
; out
++) {
194 if (gpio_keypad_flags
& GPIOKPF_DRIVE_INACTIVE
)
195 gpio_set_value(mi
->output_gpios
[out
], polarity
);
197 gpio_direction_output(mi
->output_gpios
[out
], polarity
);
199 for (in
= 0; in
< mi
->ninputs
; in
++)
200 enable_irq(gpio_to_irq(mi
->input_gpios
[in
]));
201 return HRTIMER_NORESTART
;
204 static irqreturn_t
gpio_keypad_irq_handler(int irq_in
, void *dev_id
)
207 struct gpio_kp
*kp
= dev_id
;
208 struct gpio_event_matrix_info
*mi
= kp
->keypad_info
;
209 unsigned gpio_keypad_flags
= mi
->flags
;
211 if (!kp
->use_irq
) /* ignore interrupt while registering the handler */
214 for (i
= 0; i
< mi
->ninputs
; i
++)
215 disable_irq(gpio_to_irq(mi
->input_gpios
[i
]));
216 for (i
= 0; i
< mi
->noutputs
; i
++) {
217 if (gpio_keypad_flags
& GPIOKPF_DRIVE_INACTIVE
)
218 gpio_set_value(mi
->output_gpios
[i
],
219 !(gpio_keypad_flags
& GPIOKPF_ACTIVE_HIGH
));
221 gpio_direction_input(mi
->output_gpios
[i
]);
223 hrtimer_start(&kp
->timer
, ktime_set(0, 0), HRTIMER_MODE_REL
);
227 static int gpio_keypad_request_irqs(struct gpio_kp
*kp
)
232 unsigned long request_flags
;
233 struct gpio_event_matrix_info
*mi
= kp
->keypad_info
;
235 switch (mi
->flags
& (GPIOKPF_ACTIVE_HIGH
|GPIOKPF_LEVEL_TRIGGERED_IRQ
)) {
237 request_flags
= IRQF_TRIGGER_FALLING
;
239 case GPIOKPF_ACTIVE_HIGH
:
240 request_flags
= IRQF_TRIGGER_RISING
;
242 case GPIOKPF_LEVEL_TRIGGERED_IRQ
:
243 request_flags
= IRQF_TRIGGER_LOW
;
245 case GPIOKPF_LEVEL_TRIGGERED_IRQ
| GPIOKPF_ACTIVE_HIGH
:
246 request_flags
= IRQF_TRIGGER_HIGH
;
250 for (i
= 0; i
< mi
->ninputs
; i
++) {
251 err
= irq
= gpio_to_irq(mi
->input_gpios
[i
]);
253 goto err_gpio_get_irq_num_failed
;
254 err
= request_irq(irq
, gpio_keypad_irq_handler
, request_flags
,
257 pr_err("gpiomatrix: request_irq failed for input %d, "
258 "irq %d\n", mi
->input_gpios
[i
], irq
);
259 goto err_request_irq_failed
;
261 err
= set_irq_wake(irq
, 1);
263 pr_err("gpiomatrix: set_irq_wake failed for input %d, "
264 "irq %d\n", mi
->input_gpios
[i
], irq
);
270 for (i
= mi
->noutputs
- 1; i
>= 0; i
--) {
271 free_irq(gpio_to_irq(mi
->input_gpios
[i
]), kp
);
272 err_request_irq_failed
:
273 err_gpio_get_irq_num_failed
:
279 int gpio_event_matrix_func(struct input_dev
*input_dev
,
280 struct gpio_event_info
*info
, void **data
, int func
)
286 struct gpio_event_matrix_info
*mi
;
288 mi
= container_of(info
, struct gpio_event_matrix_info
, info
);
289 if (func
== GPIO_EVENT_FUNC_SUSPEND
|| func
== GPIO_EVENT_FUNC_RESUME
) {
290 /* TODO: disable scanning */
294 if (func
== GPIO_EVENT_FUNC_INIT
) {
295 if (mi
->keymap
== NULL
||
296 mi
->input_gpios
== NULL
||
297 mi
->output_gpios
== NULL
) {
299 pr_err("gpiomatrix: Incomplete pdata\n");
300 goto err_invalid_platform_data
;
302 key_count
= mi
->ninputs
* mi
->noutputs
;
304 *data
= kp
= kzalloc(sizeof(*kp
) + sizeof(kp
->keys_pressed
[0]) *
305 BITS_TO_LONGS(key_count
), GFP_KERNEL
);
308 pr_err("gpiomatrix: Failed to allocate private data\n");
309 goto err_kp_alloc_failed
;
311 kp
->input_dev
= input_dev
;
312 kp
->keypad_info
= mi
;
313 set_bit(EV_KEY
, input_dev
->evbit
);
314 for (i
= 0; i
< key_count
; i
++) {
316 set_bit(mi
->keymap
[i
] & KEY_MAX
,
320 for (i
= 0; i
< mi
->noutputs
; i
++) {
321 if (gpio_cansleep(mi
->output_gpios
[i
])) {
322 pr_err("gpiomatrix: unsupported output gpio %d,"
323 " can sleep\n", mi
->output_gpios
[i
]);
325 goto err_request_output_gpio_failed
;
327 err
= gpio_request(mi
->output_gpios
[i
], "gpio_kp_out");
329 pr_err("gpiomatrix: gpio_request failed for "
330 "output %d\n", mi
->output_gpios
[i
]);
331 goto err_request_output_gpio_failed
;
333 if (mi
->flags
& GPIOKPF_DRIVE_INACTIVE
)
334 err
= gpio_direction_output(mi
->output_gpios
[i
],
335 !(mi
->flags
& GPIOKPF_ACTIVE_HIGH
));
337 err
= gpio_direction_input(mi
->output_gpios
[i
]);
339 pr_err("gpiomatrix: gpio_configure failed for "
340 "output %d\n", mi
->output_gpios
[i
]);
341 goto err_output_gpio_configure_failed
;
344 for (i
= 0; i
< mi
->ninputs
; i
++) {
345 err
= gpio_request(mi
->input_gpios
[i
], "gpio_kp_in");
347 pr_err("gpiomatrix: gpio_request failed for "
348 "input %d\n", mi
->input_gpios
[i
]);
349 goto err_request_input_gpio_failed
;
351 err
= gpio_direction_input(mi
->input_gpios
[i
]);
353 pr_err("gpiomatrix: gpio_direction_input failed"
354 " for input %d\n", mi
->input_gpios
[i
]);
355 goto err_gpio_direction_input_failed
;
358 kp
->current_output
= mi
->noutputs
;
359 kp
->key_state_changed
= 1;
361 hrtimer_init(&kp
->timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
362 kp
->timer
.function
= gpio_keypad_timer_func
;
363 err
= gpio_keypad_request_irqs(kp
);
364 kp
->use_irq
= err
== 0;
366 pr_info("GPIO Matrix Keypad Driver: Start keypad matrix for %s "
367 "in %s mode\n", input_dev
->name
,
368 kp
->use_irq
? "interrupt" : "polling");
370 hrtimer_start(&kp
->timer
, ktime_set(0, 0), HRTIMER_MODE_REL
);
379 for (i
= mi
->noutputs
- 1; i
>= 0; i
--)
380 free_irq(gpio_to_irq(mi
->input_gpios
[i
]), kp
);
382 hrtimer_cancel(&kp
->timer
);
383 for (i
= mi
->noutputs
- 1; i
>= 0; i
--) {
384 err_gpio_direction_input_failed
:
385 gpio_free(mi
->input_gpios
[i
]);
386 err_request_input_gpio_failed
:
389 for (i
= mi
->noutputs
- 1; i
>= 0; i
--) {
390 err_output_gpio_configure_failed
:
391 gpio_free(mi
->output_gpios
[i
]);
392 err_request_output_gpio_failed
:
397 err_invalid_platform_data
: