xref: /linux/drivers/input/keyboard/adp5588-keys.c (revision 6c8c1406) 
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * File: drivers/input/keyboard/adp5588_keys.c
4  * Description:  keypad driver for ADP5588 and ADP5587
5  *		 I2C QWERTY Keypad and IO Expander
6  * Bugs: Enter bugs at http://blackfin.uclinux.org/
7  *
8  * Copyright (C) 2008-2010 Analog Devices Inc.
9  */
10 
11 #include <linux/bits.h>
12 #include <linux/delay.h>
13 #include <linux/errno.h>
14 #include <linux/gpio/consumer.h>
15 #include <linux/gpio/driver.h>
16 #include <linux/i2c.h>
17 #include <linux/input.h>
18 #include <linux/input/matrix_keypad.h>
19 #include <linux/interrupt.h>
20 #include <linux/irq.h>
21 #include <linux/ktime.h>
22 #include <linux/module.h>
23 #include <linux/mod_devicetable.h>
24 #include <linux/pinctrl/pinconf-generic.h>
25 #include <linux/platform_device.h>
26 #include <linux/pm.h>
27 #include <linux/regulator/consumer.h>
28 #include <linux/slab.h>
29 #include <linux/timekeeping.h>
30 
31 #define DEV_ID 0x00		/* Device ID */
32 #define CFG 0x01		/* Configuration Register1 */
33 #define INT_STAT 0x02		/* Interrupt Status Register */
34 #define KEY_LCK_EC_STAT 0x03	/* Key Lock and Event Counter Register */
35 #define KEY_EVENTA 0x04		/* Key Event Register A */
36 #define KEY_EVENTB 0x05		/* Key Event Register B */
37 #define KEY_EVENTC 0x06		/* Key Event Register C */
38 #define KEY_EVENTD 0x07		/* Key Event Register D */
39 #define KEY_EVENTE 0x08		/* Key Event Register E */
40 #define KEY_EVENTF 0x09		/* Key Event Register F */
41 #define KEY_EVENTG 0x0A		/* Key Event Register G */
42 #define KEY_EVENTH 0x0B		/* Key Event Register H */
43 #define KEY_EVENTI 0x0C		/* Key Event Register I */
44 #define KEY_EVENTJ 0x0D		/* Key Event Register J */
45 #define KP_LCK_TMR 0x0E		/* Keypad Lock1 to Lock2 Timer */
46 #define UNLOCK1 0x0F		/* Unlock Key1 */
47 #define UNLOCK2 0x10		/* Unlock Key2 */
48 #define GPIO_INT_STAT1 0x11	/* GPIO Interrupt Status */
49 #define GPIO_INT_STAT2 0x12	/* GPIO Interrupt Status */
50 #define GPIO_INT_STAT3 0x13	/* GPIO Interrupt Status */
51 #define GPIO_DAT_STAT1 0x14	/* GPIO Data Status, Read twice to clear */
52 #define GPIO_DAT_STAT2 0x15	/* GPIO Data Status, Read twice to clear */
53 #define GPIO_DAT_STAT3 0x16	/* GPIO Data Status, Read twice to clear */
54 #define GPIO_DAT_OUT1 0x17	/* GPIO DATA OUT */
55 #define GPIO_DAT_OUT2 0x18	/* GPIO DATA OUT */
56 #define GPIO_DAT_OUT3 0x19	/* GPIO DATA OUT */
57 #define GPIO_INT_EN1 0x1A	/* GPIO Interrupt Enable */
58 #define GPIO_INT_EN2 0x1B	/* GPIO Interrupt Enable */
59 #define GPIO_INT_EN3 0x1C	/* GPIO Interrupt Enable */
60 #define KP_GPIO1 0x1D		/* Keypad or GPIO Selection */
61 #define KP_GPIO2 0x1E		/* Keypad or GPIO Selection */
62 #define KP_GPIO3 0x1F		/* Keypad or GPIO Selection */
63 #define GPI_EM1 0x20		/* GPI Event Mode 1 */
64 #define GPI_EM2 0x21		/* GPI Event Mode 2 */
65 #define GPI_EM3 0x22		/* GPI Event Mode 3 */
66 #define GPIO_DIR1 0x23		/* GPIO Data Direction */
67 #define GPIO_DIR2 0x24		/* GPIO Data Direction */
68 #define GPIO_DIR3 0x25		/* GPIO Data Direction */
69 #define GPIO_INT_LVL1 0x26	/* GPIO Edge/Level Detect */
70 #define GPIO_INT_LVL2 0x27	/* GPIO Edge/Level Detect */
71 #define GPIO_INT_LVL3 0x28	/* GPIO Edge/Level Detect */
72 #define DEBOUNCE_DIS1 0x29	/* Debounce Disable */
73 #define DEBOUNCE_DIS2 0x2A	/* Debounce Disable */
74 #define DEBOUNCE_DIS3 0x2B	/* Debounce Disable */
75 #define GPIO_PULL1 0x2C		/* GPIO Pull Disable */
76 #define GPIO_PULL2 0x2D		/* GPIO Pull Disable */
77 #define GPIO_PULL3 0x2E		/* GPIO Pull Disable */
78 #define CMP_CFG_STAT 0x30	/* Comparator Configuration and Status Register */
79 #define CMP_CONFG_SENS1 0x31	/* Sensor1 Comparator Configuration Register */
80 #define CMP_CONFG_SENS2 0x32	/* L2 Light Sensor Reference Level, Output Falling for Sensor 1 */
81 #define CMP1_LVL2_TRIP 0x33	/* L2 Light Sensor Hysteresis (Active when Output Rising) for Sensor 1 */
82 #define CMP1_LVL2_HYS 0x34	/* L3 Light Sensor Reference Level, Output Falling For Sensor 1 */
83 #define CMP1_LVL3_TRIP 0x35	/* L3 Light Sensor Hysteresis (Active when Output Rising) For Sensor 1 */
84 #define CMP1_LVL3_HYS 0x36	/* Sensor 2 Comparator Configuration Register */
85 #define CMP2_LVL2_TRIP 0x37	/* L2 Light Sensor Reference Level, Output Falling for Sensor 2 */
86 #define CMP2_LVL2_HYS 0x38	/* L2 Light Sensor Hysteresis (Active when Output Rising) for Sensor 2 */
87 #define CMP2_LVL3_TRIP 0x39	/* L3 Light Sensor Reference Level, Output Falling For Sensor 2 */
88 #define CMP2_LVL3_HYS 0x3A	/* L3 Light Sensor Hysteresis (Active when Output Rising) For Sensor 2 */
89 #define CMP1_ADC_DAT_R1 0x3B	/* Comparator 1 ADC data Register1 */
90 #define CMP1_ADC_DAT_R2 0x3C	/* Comparator 1 ADC data Register2 */
91 #define CMP2_ADC_DAT_R1 0x3D	/* Comparator 2 ADC data Register1 */
92 #define CMP2_ADC_DAT_R2 0x3E	/* Comparator 2 ADC data Register2 */
93 
94 #define ADP5588_DEVICE_ID_MASK	0xF
95 
96  /* Configuration Register1 */
97 #define ADP5588_AUTO_INC	BIT(7)
98 #define ADP5588_GPIEM_CFG	BIT(6)
99 #define ADP5588_OVR_FLOW_M	BIT(5)
100 #define ADP5588_INT_CFG		BIT(4)
101 #define ADP5588_OVR_FLOW_IEN	BIT(3)
102 #define ADP5588_K_LCK_IM	BIT(2)
103 #define ADP5588_GPI_IEN		BIT(1)
104 #define ADP5588_KE_IEN		BIT(0)
105 
106 /* Interrupt Status Register */
107 #define ADP5588_CMP2_INT	BIT(5)
108 #define ADP5588_CMP1_INT	BIT(4)
109 #define ADP5588_OVR_FLOW_INT	BIT(3)
110 #define ADP5588_K_LCK_INT	BIT(2)
111 #define ADP5588_GPI_INT		BIT(1)
112 #define ADP5588_KE_INT		BIT(0)
113 
114 /* Key Lock and Event Counter Register */
115 #define ADP5588_K_LCK_EN	BIT(6)
116 #define ADP5588_LCK21		0x30
117 #define ADP5588_KEC		GENMASK(3, 0)
118 
119 #define ADP5588_MAXGPIO		18
120 #define ADP5588_BANK(offs)	((offs) >> 3)
121 #define ADP5588_BIT(offs)	(1u << ((offs) & 0x7))
122 
123 /* Put one of these structures in i2c_board_info platform_data */
124 
125 /*
126  * 128 so it fits matrix-keymap maximum number of keys when the full
127  * 10cols * 8rows are used.
128  */
129 #define ADP5588_KEYMAPSIZE 128
130 
131 #define GPI_PIN_ROW0 97
132 #define GPI_PIN_ROW1 98
133 #define GPI_PIN_ROW2 99
134 #define GPI_PIN_ROW3 100
135 #define GPI_PIN_ROW4 101
136 #define GPI_PIN_ROW5 102
137 #define GPI_PIN_ROW6 103
138 #define GPI_PIN_ROW7 104
139 #define GPI_PIN_COL0 105
140 #define GPI_PIN_COL1 106
141 #define GPI_PIN_COL2 107
142 #define GPI_PIN_COL3 108
143 #define GPI_PIN_COL4 109
144 #define GPI_PIN_COL5 110
145 #define GPI_PIN_COL6 111
146 #define GPI_PIN_COL7 112
147 #define GPI_PIN_COL8 113
148 #define GPI_PIN_COL9 114
149 
150 #define GPI_PIN_ROW_BASE GPI_PIN_ROW0
151 #define GPI_PIN_ROW_END GPI_PIN_ROW7
152 #define GPI_PIN_COL_BASE GPI_PIN_COL0
153 #define GPI_PIN_COL_END GPI_PIN_COL9
154 
155 #define GPI_PIN_BASE GPI_PIN_ROW_BASE
156 #define GPI_PIN_END GPI_PIN_COL_END
157 
158 #define ADP5588_ROWS_MAX (GPI_PIN_ROW7 - GPI_PIN_ROW0 + 1)
159 #define ADP5588_COLS_MAX (GPI_PIN_COL9 - GPI_PIN_COL0 + 1)
160 
161 #define ADP5588_GPIMAPSIZE_MAX (GPI_PIN_END - GPI_PIN_BASE + 1)
162 
163 /* Key Event Register xy */
164 #define KEY_EV_PRESSED		BIT(7)
165 #define KEY_EV_MASK		GENMASK(6, 0)
166 
167 #define KP_SEL(x)		(BIT(x) - 1)	/* 2^x-1 */
168 
169 #define KEYP_MAX_EVENT		10
170 
171 /*
172  * Early pre 4.0 Silicon required to delay readout by at least 25ms,
173  * since the Event Counter Register updated 25ms after the interrupt
174  * asserted.
175  */
176 #define WA_DELAYED_READOUT_REVID(rev)		((rev) < 4)
177 #define WA_DELAYED_READOUT_TIME			25
178 
179 #define ADP5588_INVALID_HWIRQ	(~0UL)
180 
181 struct adp5588_kpad {
182 	struct i2c_client *client;
183 	struct input_dev *input;
184 	ktime_t irq_time;
185 	unsigned long delay;
186 	u32 row_shift;
187 	u32 rows;
188 	u32 cols;
189 	u32 unlock_keys[2];
190 	int nkeys_unlock;
191 	unsigned short keycode[ADP5588_KEYMAPSIZE];
192 	unsigned char gpiomap[ADP5588_MAXGPIO];
193 	struct gpio_chip gc;
194 	struct mutex gpio_lock;	/* Protect cached dir, dat_out */
195 	u8 dat_out[3];
196 	u8 dir[3];
197 	u8 int_en[3];
198 	u8 irq_mask[3];
199 	u8 pull_dis[3];
200 };
201 
202 static int adp5588_read(struct i2c_client *client, u8 reg)
203 {
204 	int ret = i2c_smbus_read_byte_data(client, reg);
205 
206 	if (ret < 0)
207 		dev_err(&client->dev, "Read Error\n");
208 
209 	return ret;
210 }
211 
212 static int adp5588_write(struct i2c_client *client, u8 reg, u8 val)
213 {
214 	return i2c_smbus_write_byte_data(client, reg, val);
215 }
216 
217 static int adp5588_gpio_get_value(struct gpio_chip *chip, unsigned int off)
218 {
219 	struct adp5588_kpad *kpad = gpiochip_get_data(chip);
220 	unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
221 	unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
222 	int val;
223 
224 	mutex_lock(&kpad->gpio_lock);
225 
226 	if (kpad->dir[bank] & bit)
227 		val = kpad->dat_out[bank];
228 	else
229 		val = adp5588_read(kpad->client, GPIO_DAT_STAT1 + bank);
230 
231 	mutex_unlock(&kpad->gpio_lock);
232 
233 	return !!(val & bit);
234 }
235 
236 static void adp5588_gpio_set_value(struct gpio_chip *chip,
237 				   unsigned int off, int val)
238 {
239 	struct adp5588_kpad *kpad = gpiochip_get_data(chip);
240 	unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
241 	unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
242 
243 	mutex_lock(&kpad->gpio_lock);
244 
245 	if (val)
246 		kpad->dat_out[bank] |= bit;
247 	else
248 		kpad->dat_out[bank] &= ~bit;
249 
250 	adp5588_write(kpad->client, GPIO_DAT_OUT1 + bank, kpad->dat_out[bank]);
251 
252 	mutex_unlock(&kpad->gpio_lock);
253 }
254 
255 static int adp5588_gpio_set_config(struct gpio_chip *chip,  unsigned int off,
256 				   unsigned long config)
257 {
258 	struct adp5588_kpad *kpad = gpiochip_get_data(chip);
259 	unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
260 	unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
261 	bool pull_disable;
262 	int ret;
263 
264 	switch (pinconf_to_config_param(config)) {
265 	case PIN_CONFIG_BIAS_PULL_UP:
266 		pull_disable = false;
267 		break;
268 	case PIN_CONFIG_BIAS_DISABLE:
269 		pull_disable = true;
270 		break;
271 	default:
272 		return -ENOTSUPP;
273 	}
274 
275 	mutex_lock(&kpad->gpio_lock);
276 
277 	if (pull_disable)
278 		kpad->pull_dis[bank] |= bit;
279 	else
280 		kpad->pull_dis[bank] &= bit;
281 
282 	ret = adp5588_write(kpad->client, GPIO_PULL1 + bank,
283 			    kpad->pull_dis[bank]);
284 
285 	mutex_unlock(&kpad->gpio_lock);
286 
287 	return ret;
288 }
289 
290 static int adp5588_gpio_direction_input(struct gpio_chip *chip, unsigned int off)
291 {
292 	struct adp5588_kpad *kpad = gpiochip_get_data(chip);
293 	unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
294 	unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
295 	int ret;
296 
297 	mutex_lock(&kpad->gpio_lock);
298 
299 	kpad->dir[bank] &= ~bit;
300 	ret = adp5588_write(kpad->client, GPIO_DIR1 + bank, kpad->dir[bank]);
301 
302 	mutex_unlock(&kpad->gpio_lock);
303 
304 	return ret;
305 }
306 
307 static int adp5588_gpio_direction_output(struct gpio_chip *chip,
308 					 unsigned int off, int val)
309 {
310 	struct adp5588_kpad *kpad = gpiochip_get_data(chip);
311 	unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
312 	unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
313 	int ret;
314 
315 	mutex_lock(&kpad->gpio_lock);
316 
317 	kpad->dir[bank] |= bit;
318 
319 	if (val)
320 		kpad->dat_out[bank] |= bit;
321 	else
322 		kpad->dat_out[bank] &= ~bit;
323 
324 	ret = adp5588_write(kpad->client, GPIO_DAT_OUT1 + bank,
325 			    kpad->dat_out[bank]);
326 	if (ret)
327 		goto out_unlock;
328 
329 	ret = adp5588_write(kpad->client, GPIO_DIR1 + bank, kpad->dir[bank]);
330 
331 out_unlock:
332 	mutex_unlock(&kpad->gpio_lock);
333 
334 	return ret;
335 }
336 
337 static int adp5588_build_gpiomap(struct adp5588_kpad *kpad)
338 {
339 	bool pin_used[ADP5588_MAXGPIO];
340 	int n_unused = 0;
341 	int i;
342 
343 	memset(pin_used, 0, sizeof(pin_used));
344 
345 	for (i = 0; i < kpad->rows; i++)
346 		pin_used[i] = true;
347 
348 	for (i = 0; i < kpad->cols; i++)
349 		pin_used[i + GPI_PIN_COL_BASE - GPI_PIN_BASE] = true;
350 
351 	for (i = 0; i < ADP5588_MAXGPIO; i++)
352 		if (!pin_used[i])
353 			kpad->gpiomap[n_unused++] = i;
354 
355 	return n_unused;
356 }
357 
358 static void adp5588_irq_bus_lock(struct irq_data *d)
359 {
360 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
361 	struct adp5588_kpad *kpad = gpiochip_get_data(gc);
362 
363 	mutex_lock(&kpad->gpio_lock);
364 }
365 
366 static void adp5588_irq_bus_sync_unlock(struct irq_data *d)
367 {
368 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
369 	struct adp5588_kpad *kpad = gpiochip_get_data(gc);
370 	int i;
371 
372 	for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) {
373 		if (kpad->int_en[i] ^ kpad->irq_mask[i]) {
374 			kpad->int_en[i] = kpad->irq_mask[i];
375 			adp5588_write(kpad->client, GPI_EM1 + i, kpad->int_en[i]);
376 		}
377 	}
378 
379 	mutex_unlock(&kpad->gpio_lock);
380 }
381 
382 static void adp5588_irq_mask(struct irq_data *d)
383 {
384 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
385 	struct adp5588_kpad *kpad = gpiochip_get_data(gc);
386 	irq_hw_number_t hwirq = irqd_to_hwirq(d);
387 	unsigned long real_irq = kpad->gpiomap[hwirq];
388 
389 	kpad->irq_mask[ADP5588_BANK(real_irq)] &= ~ADP5588_BIT(real_irq);
390 	gpiochip_disable_irq(gc, hwirq);
391 }
392 
393 static void adp5588_irq_unmask(struct irq_data *d)
394 {
395 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
396 	struct adp5588_kpad *kpad = gpiochip_get_data(gc);
397 	irq_hw_number_t hwirq = irqd_to_hwirq(d);
398 	unsigned long real_irq = kpad->gpiomap[hwirq];
399 
400 	gpiochip_enable_irq(gc, hwirq);
401 	kpad->irq_mask[ADP5588_BANK(real_irq)] |= ADP5588_BIT(real_irq);
402 }
403 
404 static int adp5588_irq_set_type(struct irq_data *d, unsigned int type)
405 {
406 	if (!(type & IRQ_TYPE_EDGE_BOTH))
407 		return -EINVAL;
408 
409 	irq_set_handler_locked(d, handle_edge_irq);
410 
411 	return 0;
412 }
413 
414 static const struct irq_chip adp5588_irq_chip = {
415 	.name = "adp5588",
416 	.irq_mask = adp5588_irq_mask,
417 	.irq_unmask = adp5588_irq_unmask,
418 	.irq_bus_lock = adp5588_irq_bus_lock,
419 	.irq_bus_sync_unlock = adp5588_irq_bus_sync_unlock,
420 	.irq_set_type = adp5588_irq_set_type,
421 	.flags = IRQCHIP_SKIP_SET_WAKE | IRQCHIP_IMMUTABLE,
422 	GPIOCHIP_IRQ_RESOURCE_HELPERS,
423 };
424 
425 static int adp5588_gpio_add(struct adp5588_kpad *kpad)
426 {
427 	struct device *dev = &kpad->client->dev;
428 	struct gpio_irq_chip *girq;
429 	int i, error;
430 
431 	kpad->gc.ngpio = adp5588_build_gpiomap(kpad);
432 	if (kpad->gc.ngpio == 0) {
433 		dev_info(dev, "No unused gpios left to export\n");
434 		return 0;
435 	}
436 
437 	kpad->gc.parent = &kpad->client->dev;
438 	kpad->gc.direction_input = adp5588_gpio_direction_input;
439 	kpad->gc.direction_output = adp5588_gpio_direction_output;
440 	kpad->gc.get = adp5588_gpio_get_value;
441 	kpad->gc.set = adp5588_gpio_set_value;
442 	kpad->gc.set_config = adp5588_gpio_set_config;
443 	kpad->gc.can_sleep = 1;
444 
445 	kpad->gc.base = -1;
446 	kpad->gc.label = kpad->client->name;
447 	kpad->gc.owner = THIS_MODULE;
448 
449 	girq = &kpad->gc.irq;
450 	gpio_irq_chip_set_chip(girq, &adp5588_irq_chip);
451 	girq->handler = handle_bad_irq;
452 	girq->threaded = true;
453 
454 	mutex_init(&kpad->gpio_lock);
455 
456 	error = devm_gpiochip_add_data(dev, &kpad->gc, kpad);
457 	if (error) {
458 		dev_err(dev, "gpiochip_add failed: %d\n", error);
459 		return error;
460 	}
461 
462 	for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) {
463 		kpad->dat_out[i] = adp5588_read(kpad->client,
464 						GPIO_DAT_OUT1 + i);
465 		kpad->dir[i] = adp5588_read(kpad->client, GPIO_DIR1 + i);
466 		kpad->pull_dis[i] = adp5588_read(kpad->client, GPIO_PULL1 + i);
467 	}
468 
469 	return 0;
470 }
471 
472 static unsigned long adp5588_gpiomap_get_hwirq(struct device *dev,
473 					       const u8 *map, unsigned int gpio,
474 					       unsigned int ngpios)
475 {
476 	unsigned int hwirq;
477 
478 	for (hwirq = 0; hwirq < ngpios; hwirq++)
479 		if (map[hwirq] == gpio)
480 			return hwirq;
481 
482 	/* should never happen */
483 	dev_warn_ratelimited(dev, "could not find the hwirq for gpio(%u)\n", gpio);
484 
485 	return ADP5588_INVALID_HWIRQ;
486 }
487 
488 static void adp5588_gpio_irq_handle(struct adp5588_kpad *kpad, int key_val,
489 				    int key_press)
490 {
491 	unsigned int irq, gpio = key_val - GPI_PIN_BASE, irq_type;
492 	struct i2c_client *client = kpad->client;
493 	struct irq_data *irqd;
494 	unsigned long hwirq;
495 
496 	hwirq = adp5588_gpiomap_get_hwirq(&client->dev, kpad->gpiomap,
497 					  gpio, kpad->gc.ngpio);
498 	if (hwirq == ADP5588_INVALID_HWIRQ) {
499 		dev_err(&client->dev, "Could not get hwirq for key(%u)\n", key_val);
500 		return;
501 	}
502 
503 	irq = irq_find_mapping(kpad->gc.irq.domain, hwirq);
504 	if (!irq)
505 		return;
506 
507 	irqd = irq_get_irq_data(irq);
508 	if (!irqd) {
509 		dev_err(&client->dev, "Could not get irq(%u) data\n", irq);
510 		return;
511 	}
512 
513 	irq_type = irqd_get_trigger_type(irqd);
514 
515 	/*
516 	 * Default is active low which means key_press is asserted on
517 	 * the falling edge.
518 	 */
519 	if ((irq_type & IRQ_TYPE_EDGE_RISING && !key_press) ||
520 	    (irq_type & IRQ_TYPE_EDGE_FALLING && key_press))
521 		handle_nested_irq(irq);
522 }
523 
524 static void adp5588_report_events(struct adp5588_kpad *kpad, int ev_cnt)
525 {
526 	int i;
527 
528 	for (i = 0; i < ev_cnt; i++) {
529 		int key = adp5588_read(kpad->client, KEY_EVENTA + i);
530 		int key_val = key & KEY_EV_MASK;
531 		int key_press = key & KEY_EV_PRESSED;
532 
533 		if (key_val >= GPI_PIN_BASE && key_val <= GPI_PIN_END) {
534 			/* gpio line used as IRQ source */
535 			adp5588_gpio_irq_handle(kpad, key_val, key_press);
536 		} else {
537 			int row = (key_val - 1) / ADP5588_COLS_MAX;
538 			int col =  (key_val - 1) % ADP5588_COLS_MAX;
539 			int code = MATRIX_SCAN_CODE(row, col, kpad->row_shift);
540 
541 			dev_dbg_ratelimited(&kpad->client->dev,
542 					    "report key(%d) r(%d) c(%d) code(%d)\n",
543 					    key_val, row, col, kpad->keycode[code]);
544 
545 			input_report_key(kpad->input,
546 					 kpad->keycode[code], key_press);
547 		}
548 	}
549 }
550 
551 static irqreturn_t adp5588_hard_irq(int irq, void *handle)
552 {
553 	struct adp5588_kpad *kpad = handle;
554 
555 	kpad->irq_time = ktime_get();
556 
557 	return IRQ_WAKE_THREAD;
558 }
559 
560 static irqreturn_t adp5588_thread_irq(int irq, void *handle)
561 {
562 	struct adp5588_kpad *kpad = handle;
563 	struct i2c_client *client = kpad->client;
564 	ktime_t target_time, now;
565 	unsigned long delay;
566 	int status, ev_cnt;
567 
568 	/*
569 	 * Readout needs to wait for at least 25ms after the notification
570 	 * for REVID < 4.
571 	 */
572 	if (kpad->delay) {
573 		target_time = ktime_add_ms(kpad->irq_time, kpad->delay);
574 		now = ktime_get();
575 		if (ktime_before(now, target_time)) {
576 			delay = ktime_to_us(ktime_sub(target_time, now));
577 			usleep_range(delay, delay + 1000);
578 		}
579 	}
580 
581 	status = adp5588_read(client, INT_STAT);
582 
583 	if (status & ADP5588_OVR_FLOW_INT)	/* Unlikely and should never happen */
584 		dev_err(&client->dev, "Event Overflow Error\n");
585 
586 	if (status & ADP5588_KE_INT) {
587 		ev_cnt = adp5588_read(client, KEY_LCK_EC_STAT) & ADP5588_KEC;
588 		if (ev_cnt) {
589 			adp5588_report_events(kpad, ev_cnt);
590 			input_sync(kpad->input);
591 		}
592 	}
593 
594 	adp5588_write(client, INT_STAT, status); /* Status is W1C */
595 
596 	return IRQ_HANDLED;
597 }
598 
599 static int adp5588_setup(struct adp5588_kpad *kpad)
600 {
601 	struct i2c_client *client = kpad->client;
602 	int i, ret;
603 
604 	ret = adp5588_write(client, KP_GPIO1, KP_SEL(kpad->rows));
605 	if (ret)
606 		return ret;
607 
608 	ret = adp5588_write(client, KP_GPIO2, KP_SEL(kpad->cols) & 0xFF);
609 	if (ret)
610 		return ret;
611 
612 	ret = adp5588_write(client, KP_GPIO3, KP_SEL(kpad->cols) >> 8);
613 	if (ret)
614 		return ret;
615 
616 	for (i = 0; i < kpad->nkeys_unlock; i++) {
617 		ret = adp5588_write(client, UNLOCK1 + i, kpad->unlock_keys[i]);
618 		if (ret)
619 			return ret;
620 	}
621 
622 	if (kpad->nkeys_unlock) {
623 		ret = adp5588_write(client, KEY_LCK_EC_STAT, ADP5588_K_LCK_EN);
624 		if (ret)
625 			return ret;
626 	}
627 
628 	for (i = 0; i < KEYP_MAX_EVENT; i++) {
629 		ret = adp5588_read(client, KEY_EVENTA);
630 		if (ret)
631 			return ret;
632 	}
633 
634 	ret = adp5588_write(client, INT_STAT,
635 			    ADP5588_CMP2_INT | ADP5588_CMP1_INT |
636 			    ADP5588_OVR_FLOW_INT | ADP5588_K_LCK_INT |
637 			    ADP5588_GPI_INT | ADP5588_KE_INT); /* Status is W1C */
638 	if (ret)
639 		return ret;
640 
641 	return adp5588_write(client, CFG, ADP5588_INT_CFG |
642 			     ADP5588_OVR_FLOW_IEN | ADP5588_KE_IEN);
643 }
644 
645 static int adp5588_fw_parse(struct adp5588_kpad *kpad)
646 {
647 	struct i2c_client *client = kpad->client;
648 	int ret, i;
649 
650 	ret = matrix_keypad_parse_properties(&client->dev, &kpad->rows,
651 					     &kpad->cols);
652 	if (ret)
653 		return ret;
654 
655 	if (kpad->rows > ADP5588_ROWS_MAX || kpad->cols > ADP5588_COLS_MAX) {
656 		dev_err(&client->dev, "Invalid nr of rows(%u) or cols(%u)\n",
657 			kpad->rows, kpad->cols);
658 		return -EINVAL;
659 	}
660 
661 	ret = matrix_keypad_build_keymap(NULL, NULL, kpad->rows, kpad->cols,
662 					 kpad->keycode, kpad->input);
663 	if (ret)
664 		return ret;
665 
666 	kpad->row_shift = get_count_order(kpad->cols);
667 
668 	if (device_property_read_bool(&client->dev, "autorepeat"))
669 		__set_bit(EV_REP, kpad->input->evbit);
670 
671 	kpad->nkeys_unlock = device_property_count_u32(&client->dev,
672 						       "adi,unlock-keys");
673 	if (kpad->nkeys_unlock <= 0) {
674 		/* so that we don't end up enabling key lock */
675 		kpad->nkeys_unlock = 0;
676 		return 0;
677 	}
678 
679 	if (kpad->nkeys_unlock > ARRAY_SIZE(kpad->unlock_keys)) {
680 		dev_err(&client->dev, "number of unlock keys(%d) > (%zu)\n",
681 			kpad->nkeys_unlock, ARRAY_SIZE(kpad->unlock_keys));
682 		return -EINVAL;
683 	}
684 
685 	ret = device_property_read_u32_array(&client->dev, "adi,unlock-keys",
686 					     kpad->unlock_keys,
687 					     kpad->nkeys_unlock);
688 	if (ret)
689 		return ret;
690 
691 	for (i = 0; i < kpad->nkeys_unlock; i++) {
692 		/*
693 		 * Even though it should be possible (as stated in the datasheet)
694 		 * to use GPIs (which are part of the keys event) as unlock keys,
695 		 * it was not working at all and was leading to overflow events
696 		 * at some point. Hence, for now, let's just allow keys which are
697 		 * part of keypad matrix to be used and if a reliable way of
698 		 * using GPIs is found, this condition can be removed/lightened.
699 		 */
700 		if (kpad->unlock_keys[i] >= kpad->cols * kpad->rows) {
701 			dev_err(&client->dev, "Invalid unlock key(%d)\n",
702 				kpad->unlock_keys[i]);
703 			return -EINVAL;
704 		}
705 
706 		/*
707 		 * Firmware properties keys start from 0 but on the device they
708 		 * start from 1.
709 		 */
710 		kpad->unlock_keys[i] += 1;
711 	}
712 
713 	return 0;
714 }
715 
716 static void adp5588_disable_regulator(void *reg)
717 {
718 	regulator_disable(reg);
719 }
720 
721 static int adp5588_probe(struct i2c_client *client,
722 			 const struct i2c_device_id *id)
723 {
724 	struct adp5588_kpad *kpad;
725 	struct input_dev *input;
726 	struct gpio_desc *gpio;
727 	struct regulator *vcc;
728 	unsigned int revid;
729 	int ret;
730 	int error;
731 
732 	if (!i2c_check_functionality(client->adapter,
733 				     I2C_FUNC_SMBUS_BYTE_DATA)) {
734 		dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
735 		return -EIO;
736 	}
737 
738 	kpad = devm_kzalloc(&client->dev, sizeof(*kpad), GFP_KERNEL);
739 	if (!kpad)
740 		return -ENOMEM;
741 
742 	input = devm_input_allocate_device(&client->dev);
743 	if (!input)
744 		return -ENOMEM;
745 
746 	kpad->client = client;
747 	kpad->input = input;
748 
749 	error = adp5588_fw_parse(kpad);
750 	if (error)
751 		return error;
752 
753 	vcc = devm_regulator_get(&client->dev, "vcc");
754 	if (IS_ERR(vcc))
755 		return PTR_ERR(vcc);
756 
757 	error = regulator_enable(vcc);
758 	if (error)
759 		return error;
760 
761 	error = devm_add_action_or_reset(&client->dev,
762 					 adp5588_disable_regulator, vcc);
763 	if (error)
764 		return error;
765 
766 	gpio = devm_gpiod_get_optional(&client->dev, "reset", GPIOD_OUT_HIGH);
767 	if (IS_ERR(gpio))
768 		return PTR_ERR(gpio);
769 
770 	if (gpio) {
771 		fsleep(30);
772 		gpiod_set_value_cansleep(gpio, 0);
773 		fsleep(60);
774 	}
775 
776 	ret = adp5588_read(client, DEV_ID);
777 	if (ret < 0)
778 		return ret;
779 
780 	revid = ret & ADP5588_DEVICE_ID_MASK;
781 	if (WA_DELAYED_READOUT_REVID(revid))
782 		kpad->delay = msecs_to_jiffies(WA_DELAYED_READOUT_TIME);
783 
784 	input->name = client->name;
785 	input->phys = "adp5588-keys/input0";
786 
787 	input_set_drvdata(input, kpad);
788 
789 	input->id.bustype = BUS_I2C;
790 	input->id.vendor = 0x0001;
791 	input->id.product = 0x0001;
792 	input->id.version = revid;
793 
794 	error = input_register_device(input);
795 	if (error) {
796 		dev_err(&client->dev, "unable to register input device: %d\n",
797 			error);
798 		return error;
799 	}
800 
801 	error = adp5588_setup(kpad);
802 	if (error)
803 		return error;
804 
805 	error = adp5588_gpio_add(kpad);
806 	if (error)
807 		return error;
808 
809 	error = devm_request_threaded_irq(&client->dev, client->irq,
810 					  adp5588_hard_irq, adp5588_thread_irq,
811 					  IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
812 					  client->dev.driver->name, kpad);
813 	if (error) {
814 		dev_err(&client->dev, "failed to request irq %d: %d\n",
815 			client->irq, error);
816 		return error;
817 	}
818 
819 	dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq);
820 	return 0;
821 }
822 
823 static void adp5588_remove(struct i2c_client *client)
824 {
825 	adp5588_write(client, CFG, 0);
826 
827 	/* all resources will be freed by devm */
828 }
829 
830 static int adp5588_suspend(struct device *dev)
831 {
832 	struct i2c_client *client = to_i2c_client(dev);
833 
834 	disable_irq(client->irq);
835 
836 	return 0;
837 }
838 
839 static int adp5588_resume(struct device *dev)
840 {
841 	struct i2c_client *client = to_i2c_client(dev);
842 
843 	enable_irq(client->irq);
844 
845 	return 0;
846 }
847 
848 static DEFINE_SIMPLE_DEV_PM_OPS(adp5588_dev_pm_ops, adp5588_suspend, adp5588_resume);
849 
850 static const struct i2c_device_id adp5588_id[] = {
851 	{ "adp5588-keys", 0 },
852 	{ "adp5587-keys", 0 },
853 	{ }
854 };
855 MODULE_DEVICE_TABLE(i2c, adp5588_id);
856 
857 static const struct of_device_id adp5588_of_match[] = {
858 	{ .compatible = "adi,adp5588" },
859 	{ .compatible = "adi,adp5587" },
860 	{}
861 };
862 MODULE_DEVICE_TABLE(of, adp5588_of_match);
863 
864 static struct i2c_driver adp5588_driver = {
865 	.driver = {
866 		.name = KBUILD_MODNAME,
867 		.of_match_table = adp5588_of_match,
868 		.pm   = pm_sleep_ptr(&adp5588_dev_pm_ops),
869 	},
870 	.probe    = adp5588_probe,
871 	.remove   = adp5588_remove,
872 	.id_table = adp5588_id,
873 };
874 
875 module_i2c_driver(adp5588_driver);
876 
877 MODULE_LICENSE("GPL");
878 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
879 MODULE_DESCRIPTION("ADP5588/87 Keypad driver");
880