xref: /linux/drivers/input/keyboard/tc3589x-keypad.c (revision ca55b2fef3a9373fcfc30f82fd26bc7fccbda732) 
1 /*
2  * Copyright (C) ST-Ericsson SA 2010
3  *
4  * Author: Jayeeta Banerjee <jayeeta.banerjee@stericsson.com>
5  * Author: Sundar Iyer <sundar.iyer@stericsson.com>
6  *
7  * License Terms: GNU General Public License, version 2
8  *
9  * TC35893 MFD Keypad Controller driver
10  */
11 
12 #include <linux/module.h>
13 #include <linux/interrupt.h>
14 #include <linux/input.h>
15 #include <linux/platform_device.h>
16 #include <linux/input/matrix_keypad.h>
17 #include <linux/i2c.h>
18 #include <linux/slab.h>
19 #include <linux/mfd/tc3589x.h>
20 #include <linux/device.h>
21 
22 /* Maximum supported keypad matrix row/columns size */
23 #define TC3589x_MAX_KPROW               8
24 #define TC3589x_MAX_KPCOL               12
25 
26 /* keypad related Constants */
27 #define TC3589x_MAX_DEBOUNCE_SETTLE     0xFF
28 #define DEDICATED_KEY_VAL		0xFF
29 
30 /* Pull up/down masks */
31 #define TC3589x_NO_PULL_MASK		0x0
32 #define TC3589x_PULL_DOWN_MASK		0x1
33 #define TC3589x_PULL_UP_MASK		0x2
34 #define TC3589x_PULLUP_ALL_MASK		0xAA
35 #define TC3589x_IO_PULL_VAL(index, mask)	((mask)<<((index)%4)*2))
36 
37 /* Bit masks for IOCFG register */
38 #define IOCFG_BALLCFG		0x01
39 #define IOCFG_IG		0x08
40 
41 #define KP_EVCODE_COL_MASK	0x0F
42 #define KP_EVCODE_ROW_MASK	0x70
43 #define KP_RELEASE_EVT_MASK	0x80
44 
45 #define KP_ROW_SHIFT		4
46 
47 #define KP_NO_VALID_KEY_MASK	0x7F
48 
49 /* bit masks for RESTCTRL register */
50 #define TC3589x_KBDRST		0x2
51 #define TC3589x_IRQRST		0x10
52 #define TC3589x_RESET_ALL	0x1B
53 
54 /* KBDMFS register bit mask */
55 #define TC3589x_KBDMFS_EN	0x1
56 
57 /* CLKEN register bitmask */
58 #define KPD_CLK_EN		0x1
59 
60 /* RSTINTCLR register bit mask */
61 #define IRQ_CLEAR		0x1
62 
63 /* bit masks for keyboard interrupts*/
64 #define TC3589x_EVT_LOSS_INT	0x8
65 #define TC3589x_EVT_INT		0x4
66 #define TC3589x_KBD_LOSS_INT	0x2
67 #define TC3589x_KBD_INT		0x1
68 
69 /* bit masks for keyboard interrupt clear*/
70 #define TC3589x_EVT_INT_CLR	0x2
71 #define TC3589x_KBD_INT_CLR	0x1
72 
73 /**
74  * struct tc35893_keypad_platform_data - platform specific keypad data
75  * @keymap_data:        matrix scan code table for keycodes
76  * @krow:               mask for available rows, value is 0xFF
77  * @kcol:               mask for available columns, value is 0xFF
78  * @debounce_period:    platform specific debounce time
79  * @settle_time:        platform specific settle down time
80  * @irqtype:            type of interrupt, falling or rising edge
81  * @enable_wakeup:      specifies if keypad event can wake up system from sleep
82  * @no_autorepeat:      flag for auto repetition
83  */
84 struct tc3589x_keypad_platform_data {
85 	const struct matrix_keymap_data *keymap_data;
86 	u8                      krow;
87 	u8                      kcol;
88 	u8                      debounce_period;
89 	u8                      settle_time;
90 	unsigned long           irqtype;
91 	bool                    enable_wakeup;
92 	bool                    no_autorepeat;
93 };
94 
95 /**
96  * struct tc_keypad - data structure used by keypad driver
97  * @tc3589x:    pointer to tc35893
98  * @input:      pointer to input device object
99  * @board:      keypad platform device
100  * @krow:	number of rows
101  * @kcol:	number of columns
102  * @keymap:     matrix scan code table for keycodes
103  * @keypad_stopped: holds keypad status
104  */
105 struct tc_keypad {
106 	struct tc3589x *tc3589x;
107 	struct input_dev *input;
108 	const struct tc3589x_keypad_platform_data *board;
109 	unsigned int krow;
110 	unsigned int kcol;
111 	unsigned short *keymap;
112 	bool keypad_stopped;
113 };
114 
115 static int tc3589x_keypad_init_key_hardware(struct tc_keypad *keypad)
116 {
117 	int ret;
118 	struct tc3589x *tc3589x = keypad->tc3589x;
119 	const struct tc3589x_keypad_platform_data *board = keypad->board;
120 
121 	/* validate platform configuration */
122 	if (board->kcol > TC3589x_MAX_KPCOL || board->krow > TC3589x_MAX_KPROW)
123 		return -EINVAL;
124 
125 	/* configure KBDSIZE 4 LSbits for cols and 4 MSbits for rows */
126 	ret = tc3589x_reg_write(tc3589x, TC3589x_KBDSIZE,
127 			(board->krow << KP_ROW_SHIFT) | board->kcol);
128 	if (ret < 0)
129 		return ret;
130 
131 	/* configure dedicated key config, no dedicated key selected */
132 	ret = tc3589x_reg_write(tc3589x, TC3589x_KBCFG_LSB, DEDICATED_KEY_VAL);
133 	if (ret < 0)
134 		return ret;
135 
136 	ret = tc3589x_reg_write(tc3589x, TC3589x_KBCFG_MSB, DEDICATED_KEY_VAL);
137 	if (ret < 0)
138 		return ret;
139 
140 	/* Configure settle time */
141 	ret = tc3589x_reg_write(tc3589x, TC3589x_KBDSETTLE_REG,
142 				board->settle_time);
143 	if (ret < 0)
144 		return ret;
145 
146 	/* Configure debounce time */
147 	ret = tc3589x_reg_write(tc3589x, TC3589x_KBDBOUNCE,
148 				board->debounce_period);
149 	if (ret < 0)
150 		return ret;
151 
152 	/* Start of initialise keypad GPIOs */
153 	ret = tc3589x_set_bits(tc3589x, TC3589x_IOCFG, 0x0, IOCFG_IG);
154 	if (ret < 0)
155 		return ret;
156 
157 	/* Configure pull-up resistors for all row GPIOs */
158 	ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG0_LSB,
159 					TC3589x_PULLUP_ALL_MASK);
160 	if (ret < 0)
161 		return ret;
162 
163 	ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG0_MSB,
164 					TC3589x_PULLUP_ALL_MASK);
165 	if (ret < 0)
166 		return ret;
167 
168 	/* Configure pull-up resistors for all column GPIOs */
169 	ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG1_LSB,
170 			TC3589x_PULLUP_ALL_MASK);
171 	if (ret < 0)
172 		return ret;
173 
174 	ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG1_MSB,
175 			TC3589x_PULLUP_ALL_MASK);
176 	if (ret < 0)
177 		return ret;
178 
179 	ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG2_LSB,
180 			TC3589x_PULLUP_ALL_MASK);
181 
182 	return ret;
183 }
184 
185 #define TC35893_DATA_REGS		4
186 #define TC35893_KEYCODE_FIFO_EMPTY	0x7f
187 #define TC35893_KEYCODE_FIFO_CLEAR	0xff
188 #define TC35893_KEYPAD_ROW_SHIFT	0x3
189 
190 static irqreturn_t tc3589x_keypad_irq(int irq, void *dev)
191 {
192 	struct tc_keypad *keypad = dev;
193 	struct tc3589x *tc3589x = keypad->tc3589x;
194 	u8 i, row_index, col_index, kbd_code, up;
195 	u8 code;
196 
197 	for (i = 0; i < TC35893_DATA_REGS * 2; i++) {
198 		kbd_code = tc3589x_reg_read(tc3589x, TC3589x_EVTCODE_FIFO);
199 
200 		/* loop till fifo is empty and no more keys are pressed */
201 		if (kbd_code == TC35893_KEYCODE_FIFO_EMPTY ||
202 				kbd_code == TC35893_KEYCODE_FIFO_CLEAR)
203 			continue;
204 
205 		/* valid key is found */
206 		col_index = kbd_code & KP_EVCODE_COL_MASK;
207 		row_index = (kbd_code & KP_EVCODE_ROW_MASK) >> KP_ROW_SHIFT;
208 		code = MATRIX_SCAN_CODE(row_index, col_index,
209 						TC35893_KEYPAD_ROW_SHIFT);
210 		up = kbd_code & KP_RELEASE_EVT_MASK;
211 
212 		input_event(keypad->input, EV_MSC, MSC_SCAN, code);
213 		input_report_key(keypad->input, keypad->keymap[code], !up);
214 		input_sync(keypad->input);
215 	}
216 
217 	/* clear IRQ */
218 	tc3589x_set_bits(tc3589x, TC3589x_KBDIC,
219 			0x0, TC3589x_EVT_INT_CLR | TC3589x_KBD_INT_CLR);
220 	/* enable IRQ */
221 	tc3589x_set_bits(tc3589x, TC3589x_KBDMSK,
222 			0x0, TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT);
223 
224 	return IRQ_HANDLED;
225 }
226 
227 static int tc3589x_keypad_enable(struct tc_keypad *keypad)
228 {
229 	struct tc3589x *tc3589x = keypad->tc3589x;
230 	int ret;
231 
232 	/* pull the keypad module out of reset */
233 	ret = tc3589x_set_bits(tc3589x, TC3589x_RSTCTRL, TC3589x_KBDRST, 0x0);
234 	if (ret < 0)
235 		return ret;
236 
237 	/* configure KBDMFS */
238 	ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMFS, 0x0, TC3589x_KBDMFS_EN);
239 	if (ret < 0)
240 		return ret;
241 
242 	/* enable the keypad clock */
243 	ret = tc3589x_set_bits(tc3589x, TC3589x_CLKEN, 0x0, KPD_CLK_EN);
244 	if (ret < 0)
245 		return ret;
246 
247 	/* clear pending IRQs */
248 	ret =  tc3589x_set_bits(tc3589x, TC3589x_RSTINTCLR, 0x0, 0x1);
249 	if (ret < 0)
250 		return ret;
251 
252 	/* enable the IRQs */
253 	ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMSK, 0x0,
254 					TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT);
255 	if (ret < 0)
256 		return ret;
257 
258 	keypad->keypad_stopped = false;
259 
260 	return ret;
261 }
262 
263 static int tc3589x_keypad_disable(struct tc_keypad *keypad)
264 {
265 	struct tc3589x *tc3589x = keypad->tc3589x;
266 	int ret;
267 
268 	/* clear IRQ */
269 	ret = tc3589x_set_bits(tc3589x, TC3589x_KBDIC,
270 			0x0, TC3589x_EVT_INT_CLR | TC3589x_KBD_INT_CLR);
271 	if (ret < 0)
272 		return ret;
273 
274 	/* disable all interrupts */
275 	ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMSK,
276 			~(TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT), 0x0);
277 	if (ret < 0)
278 		return ret;
279 
280 	/* disable the keypad module */
281 	ret = tc3589x_set_bits(tc3589x, TC3589x_CLKEN, 0x1, 0x0);
282 	if (ret < 0)
283 		return ret;
284 
285 	/* put the keypad module into reset */
286 	ret = tc3589x_set_bits(tc3589x, TC3589x_RSTCTRL, TC3589x_KBDRST, 0x1);
287 
288 	keypad->keypad_stopped = true;
289 
290 	return ret;
291 }
292 
293 static int tc3589x_keypad_open(struct input_dev *input)
294 {
295 	int error;
296 	struct tc_keypad *keypad = input_get_drvdata(input);
297 
298 	/* enable the keypad module */
299 	error = tc3589x_keypad_enable(keypad);
300 	if (error < 0) {
301 		dev_err(&input->dev, "failed to enable keypad module\n");
302 		return error;
303 	}
304 
305 	error = tc3589x_keypad_init_key_hardware(keypad);
306 	if (error < 0) {
307 		dev_err(&input->dev, "failed to configure keypad module\n");
308 		return error;
309 	}
310 
311 	return 0;
312 }
313 
314 static void tc3589x_keypad_close(struct input_dev *input)
315 {
316 	struct tc_keypad *keypad = input_get_drvdata(input);
317 
318 	/* disable the keypad module */
319 	tc3589x_keypad_disable(keypad);
320 }
321 
322 static const struct tc3589x_keypad_platform_data *
323 tc3589x_keypad_of_probe(struct device *dev)
324 {
325 	struct device_node *np = dev->of_node;
326 	struct tc3589x_keypad_platform_data *plat;
327 	u32 cols, rows;
328 	u32 debounce_ms;
329 	int proplen;
330 
331 	if (!np)
332 		return ERR_PTR(-ENODEV);
333 
334 	plat = devm_kzalloc(dev, sizeof(*plat), GFP_KERNEL);
335 	if (!plat)
336 		return ERR_PTR(-ENOMEM);
337 
338 	of_property_read_u32(np, "keypad,num-columns", &cols);
339 	of_property_read_u32(np, "keypad,num-rows", &rows);
340 	plat->kcol = (u8) cols;
341 	plat->krow = (u8) rows;
342 	if (!plat->krow || !plat->kcol ||
343 	     plat->krow > TC_KPD_ROWS || plat->kcol > TC_KPD_COLUMNS) {
344 		dev_err(dev,
345 			"keypad columns/rows not properly specified (%ux%u)\n",
346 			plat->kcol, plat->krow);
347 		return ERR_PTR(-EINVAL);
348 	}
349 
350 	if (!of_get_property(np, "linux,keymap", &proplen)) {
351 		dev_err(dev, "property linux,keymap not found\n");
352 		return ERR_PTR(-ENOENT);
353 	}
354 
355 	plat->no_autorepeat = of_property_read_bool(np, "linux,no-autorepeat");
356 
357 	plat->enable_wakeup = of_property_read_bool(np, "wakeup-source") ||
358 			      /* legacy name */
359 			      of_property_read_bool(np, "linux,wakeup");
360 
361 	/* The custom delay format is ms/16 */
362 	of_property_read_u32(np, "debounce-delay-ms", &debounce_ms);
363 	if (debounce_ms)
364 		plat->debounce_period = debounce_ms * 16;
365 	else
366 		plat->debounce_period = TC_KPD_DEBOUNCE_PERIOD;
367 
368 	plat->settle_time = TC_KPD_SETTLE_TIME;
369 	/* FIXME: should be property of the IRQ resource? */
370 	plat->irqtype = IRQF_TRIGGER_FALLING;
371 
372 	return plat;
373 }
374 
375 static int tc3589x_keypad_probe(struct platform_device *pdev)
376 {
377 	struct tc3589x *tc3589x = dev_get_drvdata(pdev->dev.parent);
378 	struct tc_keypad *keypad;
379 	struct input_dev *input;
380 	const struct tc3589x_keypad_platform_data *plat;
381 	int error, irq;
382 
383 	plat = tc3589x_keypad_of_probe(&pdev->dev);
384 	if (IS_ERR(plat)) {
385 		dev_err(&pdev->dev, "invalid keypad platform data\n");
386 		return PTR_ERR(plat);
387 	}
388 
389 	irq = platform_get_irq(pdev, 0);
390 	if (irq < 0)
391 		return irq;
392 
393 	keypad = devm_kzalloc(&pdev->dev, sizeof(struct tc_keypad),
394 			      GFP_KERNEL);
395 	if (!keypad)
396 		return -ENOMEM;
397 
398 	input = devm_input_allocate_device(&pdev->dev);
399 	if (!input) {
400 		dev_err(&pdev->dev, "failed to allocate input device\n");
401 		return -ENOMEM;
402 	}
403 
404 	keypad->board = plat;
405 	keypad->input = input;
406 	keypad->tc3589x = tc3589x;
407 
408 	input->id.bustype = BUS_I2C;
409 	input->name = pdev->name;
410 	input->dev.parent = &pdev->dev;
411 
412 	input->open = tc3589x_keypad_open;
413 	input->close = tc3589x_keypad_close;
414 
415 	error = matrix_keypad_build_keymap(plat->keymap_data, NULL,
416 					   TC3589x_MAX_KPROW, TC3589x_MAX_KPCOL,
417 					   NULL, input);
418 	if (error) {
419 		dev_err(&pdev->dev, "Failed to build keymap\n");
420 		return error;
421 	}
422 
423 	keypad->keymap = input->keycode;
424 
425 	input_set_capability(input, EV_MSC, MSC_SCAN);
426 	if (!plat->no_autorepeat)
427 		__set_bit(EV_REP, input->evbit);
428 
429 	input_set_drvdata(input, keypad);
430 
431 	tc3589x_keypad_disable(keypad);
432 
433 	error = devm_request_threaded_irq(&pdev->dev, irq,
434 					  NULL, tc3589x_keypad_irq,
435 					  plat->irqtype | IRQF_ONESHOT,
436 					  "tc3589x-keypad", keypad);
437 	if (error) {
438 		dev_err(&pdev->dev,
439 				"Could not allocate irq %d,error %d\n",
440 				irq, error);
441 		return error;
442 	}
443 
444 	error = input_register_device(input);
445 	if (error) {
446 		dev_err(&pdev->dev, "Could not register input device\n");
447 		return error;
448 	}
449 
450 	/* let platform decide if keypad is a wakeup source or not */
451 	device_init_wakeup(&pdev->dev, plat->enable_wakeup);
452 	device_set_wakeup_capable(&pdev->dev, plat->enable_wakeup);
453 
454 	platform_set_drvdata(pdev, keypad);
455 
456 	return 0;
457 }
458 
459 #ifdef CONFIG_PM_SLEEP
460 static int tc3589x_keypad_suspend(struct device *dev)
461 {
462 	struct platform_device *pdev = to_platform_device(dev);
463 	struct tc_keypad *keypad = platform_get_drvdata(pdev);
464 	int irq = platform_get_irq(pdev, 0);
465 
466 	/* keypad is already off; we do nothing */
467 	if (keypad->keypad_stopped)
468 		return 0;
469 
470 	/* if device is not a wakeup source, disable it for powersave */
471 	if (!device_may_wakeup(&pdev->dev))
472 		tc3589x_keypad_disable(keypad);
473 	else
474 		enable_irq_wake(irq);
475 
476 	return 0;
477 }
478 
479 static int tc3589x_keypad_resume(struct device *dev)
480 {
481 	struct platform_device *pdev = to_platform_device(dev);
482 	struct tc_keypad *keypad = platform_get_drvdata(pdev);
483 	int irq = platform_get_irq(pdev, 0);
484 
485 	if (!keypad->keypad_stopped)
486 		return 0;
487 
488 	/* enable the device to resume normal operations */
489 	if (!device_may_wakeup(&pdev->dev))
490 		tc3589x_keypad_enable(keypad);
491 	else
492 		disable_irq_wake(irq);
493 
494 	return 0;
495 }
496 #endif
497 
498 static SIMPLE_DEV_PM_OPS(tc3589x_keypad_dev_pm_ops,
499 			 tc3589x_keypad_suspend, tc3589x_keypad_resume);
500 
501 static struct platform_driver tc3589x_keypad_driver = {
502 	.driver	= {
503 		.name	= "tc3589x-keypad",
504 		.pm	= &tc3589x_keypad_dev_pm_ops,
505 	},
506 	.probe	= tc3589x_keypad_probe,
507 };
508 module_platform_driver(tc3589x_keypad_driver);
509 
510 MODULE_LICENSE("GPL v2");
511 MODULE_AUTHOR("Jayeeta Banerjee/Sundar Iyer");
512 MODULE_DESCRIPTION("TC35893 Keypad Driver");
513 MODULE_ALIAS("platform:tc3589x-keypad");
514