1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * OMAP4 Keypad Driver
4  *
5  * Copyright (C) 2010 Texas Instruments
6  *
7  * Author: Abraham Arce <x0066660@ti.com>
8  * Initial Code: Syed Rafiuddin <rafiuddin.syed@ti.com>
9  */
10 
11 #include <linux/module.h>
12 #include <linux/interrupt.h>
13 #include <linux/platform_device.h>
14 #include <linux/errno.h>
15 #include <linux/io.h>
16 #include <linux/of.h>
17 #include <linux/input.h>
18 #include <linux/input/matrix_keypad.h>
19 #include <linux/slab.h>
20 #include <linux/pm_runtime.h>
21 
22 /* OMAP4 registers */
23 #define OMAP4_KBD_REVISION		0x00
24 #define OMAP4_KBD_SYSCONFIG		0x10
25 #define OMAP4_KBD_SYSSTATUS		0x14
26 #define OMAP4_KBD_IRQSTATUS		0x18
27 #define OMAP4_KBD_IRQENABLE		0x1C
28 #define OMAP4_KBD_WAKEUPENABLE		0x20
29 #define OMAP4_KBD_PENDING		0x24
30 #define OMAP4_KBD_CTRL			0x28
31 #define OMAP4_KBD_DEBOUNCINGTIME	0x2C
32 #define OMAP4_KBD_LONGKEYTIME		0x30
33 #define OMAP4_KBD_TIMEOUT		0x34
34 #define OMAP4_KBD_STATEMACHINE		0x38
35 #define OMAP4_KBD_ROWINPUTS		0x3C
36 #define OMAP4_KBD_COLUMNOUTPUTS		0x40
37 #define OMAP4_KBD_FULLCODE31_0		0x44
38 #define OMAP4_KBD_FULLCODE63_32		0x48
39 
40 /* OMAP4 bit definitions */
41 #define OMAP4_DEF_IRQENABLE_EVENTEN	BIT(0)
42 #define OMAP4_DEF_IRQENABLE_LONGKEY	BIT(1)
43 #define OMAP4_DEF_WUP_EVENT_ENA		BIT(0)
44 #define OMAP4_DEF_WUP_LONG_KEY_ENA	BIT(1)
45 #define OMAP4_DEF_CTRL_NOSOFTMODE	BIT(1)
46 #define OMAP4_DEF_CTRL_PTV_SHIFT	2
47 
48 /* OMAP4 values */
49 #define OMAP4_VAL_IRQDISABLE		0x0
50 
51 /*
52  * Errata i689: If a key is released for a time shorter than debounce time,
53  * the keyboard will idle and never detect the key release. The workaround
54  * is to use at least a 12ms debounce time. See omap5432 TRM chapter
55  * "26.4.6.2 Keyboard Controller Timer" for more information.
56  */
57 #define OMAP4_KEYPAD_PTV_DIV_128        0x6
58 #define OMAP4_KEYPAD_DEBOUNCINGTIME_MS(dbms, ptv)     \
59 	((((dbms) * 1000) / ((1 << ((ptv) + 1)) * (1000000 / 32768))) - 1)
60 #define OMAP4_VAL_DEBOUNCINGTIME_16MS					\
61 	OMAP4_KEYPAD_DEBOUNCINGTIME_MS(16, OMAP4_KEYPAD_PTV_DIV_128)
62 
63 enum {
64 	KBD_REVISION_OMAP4 = 0,
65 	KBD_REVISION_OMAP5,
66 };
67 
68 struct omap4_keypad {
69 	struct input_dev *input;
70 
71 	void __iomem *base;
72 	bool irq_wake_enabled;
73 	unsigned int irq;
74 
75 	unsigned int rows;
76 	unsigned int cols;
77 	u32 reg_offset;
78 	u32 irqreg_offset;
79 	unsigned int row_shift;
80 	bool no_autorepeat;
81 	unsigned char key_state[8];
82 	unsigned short *keymap;
83 };
84 
85 static int kbd_readl(struct omap4_keypad *keypad_data, u32 offset)
86 {
87 	return __raw_readl(keypad_data->base +
88 				keypad_data->reg_offset + offset);
89 }
90 
91 static void kbd_writel(struct omap4_keypad *keypad_data, u32 offset, u32 value)
92 {
93 	__raw_writel(value,
94 		     keypad_data->base + keypad_data->reg_offset + offset);
95 }
96 
97 static int kbd_read_irqreg(struct omap4_keypad *keypad_data, u32 offset)
98 {
99 	return __raw_readl(keypad_data->base +
100 				keypad_data->irqreg_offset + offset);
101 }
102 
103 static void kbd_write_irqreg(struct omap4_keypad *keypad_data,
104 			     u32 offset, u32 value)
105 {
106 	__raw_writel(value,
107 		     keypad_data->base + keypad_data->irqreg_offset + offset);
108 }
109 
110 
111 /* Interrupt handlers */
112 static irqreturn_t omap4_keypad_irq_handler(int irq, void *dev_id)
113 {
114 	struct omap4_keypad *keypad_data = dev_id;
115 
116 	if (kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS))
117 		return IRQ_WAKE_THREAD;
118 
119 	return IRQ_NONE;
120 }
121 
122 static irqreturn_t omap4_keypad_irq_thread_fn(int irq, void *dev_id)
123 {
124 	struct omap4_keypad *keypad_data = dev_id;
125 	struct input_dev *input_dev = keypad_data->input;
126 	unsigned char key_state[ARRAY_SIZE(keypad_data->key_state)];
127 	unsigned int col, row, code, changed;
128 	u32 *new_state = (u32 *) key_state;
129 
130 	*new_state = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE31_0);
131 	*(new_state + 1) = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE63_32);
132 
133 	for (row = 0; row < keypad_data->rows; row++) {
134 		changed = key_state[row] ^ keypad_data->key_state[row];
135 		if (!changed)
136 			continue;
137 
138 		for (col = 0; col < keypad_data->cols; col++) {
139 			if (changed & (1 << col)) {
140 				code = MATRIX_SCAN_CODE(row, col,
141 						keypad_data->row_shift);
142 				input_event(input_dev, EV_MSC, MSC_SCAN, code);
143 				input_report_key(input_dev,
144 						 keypad_data->keymap[code],
145 						 key_state[row] & (1 << col));
146 			}
147 		}
148 	}
149 
150 	input_sync(input_dev);
151 
152 	memcpy(keypad_data->key_state, key_state,
153 		sizeof(keypad_data->key_state));
154 
155 	/* clear pending interrupts */
156 	kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS,
157 			 kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS));
158 
159 	return IRQ_HANDLED;
160 }
161 
162 static int omap4_keypad_open(struct input_dev *input)
163 {
164 	struct omap4_keypad *keypad_data = input_get_drvdata(input);
165 
166 	pm_runtime_get_sync(input->dev.parent);
167 
168 	disable_irq(keypad_data->irq);
169 
170 	kbd_writel(keypad_data, OMAP4_KBD_CTRL,
171 			OMAP4_DEF_CTRL_NOSOFTMODE |
172 			(OMAP4_KEYPAD_PTV_DIV_128 << OMAP4_DEF_CTRL_PTV_SHIFT));
173 	kbd_writel(keypad_data, OMAP4_KBD_DEBOUNCINGTIME,
174 			OMAP4_VAL_DEBOUNCINGTIME_16MS);
175 	/* clear pending interrupts */
176 	kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS,
177 			 kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS));
178 	kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQENABLE,
179 			OMAP4_DEF_IRQENABLE_EVENTEN |
180 				OMAP4_DEF_IRQENABLE_LONGKEY);
181 	kbd_writel(keypad_data, OMAP4_KBD_WAKEUPENABLE,
182 			OMAP4_DEF_WUP_EVENT_ENA | OMAP4_DEF_WUP_LONG_KEY_ENA);
183 
184 	enable_irq(keypad_data->irq);
185 
186 	return 0;
187 }
188 
189 static void omap4_keypad_close(struct input_dev *input)
190 {
191 	struct omap4_keypad *keypad_data = input_get_drvdata(input);
192 
193 	disable_irq(keypad_data->irq);
194 
195 	/* Disable interrupts and wake-up events */
196 	kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQENABLE,
197 			 OMAP4_VAL_IRQDISABLE);
198 	kbd_writel(keypad_data, OMAP4_KBD_WAKEUPENABLE, 0);
199 
200 	/* clear pending interrupts */
201 	kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS,
202 			 kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS));
203 
204 	enable_irq(keypad_data->irq);
205 
206 	pm_runtime_put_sync(input->dev.parent);
207 }
208 
209 static int omap4_keypad_parse_dt(struct device *dev,
210 				 struct omap4_keypad *keypad_data)
211 {
212 	struct device_node *np = dev->of_node;
213 	int err;
214 
215 	err = matrix_keypad_parse_properties(dev, &keypad_data->rows,
216 					     &keypad_data->cols);
217 	if (err)
218 		return err;
219 
220 	if (of_get_property(np, "linux,input-no-autorepeat", NULL))
221 		keypad_data->no_autorepeat = true;
222 
223 	return 0;
224 }
225 
226 static int omap4_keypad_probe(struct platform_device *pdev)
227 {
228 	struct omap4_keypad *keypad_data;
229 	struct input_dev *input_dev;
230 	struct resource *res;
231 	unsigned int max_keys;
232 	int rev;
233 	int irq;
234 	int error;
235 
236 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
237 	if (!res) {
238 		dev_err(&pdev->dev, "no base address specified\n");
239 		return -EINVAL;
240 	}
241 
242 	irq = platform_get_irq(pdev, 0);
243 	if (irq < 0)
244 		return irq;
245 
246 	keypad_data = kzalloc(sizeof(struct omap4_keypad), GFP_KERNEL);
247 	if (!keypad_data) {
248 		dev_err(&pdev->dev, "keypad_data memory allocation failed\n");
249 		return -ENOMEM;
250 	}
251 
252 	keypad_data->irq = irq;
253 
254 	error = omap4_keypad_parse_dt(&pdev->dev, keypad_data);
255 	if (error)
256 		goto err_free_keypad;
257 
258 	res = request_mem_region(res->start, resource_size(res), pdev->name);
259 	if (!res) {
260 		dev_err(&pdev->dev, "can't request mem region\n");
261 		error = -EBUSY;
262 		goto err_free_keypad;
263 	}
264 
265 	keypad_data->base = ioremap(res->start, resource_size(res));
266 	if (!keypad_data->base) {
267 		dev_err(&pdev->dev, "can't ioremap mem resource\n");
268 		error = -ENOMEM;
269 		goto err_release_mem;
270 	}
271 
272 
273 	/*
274 	 * Enable clocks for the keypad module so that we can read
275 	 * revision register.
276 	 */
277 	pm_runtime_enable(&pdev->dev);
278 	error = pm_runtime_get_sync(&pdev->dev);
279 	if (error) {
280 		dev_err(&pdev->dev, "pm_runtime_get_sync() failed\n");
281 		goto err_unmap;
282 	}
283 	rev = __raw_readl(keypad_data->base + OMAP4_KBD_REVISION);
284 	rev &= 0x03 << 30;
285 	rev >>= 30;
286 	switch (rev) {
287 	case KBD_REVISION_OMAP4:
288 		keypad_data->reg_offset = 0x00;
289 		keypad_data->irqreg_offset = 0x00;
290 		break;
291 	case KBD_REVISION_OMAP5:
292 		keypad_data->reg_offset = 0x10;
293 		keypad_data->irqreg_offset = 0x0c;
294 		break;
295 	default:
296 		dev_err(&pdev->dev,
297 			"Keypad reports unsupported revision %d", rev);
298 		error = -EINVAL;
299 		goto err_pm_put_sync;
300 	}
301 
302 	/* input device allocation */
303 	keypad_data->input = input_dev = input_allocate_device();
304 	if (!input_dev) {
305 		error = -ENOMEM;
306 		goto err_pm_put_sync;
307 	}
308 
309 	input_dev->name = pdev->name;
310 	input_dev->dev.parent = &pdev->dev;
311 	input_dev->id.bustype = BUS_HOST;
312 	input_dev->id.vendor = 0x0001;
313 	input_dev->id.product = 0x0001;
314 	input_dev->id.version = 0x0001;
315 
316 	input_dev->open = omap4_keypad_open;
317 	input_dev->close = omap4_keypad_close;
318 
319 	input_set_capability(input_dev, EV_MSC, MSC_SCAN);
320 	if (!keypad_data->no_autorepeat)
321 		__set_bit(EV_REP, input_dev->evbit);
322 
323 	input_set_drvdata(input_dev, keypad_data);
324 
325 	keypad_data->row_shift = get_count_order(keypad_data->cols);
326 	max_keys = keypad_data->rows << keypad_data->row_shift;
327 	keypad_data->keymap = kcalloc(max_keys,
328 				      sizeof(keypad_data->keymap[0]),
329 				      GFP_KERNEL);
330 	if (!keypad_data->keymap) {
331 		dev_err(&pdev->dev, "Not enough memory for keymap\n");
332 		error = -ENOMEM;
333 		goto err_free_input;
334 	}
335 
336 	error = matrix_keypad_build_keymap(NULL, NULL,
337 					   keypad_data->rows, keypad_data->cols,
338 					   keypad_data->keymap, input_dev);
339 	if (error) {
340 		dev_err(&pdev->dev, "failed to build keymap\n");
341 		goto err_free_keymap;
342 	}
343 
344 	error = request_threaded_irq(keypad_data->irq, omap4_keypad_irq_handler,
345 				     omap4_keypad_irq_thread_fn, IRQF_ONESHOT,
346 				     "omap4-keypad", keypad_data);
347 	if (error) {
348 		dev_err(&pdev->dev, "failed to register interrupt\n");
349 		goto err_free_keymap;
350 	}
351 
352 	device_init_wakeup(&pdev->dev, true);
353 	pm_runtime_put_sync(&pdev->dev);
354 
355 	error = input_register_device(keypad_data->input);
356 	if (error < 0) {
357 		dev_err(&pdev->dev, "failed to register input device\n");
358 		goto err_pm_disable;
359 	}
360 
361 	platform_set_drvdata(pdev, keypad_data);
362 	return 0;
363 
364 err_pm_disable:
365 	pm_runtime_disable(&pdev->dev);
366 	free_irq(keypad_data->irq, keypad_data);
367 err_free_keymap:
368 	kfree(keypad_data->keymap);
369 err_free_input:
370 	input_free_device(input_dev);
371 err_pm_put_sync:
372 	pm_runtime_put_sync(&pdev->dev);
373 err_unmap:
374 	iounmap(keypad_data->base);
375 err_release_mem:
376 	release_mem_region(res->start, resource_size(res));
377 err_free_keypad:
378 	kfree(keypad_data);
379 	return error;
380 }
381 
382 static int omap4_keypad_remove(struct platform_device *pdev)
383 {
384 	struct omap4_keypad *keypad_data = platform_get_drvdata(pdev);
385 	struct resource *res;
386 
387 	free_irq(keypad_data->irq, keypad_data);
388 
389 	pm_runtime_disable(&pdev->dev);
390 
391 	input_unregister_device(keypad_data->input);
392 
393 	iounmap(keypad_data->base);
394 
395 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
396 	release_mem_region(res->start, resource_size(res));
397 
398 	kfree(keypad_data->keymap);
399 	kfree(keypad_data);
400 
401 	return 0;
402 }
403 
404 static const struct of_device_id omap_keypad_dt_match[] = {
405 	{ .compatible = "ti,omap4-keypad" },
406 	{},
407 };
408 MODULE_DEVICE_TABLE(of, omap_keypad_dt_match);
409 
410 #ifdef CONFIG_PM_SLEEP
411 static int omap4_keypad_suspend(struct device *dev)
412 {
413 	struct platform_device *pdev = to_platform_device(dev);
414 	struct omap4_keypad *keypad_data = platform_get_drvdata(pdev);
415 	int error;
416 
417 	if (device_may_wakeup(&pdev->dev)) {
418 		error = enable_irq_wake(keypad_data->irq);
419 		if (!error)
420 			keypad_data->irq_wake_enabled = true;
421 	}
422 
423 	return 0;
424 }
425 
426 static int omap4_keypad_resume(struct device *dev)
427 {
428 	struct platform_device *pdev = to_platform_device(dev);
429 	struct omap4_keypad *keypad_data = platform_get_drvdata(pdev);
430 
431 	if (device_may_wakeup(&pdev->dev) && keypad_data->irq_wake_enabled) {
432 		disable_irq_wake(keypad_data->irq);
433 		keypad_data->irq_wake_enabled = false;
434 	}
435 
436 	return 0;
437 }
438 #endif
439 
440 static SIMPLE_DEV_PM_OPS(omap4_keypad_pm_ops,
441 			 omap4_keypad_suspend, omap4_keypad_resume);
442 
443 static struct platform_driver omap4_keypad_driver = {
444 	.probe		= omap4_keypad_probe,
445 	.remove		= omap4_keypad_remove,
446 	.driver		= {
447 		.name	= "omap4-keypad",
448 		.pm	= &omap4_keypad_pm_ops,
449 		.of_match_table = omap_keypad_dt_match,
450 	},
451 };
452 module_platform_driver(omap4_keypad_driver);
453 
454 MODULE_AUTHOR("Texas Instruments");
455 MODULE_DESCRIPTION("OMAP4 Keypad Driver");
456 MODULE_LICENSE("GPL");
457 MODULE_ALIAS("platform:omap4-keypad");
458