1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) ST-Ericsson SA 2010
4 *
5 * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
6 */
7
8#include <linux/module.h>
9#include <linux/slab.h>
10#include <linux/input.h>
11#include <linux/interrupt.h>
12#include <linux/platform_device.h>
13#include <linux/input/matrix_keypad.h>
14#include <linux/mfd/stmpe.h>
15
16/* These are at the same addresses in all STMPE variants */
17#define STMPE_KPC_COL			0x60
18#define STMPE_KPC_ROW_MSB		0x61
19#define STMPE_KPC_ROW_LSB		0x62
20#define STMPE_KPC_CTRL_MSB		0x63
21#define STMPE_KPC_CTRL_LSB		0x64
22#define STMPE_KPC_COMBI_KEY_0		0x65
23#define STMPE_KPC_COMBI_KEY_1		0x66
24#define STMPE_KPC_COMBI_KEY_2		0x67
25#define STMPE_KPC_DATA_BYTE0		0x68
26#define STMPE_KPC_DATA_BYTE1		0x69
27#define STMPE_KPC_DATA_BYTE2		0x6a
28#define STMPE_KPC_DATA_BYTE3		0x6b
29#define STMPE_KPC_DATA_BYTE4		0x6c
30
31#define STMPE_KPC_CTRL_LSB_SCAN		(0x1 << 0)
32#define STMPE_KPC_CTRL_LSB_DEBOUNCE	(0x7f << 1)
33#define STMPE_KPC_CTRL_MSB_SCAN_COUNT	(0xf << 4)
34
35#define STMPE_KPC_ROW_MSB_ROWS		0xff
36
37#define STMPE_KPC_DATA_UP		(0x1 << 7)
38#define STMPE_KPC_DATA_ROW		(0xf << 3)
39#define STMPE_KPC_DATA_COL		(0x7 << 0)
40#define STMPE_KPC_DATA_NOKEY_MASK	0x78
41
42#define STMPE_KEYPAD_MAX_DEBOUNCE	127
43#define STMPE_KEYPAD_MAX_SCAN_COUNT	15
44
45#define STMPE_KEYPAD_MAX_ROWS		8
46#define STMPE_KEYPAD_MAX_COLS		8
47#define STMPE_KEYPAD_ROW_SHIFT		3
48#define STMPE_KEYPAD_KEYMAP_MAX_SIZE \
49	(STMPE_KEYPAD_MAX_ROWS * STMPE_KEYPAD_MAX_COLS)
50
51
52#define STMPE1601_NUM_DATA	5
53#define STMPE2401_NUM_DATA	3
54#define STMPE2403_NUM_DATA	5
55
56/* Make sure it covers all cases above */
57#define MAX_NUM_DATA		5
58
59/**
60 * struct stmpe_keypad_variant - model-specific attributes
61 * @auto_increment: whether the KPC_DATA_BYTE register address
62 *		    auto-increments on multiple read
63 * @set_pullup: whether the pins need to have their pull-ups set
64 * @num_data: number of data bytes
65 * @num_normal_data: number of normal keys' data bytes
66 * @max_cols: maximum number of columns supported
67 * @max_rows: maximum number of rows supported
68 * @col_gpios: bitmask of gpios which can be used for columns
69 * @row_gpios: bitmask of gpios which can be used for rows
70 */
71struct stmpe_keypad_variant {
72	bool		auto_increment;
73	bool		set_pullup;
74	int		num_data;
75	int		num_normal_data;
76	int		max_cols;
77	int		max_rows;
78	unsigned int	col_gpios;
79	unsigned int	row_gpios;
80};
81
82static const struct stmpe_keypad_variant stmpe_keypad_variants[] = {
83	[STMPE1601] = {
84		.auto_increment		= true,
85		.num_data		= STMPE1601_NUM_DATA,
86		.num_normal_data	= 3,
87		.max_cols		= 8,
88		.max_rows		= 8,
89		.col_gpios		= 0x000ff,	/* GPIO 0 - 7 */
90		.row_gpios		= 0x0ff00,	/* GPIO 8 - 15 */
91	},
92	[STMPE2401] = {
93		.auto_increment		= false,
94		.set_pullup		= true,
95		.num_data		= STMPE2401_NUM_DATA,
96		.num_normal_data	= 2,
97		.max_cols		= 8,
98		.max_rows		= 12,
99		.col_gpios		= 0x0000ff,	/* GPIO 0 - 7*/
100		.row_gpios		= 0x1f7f00,	/* GPIO 8-14, 16-20 */
101	},
102	[STMPE2403] = {
103		.auto_increment		= true,
104		.set_pullup		= true,
105		.num_data		= STMPE2403_NUM_DATA,
106		.num_normal_data	= 3,
107		.max_cols		= 8,
108		.max_rows		= 12,
109		.col_gpios		= 0x0000ff,	/* GPIO 0 - 7*/
110		.row_gpios		= 0x1fef00,	/* GPIO 8-14, 16-20 */
111	},
112};
113
114/**
115 * struct stmpe_keypad - STMPE keypad state container
116 * @stmpe: pointer to parent STMPE device
117 * @input: spawned input device
118 * @variant: STMPE variant
119 * @debounce_ms: debounce interval, in ms.  Maximum is
120 *		 %STMPE_KEYPAD_MAX_DEBOUNCE.
121 * @scan_count: number of key scanning cycles to confirm key data.
122 *		Maximum is %STMPE_KEYPAD_MAX_SCAN_COUNT.
123 * @no_autorepeat: disable key autorepeat
124 * @rows: bitmask for the rows
125 * @cols: bitmask for the columns
126 * @keymap: the keymap
127 */
128struct stmpe_keypad {
129	struct stmpe *stmpe;
130	struct input_dev *input;
131	const struct stmpe_keypad_variant *variant;
132	unsigned int debounce_ms;
133	unsigned int scan_count;
134	bool no_autorepeat;
135	unsigned int rows;
136	unsigned int cols;
137	unsigned short keymap[STMPE_KEYPAD_KEYMAP_MAX_SIZE];
138};
139
140static int stmpe_keypad_read_data(struct stmpe_keypad *keypad, u8 *data)
141{
142	const struct stmpe_keypad_variant *variant = keypad->variant;
143	struct stmpe *stmpe = keypad->stmpe;
144	int ret;
145	int i;
146
147	if (variant->auto_increment)
148		return stmpe_block_read(stmpe, STMPE_KPC_DATA_BYTE0,
149					variant->num_data, data);
150
151	for (i = 0; i < variant->num_data; i++) {
152		ret = stmpe_reg_read(stmpe, STMPE_KPC_DATA_BYTE0 + i);
153		if (ret < 0)
154			return ret;
155
156		data[i] = ret;
157	}
158
159	return 0;
160}
161
162static irqreturn_t stmpe_keypad_irq(int irq, void *dev)
163{
164	struct stmpe_keypad *keypad = dev;
165	struct input_dev *input = keypad->input;
166	const struct stmpe_keypad_variant *variant = keypad->variant;
167	u8 fifo[MAX_NUM_DATA];
168	int ret;
169	int i;
170
171	ret = stmpe_keypad_read_data(keypad, fifo);
172	if (ret < 0)
173		return IRQ_NONE;
174
175	for (i = 0; i < variant->num_normal_data; i++) {
176		u8 data = fifo[i];
177		int row = (data & STMPE_KPC_DATA_ROW) >> 3;
178		int col = data & STMPE_KPC_DATA_COL;
179		int code = MATRIX_SCAN_CODE(row, col, STMPE_KEYPAD_ROW_SHIFT);
180		bool up = data & STMPE_KPC_DATA_UP;
181
182		if ((data & STMPE_KPC_DATA_NOKEY_MASK)
183			== STMPE_KPC_DATA_NOKEY_MASK)
184			continue;
185
186		input_event(input, EV_MSC, MSC_SCAN, code);
187		input_report_key(input, keypad->keymap[code], !up);
188		input_sync(input);
189	}
190
191	return IRQ_HANDLED;
192}
193
194static int stmpe_keypad_altfunc_init(struct stmpe_keypad *keypad)
195{
196	const struct stmpe_keypad_variant *variant = keypad->variant;
197	unsigned int col_gpios = variant->col_gpios;
198	unsigned int row_gpios = variant->row_gpios;
199	struct stmpe *stmpe = keypad->stmpe;
200	u8 pureg = stmpe->regs[STMPE_IDX_GPPUR_LSB];
201	unsigned int pins = 0;
202	unsigned int pu_pins = 0;
203	int ret;
204	int i;
205
206	/*
207	 * Figure out which pins need to be set to the keypad alternate
208	 * function.
209	 *
210	 * {cols,rows}_gpios are bitmasks of which pins on the chip can be used
211	 * for the keypad.
212	 *
213	 * keypad->{cols,rows} are a bitmask of which pins (of the ones useable
214	 * for the keypad) are used on the board.
215	 */
216
217	for (i = 0; i < variant->max_cols; i++) {
218		int num = __ffs(col_gpios);
219
220		if (keypad->cols & (1 << i)) {
221			pins |= 1 << num;
222			pu_pins |= 1 << num;
223		}
224
225		col_gpios &= ~(1 << num);
226	}
227
228	for (i = 0; i < variant->max_rows; i++) {
229		int num = __ffs(row_gpios);
230
231		if (keypad->rows & (1 << i))
232			pins |= 1 << num;
233
234		row_gpios &= ~(1 << num);
235	}
236
237	ret = stmpe_set_altfunc(stmpe, pins, STMPE_BLOCK_KEYPAD);
238	if (ret)
239		return ret;
240
241	/*
242	 * On STMPE24xx, set pin bias to pull-up on all keypad input
243	 * pins (columns), this incidentally happen to be maximum 8 pins
244	 * and placed at GPIO0-7 so only the LSB of the pull up register
245	 * ever needs to be written.
246	 */
247	if (variant->set_pullup) {
248		u8 val;
249
250		ret = stmpe_reg_read(stmpe, pureg);
251		if (ret)
252			return ret;
253
254		/* Do not touch unused pins, may be used for GPIO */
255		val = ret & ~pu_pins;
256		val |= pu_pins;
257
258		ret = stmpe_reg_write(stmpe, pureg, val);
259	}
260
261	return 0;
262}
263
264static int stmpe_keypad_chip_init(struct stmpe_keypad *keypad)
265{
266	const struct stmpe_keypad_variant *variant = keypad->variant;
267	struct stmpe *stmpe = keypad->stmpe;
268	int ret;
269
270	if (keypad->debounce_ms > STMPE_KEYPAD_MAX_DEBOUNCE)
271		return -EINVAL;
272
273	if (keypad->scan_count > STMPE_KEYPAD_MAX_SCAN_COUNT)
274		return -EINVAL;
275
276	ret = stmpe_enable(stmpe, STMPE_BLOCK_KEYPAD);
277	if (ret < 0)
278		return ret;
279
280	ret = stmpe_keypad_altfunc_init(keypad);
281	if (ret < 0)
282		return ret;
283
284	ret = stmpe_reg_write(stmpe, STMPE_KPC_COL, keypad->cols);
285	if (ret < 0)
286		return ret;
287
288	ret = stmpe_reg_write(stmpe, STMPE_KPC_ROW_LSB, keypad->rows);
289	if (ret < 0)
290		return ret;
291
292	if (variant->max_rows > 8) {
293		ret = stmpe_set_bits(stmpe, STMPE_KPC_ROW_MSB,
294				     STMPE_KPC_ROW_MSB_ROWS,
295				     keypad->rows >> 8);
296		if (ret < 0)
297			return ret;
298	}
299
300	ret = stmpe_set_bits(stmpe, STMPE_KPC_CTRL_MSB,
301			     STMPE_KPC_CTRL_MSB_SCAN_COUNT,
302			     keypad->scan_count << 4);
303	if (ret < 0)
304		return ret;
305
306	return stmpe_set_bits(stmpe, STMPE_KPC_CTRL_LSB,
307			      STMPE_KPC_CTRL_LSB_SCAN |
308			      STMPE_KPC_CTRL_LSB_DEBOUNCE,
309			      STMPE_KPC_CTRL_LSB_SCAN |
310			      (keypad->debounce_ms << 1));
311}
312
313static void stmpe_keypad_fill_used_pins(struct stmpe_keypad *keypad,
314					u32 used_rows, u32 used_cols)
315{
316	int row, col;
317
318	for (row = 0; row < used_rows; row++) {
319		for (col = 0; col < used_cols; col++) {
320			int code = MATRIX_SCAN_CODE(row, col,
321						    STMPE_KEYPAD_ROW_SHIFT);
322			if (keypad->keymap[code] != KEY_RESERVED) {
323				keypad->rows |= 1 << row;
324				keypad->cols |= 1 << col;
325			}
326		}
327	}
328}
329
330static int stmpe_keypad_probe(struct platform_device *pdev)
331{
332	struct stmpe *stmpe = dev_get_drvdata(pdev->dev.parent);
333	struct device_node *np = pdev->dev.of_node;
334	struct stmpe_keypad *keypad;
335	struct input_dev *input;
336	u32 rows;
337	u32 cols;
338	int error;
339	int irq;
340
341	irq = platform_get_irq(pdev, 0);
342	if (irq < 0)
343		return irq;
344
345	keypad = devm_kzalloc(&pdev->dev, sizeof(struct stmpe_keypad),
346			      GFP_KERNEL);
347	if (!keypad)
348		return -ENOMEM;
349
350	keypad->stmpe = stmpe;
351	keypad->variant = &stmpe_keypad_variants[stmpe->partnum];
352
353	of_property_read_u32(np, "debounce-interval", &keypad->debounce_ms);
354	of_property_read_u32(np, "st,scan-count", &keypad->scan_count);
355	keypad->no_autorepeat = of_property_read_bool(np, "st,no-autorepeat");
356
357	input = devm_input_allocate_device(&pdev->dev);
358	if (!input)
359		return -ENOMEM;
360
361	input->name = "STMPE keypad";
362	input->id.bustype = BUS_I2C;
363	input->dev.parent = &pdev->dev;
364
365	error = matrix_keypad_parse_properties(&pdev->dev, &rows, &cols);
366	if (error)
367		return error;
368
369	error = matrix_keypad_build_keymap(NULL, NULL, rows, cols,
370					   keypad->keymap, input);
371	if (error)
372		return error;
373
374	input_set_capability(input, EV_MSC, MSC_SCAN);
375	if (!keypad->no_autorepeat)
376		__set_bit(EV_REP, input->evbit);
377
378	stmpe_keypad_fill_used_pins(keypad, rows, cols);
379
380	keypad->input = input;
381
382	error = stmpe_keypad_chip_init(keypad);
383	if (error < 0)
384		return error;
385
386	error = devm_request_threaded_irq(&pdev->dev, irq,
387					  NULL, stmpe_keypad_irq,
388					  IRQF_ONESHOT, "stmpe-keypad", keypad);
389	if (error) {
390		dev_err(&pdev->dev, "unable to get irq: %d\n", error);
391		return error;
392	}
393
394	error = input_register_device(input);
395	if (error) {
396		dev_err(&pdev->dev,
397			"unable to register input device: %d\n", error);
398		return error;
399	}
400
401	platform_set_drvdata(pdev, keypad);
402
403	return 0;
404}
405
406static int stmpe_keypad_remove(struct platform_device *pdev)
407{
408	struct stmpe_keypad *keypad = platform_get_drvdata(pdev);
409
410	stmpe_disable(keypad->stmpe, STMPE_BLOCK_KEYPAD);
411
412	return 0;
413}
414
415static struct platform_driver stmpe_keypad_driver = {
416	.driver.name	= "stmpe-keypad",
417	.driver.owner	= THIS_MODULE,
418	.probe		= stmpe_keypad_probe,
419	.remove		= stmpe_keypad_remove,
420};
421module_platform_driver(stmpe_keypad_driver);
422
423MODULE_LICENSE("GPL v2");
424MODULE_DESCRIPTION("STMPExxxx keypad driver");
425MODULE_AUTHOR("Rabin Vincent <rabin.vincent@stericsson.com>");
426