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, command: 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, command: reg, value: 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(gc: 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(client: kpad->client, GPIO_DAT_STAT1 + bank); |
230 | |
231 | mutex_unlock(lock: &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(gc: 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(client: kpad->client, GPIO_DAT_OUT1 + bank, val: kpad->dat_out[bank]); |
251 | |
252 | mutex_unlock(lock: &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(gc: 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(client: kpad->client, GPIO_PULL1 + bank, |
283 | val: kpad->pull_dis[bank]); |
284 | |
285 | mutex_unlock(lock: &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(gc: 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(client: kpad->client, GPIO_DIR1 + bank, val: kpad->dir[bank]); |
301 | |
302 | mutex_unlock(lock: &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(gc: 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(client: kpad->client, GPIO_DAT_OUT1 + bank, |
325 | val: kpad->dat_out[bank]); |
326 | if (ret) |
327 | goto out_unlock; |
328 | |
329 | ret = adp5588_write(client: kpad->client, GPIO_DIR1 + bank, val: kpad->dir[bank]); |
330 | |
331 | out_unlock: |
332 | mutex_unlock(lock: &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(client: kpad->client, GPI_EM1 + i, val: kpad->int_en[i]); |
376 | } |
377 | } |
378 | |
379 | mutex_unlock(lock: &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, offset: 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, offset: 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(data: d, handler: 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, chip: &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(client: kpad->client, |
464 | GPIO_DAT_OUT1 + i); |
465 | kpad->dir[i] = adp5588_read(client: kpad->client, GPIO_DIR1 + i); |
466 | kpad->pull_dis[i] = adp5588_read(client: 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(dev: &client->dev, map: kpad->gpiomap, |
497 | gpio, ngpios: 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(domain: 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(d: 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(client: 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(dev: kpad->input, |
546 | code: kpad->keycode[code], value: 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(kt: kpad->irq_time, msec: kpad->delay); |
574 | now = ktime_get(); |
575 | if (ktime_before(cmp1: now, cmp2: target_time)) { |
576 | delay = ktime_to_us(ktime_sub(target_time, now)); |
577 | usleep_range(min: delay, max: 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(dev: kpad->input); |
591 | } |
592 | } |
593 | |
594 | adp5588_write(client, INT_STAT, val: 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, val: 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(dev: &client->dev, rows: &kpad->rows, |
651 | cols: &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, rows: kpad->rows, cols: kpad->cols, |
662 | keymap: kpad->keycode, input_dev: kpad->input); |
663 | if (ret) |
664 | return ret; |
665 | |
666 | kpad->row_shift = get_count_order(count: kpad->cols); |
667 | |
668 | if (device_property_read_bool(dev: &client->dev, propname: "autorepeat" )) |
669 | __set_bit(EV_REP, kpad->input->evbit); |
670 | |
671 | kpad->nkeys_unlock = device_property_count_u32(dev: &client->dev, |
672 | propname: "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(dev: &client->dev, propname: "adi,unlock-keys" , |
686 | val: kpad->unlock_keys, |
687 | nval: 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 int adp5588_probe(struct i2c_client *client) |
717 | { |
718 | struct adp5588_kpad *kpad; |
719 | struct input_dev *input; |
720 | struct gpio_desc *gpio; |
721 | unsigned int revid; |
722 | int ret; |
723 | int error; |
724 | |
725 | if (!i2c_check_functionality(adap: client->adapter, |
726 | I2C_FUNC_SMBUS_BYTE_DATA)) { |
727 | dev_err(&client->dev, "SMBUS Byte Data not Supported\n" ); |
728 | return -EIO; |
729 | } |
730 | |
731 | kpad = devm_kzalloc(dev: &client->dev, size: sizeof(*kpad), GFP_KERNEL); |
732 | if (!kpad) |
733 | return -ENOMEM; |
734 | |
735 | input = devm_input_allocate_device(&client->dev); |
736 | if (!input) |
737 | return -ENOMEM; |
738 | |
739 | kpad->client = client; |
740 | kpad->input = input; |
741 | |
742 | error = adp5588_fw_parse(kpad); |
743 | if (error) |
744 | return error; |
745 | |
746 | error = devm_regulator_get_enable(dev: &client->dev, id: "vcc" ); |
747 | if (error) |
748 | return error; |
749 | |
750 | gpio = devm_gpiod_get_optional(dev: &client->dev, con_id: "reset" , flags: GPIOD_OUT_HIGH); |
751 | if (IS_ERR(ptr: gpio)) |
752 | return PTR_ERR(ptr: gpio); |
753 | |
754 | if (gpio) { |
755 | fsleep(usecs: 30); |
756 | gpiod_set_value_cansleep(desc: gpio, value: 0); |
757 | fsleep(usecs: 60); |
758 | } |
759 | |
760 | ret = adp5588_read(client, DEV_ID); |
761 | if (ret < 0) |
762 | return ret; |
763 | |
764 | revid = ret & ADP5588_DEVICE_ID_MASK; |
765 | if (WA_DELAYED_READOUT_REVID(revid)) |
766 | kpad->delay = msecs_to_jiffies(WA_DELAYED_READOUT_TIME); |
767 | |
768 | input->name = client->name; |
769 | input->phys = "adp5588-keys/input0" ; |
770 | |
771 | input_set_drvdata(dev: input, data: kpad); |
772 | |
773 | input->id.bustype = BUS_I2C; |
774 | input->id.vendor = 0x0001; |
775 | input->id.product = 0x0001; |
776 | input->id.version = revid; |
777 | |
778 | error = input_register_device(input); |
779 | if (error) { |
780 | dev_err(&client->dev, "unable to register input device: %d\n" , |
781 | error); |
782 | return error; |
783 | } |
784 | |
785 | error = adp5588_setup(kpad); |
786 | if (error) |
787 | return error; |
788 | |
789 | error = adp5588_gpio_add(kpad); |
790 | if (error) |
791 | return error; |
792 | |
793 | error = devm_request_threaded_irq(dev: &client->dev, irq: client->irq, |
794 | handler: adp5588_hard_irq, thread_fn: adp5588_thread_irq, |
795 | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
796 | devname: client->dev.driver->name, dev_id: kpad); |
797 | if (error) { |
798 | dev_err(&client->dev, "failed to request irq %d: %d\n" , |
799 | client->irq, error); |
800 | return error; |
801 | } |
802 | |
803 | dev_info(&client->dev, "Rev.%d keypad, irq %d\n" , revid, client->irq); |
804 | return 0; |
805 | } |
806 | |
807 | static void adp5588_remove(struct i2c_client *client) |
808 | { |
809 | adp5588_write(client, CFG, val: 0); |
810 | |
811 | /* all resources will be freed by devm */ |
812 | } |
813 | |
814 | static int adp5588_suspend(struct device *dev) |
815 | { |
816 | struct i2c_client *client = to_i2c_client(dev); |
817 | |
818 | disable_irq(irq: client->irq); |
819 | |
820 | return 0; |
821 | } |
822 | |
823 | static int adp5588_resume(struct device *dev) |
824 | { |
825 | struct i2c_client *client = to_i2c_client(dev); |
826 | |
827 | enable_irq(irq: client->irq); |
828 | |
829 | return 0; |
830 | } |
831 | |
832 | static DEFINE_SIMPLE_DEV_PM_OPS(adp5588_dev_pm_ops, adp5588_suspend, adp5588_resume); |
833 | |
834 | static const struct i2c_device_id adp5588_id[] = { |
835 | { "adp5588-keys" , 0 }, |
836 | { "adp5587-keys" , 0 }, |
837 | { } |
838 | }; |
839 | MODULE_DEVICE_TABLE(i2c, adp5588_id); |
840 | |
841 | static const struct of_device_id adp5588_of_match[] = { |
842 | { .compatible = "adi,adp5588" }, |
843 | { .compatible = "adi,adp5587" }, |
844 | {} |
845 | }; |
846 | MODULE_DEVICE_TABLE(of, adp5588_of_match); |
847 | |
848 | static struct i2c_driver adp5588_driver = { |
849 | .driver = { |
850 | .name = KBUILD_MODNAME, |
851 | .of_match_table = adp5588_of_match, |
852 | .pm = pm_sleep_ptr(&adp5588_dev_pm_ops), |
853 | }, |
854 | .probe = adp5588_probe, |
855 | .remove = adp5588_remove, |
856 | .id_table = adp5588_id, |
857 | }; |
858 | |
859 | module_i2c_driver(adp5588_driver); |
860 | |
861 | MODULE_LICENSE("GPL" ); |
862 | MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>" ); |
863 | MODULE_DESCRIPTION("ADP5588/87 Keypad driver" ); |
864 | |