1 /*
2  * Driver for the IMX keypad port.
3  * Copyright (C) 2009 Alberto Panizzo <maramaopercheseimorto@gmail.com>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  */
9 
10 #include <linux/clk.h>
11 #include <linux/delay.h>
12 #include <linux/device.h>
13 #include <linux/err.h>
14 #include <linux/input/matrix_keypad.h>
15 #include <linux/interrupt.h>
16 #include <linux/io.h>
17 #include <linux/jiffies.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/of.h>
21 #include <linux/platform_device.h>
22 #include <linux/slab.h>
23 #include <linux/timer.h>
24 
25 /*
26  * Keypad Controller registers (halfword)
27  */
28 #define KPCR		0x00 /* Keypad Control Register */
29 
30 #define KPSR		0x02 /* Keypad Status Register */
31 #define KBD_STAT_KPKD	(0x1 << 0) /* Key Press Interrupt Status bit (w1c) */
32 #define KBD_STAT_KPKR	(0x1 << 1) /* Key Release Interrupt Status bit (w1c) */
33 #define KBD_STAT_KDSC	(0x1 << 2) /* Key Depress Synch Chain Status bit (w1c)*/
34 #define KBD_STAT_KRSS	(0x1 << 3) /* Key Release Synch Status bit (w1c)*/
35 #define KBD_STAT_KDIE	(0x1 << 8) /* Key Depress Interrupt Enable Status bit */
36 #define KBD_STAT_KRIE	(0x1 << 9) /* Key Release Interrupt Enable */
37 #define KBD_STAT_KPPEN	(0x1 << 10) /* Keypad Clock Enable */
38 
39 #define KDDR		0x04 /* Keypad Data Direction Register */
40 #define KPDR		0x06 /* Keypad Data Register */
41 
42 #define MAX_MATRIX_KEY_ROWS	8
43 #define MAX_MATRIX_KEY_COLS	8
44 #define MATRIX_ROW_SHIFT	3
45 
46 #define MAX_MATRIX_KEY_NUM	(MAX_MATRIX_KEY_ROWS * MAX_MATRIX_KEY_COLS)
47 
48 struct imx_keypad {
49 
50 	struct clk *clk;
51 	struct input_dev *input_dev;
52 	void __iomem *mmio_base;
53 
54 	int			irq;
55 	struct timer_list	check_matrix_timer;
56 
57 	/*
58 	 * The matrix is stable only if no changes are detected after
59 	 * IMX_KEYPAD_SCANS_FOR_STABILITY scans
60 	 */
61 #define IMX_KEYPAD_SCANS_FOR_STABILITY 3
62 	int			stable_count;
63 
64 	bool			enabled;
65 
66 	/* Masks for enabled rows/cols */
67 	unsigned short		rows_en_mask;
68 	unsigned short		cols_en_mask;
69 
70 	unsigned short		keycodes[MAX_MATRIX_KEY_NUM];
71 
72 	/*
73 	 * Matrix states:
74 	 * -stable: achieved after a complete debounce process.
75 	 * -unstable: used in the debouncing process.
76 	 */
77 	unsigned short		matrix_stable_state[MAX_MATRIX_KEY_COLS];
78 	unsigned short		matrix_unstable_state[MAX_MATRIX_KEY_COLS];
79 };
80 
81 /* Scan the matrix and return the new state in *matrix_volatile_state. */
82 static void imx_keypad_scan_matrix(struct imx_keypad *keypad,
83 				  unsigned short *matrix_volatile_state)
84 {
85 	int col;
86 	unsigned short reg_val;
87 
88 	for (col = 0; col < MAX_MATRIX_KEY_COLS; col++) {
89 		if ((keypad->cols_en_mask & (1 << col)) == 0)
90 			continue;
91 		/*
92 		 * Discharge keypad capacitance:
93 		 * 2. write 1s on column data.
94 		 * 3. configure columns as totem-pole to discharge capacitance.
95 		 * 4. configure columns as open-drain.
96 		 */
97 		reg_val = readw(keypad->mmio_base + KPDR);
98 		reg_val |= 0xff00;
99 		writew(reg_val, keypad->mmio_base + KPDR);
100 
101 		reg_val = readw(keypad->mmio_base + KPCR);
102 		reg_val &= ~((keypad->cols_en_mask & 0xff) << 8);
103 		writew(reg_val, keypad->mmio_base + KPCR);
104 
105 		udelay(2);
106 
107 		reg_val = readw(keypad->mmio_base + KPCR);
108 		reg_val |= (keypad->cols_en_mask & 0xff) << 8;
109 		writew(reg_val, keypad->mmio_base + KPCR);
110 
111 		/*
112 		 * 5. Write a single column to 0, others to 1.
113 		 * 6. Sample row inputs and save data.
114 		 * 7. Repeat steps 2 - 6 for remaining columns.
115 		 */
116 		reg_val = readw(keypad->mmio_base + KPDR);
117 		reg_val &= ~(1 << (8 + col));
118 		writew(reg_val, keypad->mmio_base + KPDR);
119 
120 		/*
121 		 * Delay added to avoid propagating the 0 from column to row
122 		 * when scanning.
123 		 */
124 		udelay(5);
125 
126 		/*
127 		 * 1s in matrix_volatile_state[col] means key pressures
128 		 * throw data from non enabled rows.
129 		 */
130 		reg_val = readw(keypad->mmio_base + KPDR);
131 		matrix_volatile_state[col] = (~reg_val) & keypad->rows_en_mask;
132 	}
133 
134 	/*
135 	 * Return in standby mode:
136 	 * 9. write 0s to columns
137 	 */
138 	reg_val = readw(keypad->mmio_base + KPDR);
139 	reg_val &= 0x00ff;
140 	writew(reg_val, keypad->mmio_base + KPDR);
141 }
142 
143 /*
144  * Compare the new matrix state (volatile) with the stable one stored in
145  * keypad->matrix_stable_state and fire events if changes are detected.
146  */
147 static void imx_keypad_fire_events(struct imx_keypad *keypad,
148 				   unsigned short *matrix_volatile_state)
149 {
150 	struct input_dev *input_dev = keypad->input_dev;
151 	int row, col;
152 
153 	for (col = 0; col < MAX_MATRIX_KEY_COLS; col++) {
154 		unsigned short bits_changed;
155 		int code;
156 
157 		if ((keypad->cols_en_mask & (1 << col)) == 0)
158 			continue; /* Column is not enabled */
159 
160 		bits_changed = keypad->matrix_stable_state[col] ^
161 						matrix_volatile_state[col];
162 
163 		if (bits_changed == 0)
164 			continue; /* Column does not contain changes */
165 
166 		for (row = 0; row < MAX_MATRIX_KEY_ROWS; row++) {
167 			if ((keypad->rows_en_mask & (1 << row)) == 0)
168 				continue; /* Row is not enabled */
169 			if ((bits_changed & (1 << row)) == 0)
170 				continue; /* Row does not contain changes */
171 
172 			code = MATRIX_SCAN_CODE(row, col, MATRIX_ROW_SHIFT);
173 			input_event(input_dev, EV_MSC, MSC_SCAN, code);
174 			input_report_key(input_dev, keypad->keycodes[code],
175 				matrix_volatile_state[col] & (1 << row));
176 			dev_dbg(&input_dev->dev, "Event code: %d, val: %d",
177 				keypad->keycodes[code],
178 				matrix_volatile_state[col] & (1 << row));
179 		}
180 	}
181 	input_sync(input_dev);
182 }
183 
184 /*
185  * imx_keypad_check_for_events is the timer handler.
186  */
187 static void imx_keypad_check_for_events(unsigned long data)
188 {
189 	struct imx_keypad *keypad = (struct imx_keypad *) data;
190 	unsigned short matrix_volatile_state[MAX_MATRIX_KEY_COLS];
191 	unsigned short reg_val;
192 	bool state_changed, is_zero_matrix;
193 	int i;
194 
195 	memset(matrix_volatile_state, 0, sizeof(matrix_volatile_state));
196 
197 	imx_keypad_scan_matrix(keypad, matrix_volatile_state);
198 
199 	state_changed = false;
200 	for (i = 0; i < MAX_MATRIX_KEY_COLS; i++) {
201 		if ((keypad->cols_en_mask & (1 << i)) == 0)
202 			continue;
203 
204 		if (keypad->matrix_unstable_state[i] ^ matrix_volatile_state[i]) {
205 			state_changed = true;
206 			break;
207 		}
208 	}
209 
210 	/*
211 	 * If the matrix state is changed from the previous scan
212 	 *   (Re)Begin the debouncing process, saving the new state in
213 	 *    keypad->matrix_unstable_state.
214 	 * else
215 	 *   Increase the count of number of scans with a stable state.
216 	 */
217 	if (state_changed) {
218 		memcpy(keypad->matrix_unstable_state, matrix_volatile_state,
219 			sizeof(matrix_volatile_state));
220 		keypad->stable_count = 0;
221 	} else
222 		keypad->stable_count++;
223 
224 	/*
225 	 * If the matrix is not as stable as we want reschedule scan
226 	 * in the near future.
227 	 */
228 	if (keypad->stable_count < IMX_KEYPAD_SCANS_FOR_STABILITY) {
229 		mod_timer(&keypad->check_matrix_timer,
230 			  jiffies + msecs_to_jiffies(10));
231 		return;
232 	}
233 
234 	/*
235 	 * If the matrix state is stable, fire the events and save the new
236 	 * stable state. Note, if the matrix is kept stable for longer
237 	 * (keypad->stable_count > IMX_KEYPAD_SCANS_FOR_STABILITY) all
238 	 * events have already been generated.
239 	 */
240 	if (keypad->stable_count == IMX_KEYPAD_SCANS_FOR_STABILITY) {
241 		imx_keypad_fire_events(keypad, matrix_volatile_state);
242 
243 		memcpy(keypad->matrix_stable_state, matrix_volatile_state,
244 			sizeof(matrix_volatile_state));
245 	}
246 
247 	is_zero_matrix = true;
248 	for (i = 0; i < MAX_MATRIX_KEY_COLS; i++) {
249 		if (matrix_volatile_state[i] != 0) {
250 			is_zero_matrix = false;
251 			break;
252 		}
253 	}
254 
255 
256 	if (is_zero_matrix) {
257 		/*
258 		 * All keys have been released. Enable only the KDI
259 		 * interrupt for future key presses (clear the KDI
260 		 * status bit and its sync chain before that).
261 		 */
262 		reg_val = readw(keypad->mmio_base + KPSR);
263 		reg_val |= KBD_STAT_KPKD | KBD_STAT_KDSC;
264 		writew(reg_val, keypad->mmio_base + KPSR);
265 
266 		reg_val = readw(keypad->mmio_base + KPSR);
267 		reg_val |= KBD_STAT_KDIE;
268 		reg_val &= ~KBD_STAT_KRIE;
269 		writew(reg_val, keypad->mmio_base + KPSR);
270 	} else {
271 		/*
272 		 * Some keys are still pressed. Schedule a rescan in
273 		 * attempt to detect multiple key presses and enable
274 		 * the KRI interrupt to react quickly to key release
275 		 * event.
276 		 */
277 		mod_timer(&keypad->check_matrix_timer,
278 			  jiffies + msecs_to_jiffies(60));
279 
280 		reg_val = readw(keypad->mmio_base + KPSR);
281 		reg_val |= KBD_STAT_KPKR | KBD_STAT_KRSS;
282 		writew(reg_val, keypad->mmio_base + KPSR);
283 
284 		reg_val = readw(keypad->mmio_base + KPSR);
285 		reg_val |= KBD_STAT_KRIE;
286 		reg_val &= ~KBD_STAT_KDIE;
287 		writew(reg_val, keypad->mmio_base + KPSR);
288 	}
289 }
290 
291 static irqreturn_t imx_keypad_irq_handler(int irq, void *dev_id)
292 {
293 	struct imx_keypad *keypad = dev_id;
294 	unsigned short reg_val;
295 
296 	reg_val = readw(keypad->mmio_base + KPSR);
297 
298 	/* Disable both interrupt types */
299 	reg_val &= ~(KBD_STAT_KRIE | KBD_STAT_KDIE);
300 	/* Clear interrupts status bits */
301 	reg_val |= KBD_STAT_KPKR | KBD_STAT_KPKD;
302 	writew(reg_val, keypad->mmio_base + KPSR);
303 
304 	if (keypad->enabled) {
305 		/* The matrix is supposed to be changed */
306 		keypad->stable_count = 0;
307 
308 		/* Schedule the scanning procedure near in the future */
309 		mod_timer(&keypad->check_matrix_timer,
310 			  jiffies + msecs_to_jiffies(2));
311 	}
312 
313 	return IRQ_HANDLED;
314 }
315 
316 static void imx_keypad_config(struct imx_keypad *keypad)
317 {
318 	unsigned short reg_val;
319 
320 	/*
321 	 * Include enabled rows in interrupt generation (KPCR[7:0])
322 	 * Configure keypad columns as open-drain (KPCR[15:8])
323 	 */
324 	reg_val = readw(keypad->mmio_base + KPCR);
325 	reg_val |= keypad->rows_en_mask & 0xff;		/* rows */
326 	reg_val |= (keypad->cols_en_mask & 0xff) << 8;	/* cols */
327 	writew(reg_val, keypad->mmio_base + KPCR);
328 
329 	/* Write 0's to KPDR[15:8] (Colums) */
330 	reg_val = readw(keypad->mmio_base + KPDR);
331 	reg_val &= 0x00ff;
332 	writew(reg_val, keypad->mmio_base + KPDR);
333 
334 	/* Configure columns as output, rows as input (KDDR[15:0]) */
335 	writew(0xff00, keypad->mmio_base + KDDR);
336 
337 	/*
338 	 * Clear Key Depress and Key Release status bit.
339 	 * Clear both synchronizer chain.
340 	 */
341 	reg_val = readw(keypad->mmio_base + KPSR);
342 	reg_val |= KBD_STAT_KPKR | KBD_STAT_KPKD |
343 		   KBD_STAT_KDSC | KBD_STAT_KRSS;
344 	writew(reg_val, keypad->mmio_base + KPSR);
345 
346 	/* Enable KDI and disable KRI (avoid false release events). */
347 	reg_val |= KBD_STAT_KDIE;
348 	reg_val &= ~KBD_STAT_KRIE;
349 	writew(reg_val, keypad->mmio_base + KPSR);
350 }
351 
352 static void imx_keypad_inhibit(struct imx_keypad *keypad)
353 {
354 	unsigned short reg_val;
355 
356 	/* Inhibit KDI and KRI interrupts. */
357 	reg_val = readw(keypad->mmio_base + KPSR);
358 	reg_val &= ~(KBD_STAT_KRIE | KBD_STAT_KDIE);
359 	reg_val |= KBD_STAT_KPKR | KBD_STAT_KPKD;
360 	writew(reg_val, keypad->mmio_base + KPSR);
361 
362 	/* Colums as open drain and disable all rows */
363 	reg_val = (keypad->cols_en_mask & 0xff) << 8;
364 	writew(reg_val, keypad->mmio_base + KPCR);
365 }
366 
367 static void imx_keypad_close(struct input_dev *dev)
368 {
369 	struct imx_keypad *keypad = input_get_drvdata(dev);
370 
371 	dev_dbg(&dev->dev, ">%s\n", __func__);
372 
373 	/* Mark keypad as being inactive */
374 	keypad->enabled = false;
375 	synchronize_irq(keypad->irq);
376 	del_timer_sync(&keypad->check_matrix_timer);
377 
378 	imx_keypad_inhibit(keypad);
379 
380 	/* Disable clock unit */
381 	clk_disable_unprepare(keypad->clk);
382 }
383 
384 static int imx_keypad_open(struct input_dev *dev)
385 {
386 	struct imx_keypad *keypad = input_get_drvdata(dev);
387 	int error;
388 
389 	dev_dbg(&dev->dev, ">%s\n", __func__);
390 
391 	/* Enable the kpp clock */
392 	error = clk_prepare_enable(keypad->clk);
393 	if (error)
394 		return error;
395 
396 	/* We became active from now */
397 	keypad->enabled = true;
398 
399 	imx_keypad_config(keypad);
400 
401 	/* Sanity control, not all the rows must be actived now. */
402 	if ((readw(keypad->mmio_base + KPDR) & keypad->rows_en_mask) == 0) {
403 		dev_err(&dev->dev,
404 			"too many keys pressed, control pins initialisation\n");
405 		goto open_err;
406 	}
407 
408 	return 0;
409 
410 open_err:
411 	imx_keypad_close(dev);
412 	return -EIO;
413 }
414 
415 #ifdef CONFIG_OF
416 static const struct of_device_id imx_keypad_of_match[] = {
417 	{ .compatible = "fsl,imx21-kpp", },
418 	{ /* sentinel */ }
419 };
420 MODULE_DEVICE_TABLE(of, imx_keypad_of_match);
421 #endif
422 
423 static int imx_keypad_probe(struct platform_device *pdev)
424 {
425 	const struct matrix_keymap_data *keymap_data =
426 			dev_get_platdata(&pdev->dev);
427 	struct imx_keypad *keypad;
428 	struct input_dev *input_dev;
429 	struct resource *res;
430 	int irq, error, i, row, col;
431 
432 	if (!keymap_data && !pdev->dev.of_node) {
433 		dev_err(&pdev->dev, "no keymap defined\n");
434 		return -EINVAL;
435 	}
436 
437 	irq = platform_get_irq(pdev, 0);
438 	if (irq < 0) {
439 		dev_err(&pdev->dev, "no irq defined in platform data\n");
440 		return irq;
441 	}
442 
443 	input_dev = devm_input_allocate_device(&pdev->dev);
444 	if (!input_dev) {
445 		dev_err(&pdev->dev, "failed to allocate the input device\n");
446 		return -ENOMEM;
447 	}
448 
449 	keypad = devm_kzalloc(&pdev->dev, sizeof(*keypad), GFP_KERNEL);
450 	if (!keypad) {
451 		dev_err(&pdev->dev, "not enough memory for driver data\n");
452 		return -ENOMEM;
453 	}
454 
455 	keypad->input_dev = input_dev;
456 	keypad->irq = irq;
457 	keypad->stable_count = 0;
458 
459 	setup_timer(&keypad->check_matrix_timer,
460 		    imx_keypad_check_for_events, (unsigned long) keypad);
461 
462 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
463 	keypad->mmio_base = devm_ioremap_resource(&pdev->dev, res);
464 	if (IS_ERR(keypad->mmio_base))
465 		return PTR_ERR(keypad->mmio_base);
466 
467 	keypad->clk = devm_clk_get(&pdev->dev, NULL);
468 	if (IS_ERR(keypad->clk)) {
469 		dev_err(&pdev->dev, "failed to get keypad clock\n");
470 		return PTR_ERR(keypad->clk);
471 	}
472 
473 	/* Init the Input device */
474 	input_dev->name = pdev->name;
475 	input_dev->id.bustype = BUS_HOST;
476 	input_dev->dev.parent = &pdev->dev;
477 	input_dev->open = imx_keypad_open;
478 	input_dev->close = imx_keypad_close;
479 
480 	error = matrix_keypad_build_keymap(keymap_data, NULL,
481 					   MAX_MATRIX_KEY_ROWS,
482 					   MAX_MATRIX_KEY_COLS,
483 					   keypad->keycodes, input_dev);
484 	if (error) {
485 		dev_err(&pdev->dev, "failed to build keymap\n");
486 		return error;
487 	}
488 
489 	/* Search for rows and cols enabled */
490 	for (row = 0; row < MAX_MATRIX_KEY_ROWS; row++) {
491 		for (col = 0; col < MAX_MATRIX_KEY_COLS; col++) {
492 			i = MATRIX_SCAN_CODE(row, col, MATRIX_ROW_SHIFT);
493 			if (keypad->keycodes[i] != KEY_RESERVED) {
494 				keypad->rows_en_mask |= 1 << row;
495 				keypad->cols_en_mask |= 1 << col;
496 			}
497 		}
498 	}
499 	dev_dbg(&pdev->dev, "enabled rows mask: %x\n", keypad->rows_en_mask);
500 	dev_dbg(&pdev->dev, "enabled cols mask: %x\n", keypad->cols_en_mask);
501 
502 	__set_bit(EV_REP, input_dev->evbit);
503 	input_set_capability(input_dev, EV_MSC, MSC_SCAN);
504 	input_set_drvdata(input_dev, keypad);
505 
506 	/* Ensure that the keypad will stay dormant until opened */
507 	error = clk_prepare_enable(keypad->clk);
508 	if (error)
509 		return error;
510 	imx_keypad_inhibit(keypad);
511 	clk_disable_unprepare(keypad->clk);
512 
513 	error = devm_request_irq(&pdev->dev, irq, imx_keypad_irq_handler, 0,
514 			    pdev->name, keypad);
515 	if (error) {
516 		dev_err(&pdev->dev, "failed to request IRQ\n");
517 		return error;
518 	}
519 
520 	/* Register the input device */
521 	error = input_register_device(input_dev);
522 	if (error) {
523 		dev_err(&pdev->dev, "failed to register input device\n");
524 		return error;
525 	}
526 
527 	platform_set_drvdata(pdev, keypad);
528 	device_init_wakeup(&pdev->dev, 1);
529 
530 	return 0;
531 }
532 
533 static int __maybe_unused imx_kbd_suspend(struct device *dev)
534 {
535 	struct platform_device *pdev = to_platform_device(dev);
536 	struct imx_keypad *kbd = platform_get_drvdata(pdev);
537 	struct input_dev *input_dev = kbd->input_dev;
538 
539 	/* imx kbd can wake up system even clock is disabled */
540 	mutex_lock(&input_dev->mutex);
541 
542 	if (input_dev->users)
543 		clk_disable_unprepare(kbd->clk);
544 
545 	mutex_unlock(&input_dev->mutex);
546 
547 	if (device_may_wakeup(&pdev->dev))
548 		enable_irq_wake(kbd->irq);
549 
550 	return 0;
551 }
552 
553 static int __maybe_unused imx_kbd_resume(struct device *dev)
554 {
555 	struct platform_device *pdev = to_platform_device(dev);
556 	struct imx_keypad *kbd = platform_get_drvdata(pdev);
557 	struct input_dev *input_dev = kbd->input_dev;
558 	int ret = 0;
559 
560 	if (device_may_wakeup(&pdev->dev))
561 		disable_irq_wake(kbd->irq);
562 
563 	mutex_lock(&input_dev->mutex);
564 
565 	if (input_dev->users) {
566 		ret = clk_prepare_enable(kbd->clk);
567 		if (ret)
568 			goto err_clk;
569 	}
570 
571 err_clk:
572 	mutex_unlock(&input_dev->mutex);
573 
574 	return ret;
575 }
576 
577 static SIMPLE_DEV_PM_OPS(imx_kbd_pm_ops, imx_kbd_suspend, imx_kbd_resume);
578 
579 static struct platform_driver imx_keypad_driver = {
580 	.driver		= {
581 		.name	= "imx-keypad",
582 		.pm	= &imx_kbd_pm_ops,
583 		.of_match_table = of_match_ptr(imx_keypad_of_match),
584 	},
585 	.probe		= imx_keypad_probe,
586 };
587 module_platform_driver(imx_keypad_driver);
588 
589 MODULE_AUTHOR("Alberto Panizzo <maramaopercheseimorto@gmail.com>");
590 MODULE_DESCRIPTION("IMX Keypad Port Driver");
591 MODULE_LICENSE("GPL v2");
592 MODULE_ALIAS("platform:imx-keypad");
593