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