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 181struct 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 202static 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 212static int adp5588_write(struct i2c_client *client, u8 reg, u8 val) 213{ 214 return i2c_smbus_write_byte_data(client, reg, val); 215} 216 217static 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 236static 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 255static 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 290static 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 307static 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 331out_unlock: 332 mutex_unlock(&kpad->gpio_lock); 333 334 return ret; 335} 336 337static 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 358static 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 366static 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 382static 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 393static 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 404static 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 414static 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 425static 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 472static 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 488static 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 524static 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 551static 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 560static 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 599static 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 645static 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 716static 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(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(&client->dev, 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(&client->dev, "vcc"); 747 if (error) 748 return error; 749 750 gpio = devm_gpiod_get_optional(&client->dev, "reset", GPIOD_OUT_HIGH); 751 if (IS_ERR(gpio)) 752 return PTR_ERR(gpio); 753 754 if (gpio) { 755 fsleep(30); 756 gpiod_set_value_cansleep(gpio, 0); 757 fsleep(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(input, 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(&client->dev, client->irq, 794 adp5588_hard_irq, adp5588_thread_irq, 795 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 796 client->dev.driver->name, 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 807static void adp5588_remove(struct i2c_client *client) 808{ 809 adp5588_write(client, CFG, 0); 810 811 /* all resources will be freed by devm */ 812} 813 814static int adp5588_suspend(struct device *dev) 815{ 816 struct i2c_client *client = to_i2c_client(dev); 817 818 disable_irq(client->irq); 819 820 return 0; 821} 822 823static int adp5588_resume(struct device *dev) 824{ 825 struct i2c_client *client = to_i2c_client(dev); 826 827 enable_irq(client->irq); 828 829 return 0; 830} 831 832static DEFINE_SIMPLE_DEV_PM_OPS(adp5588_dev_pm_ops, adp5588_suspend, adp5588_resume); 833 834static const struct i2c_device_id adp5588_id[] = { 835 { "adp5588-keys", 0 }, 836 { "adp5587-keys", 0 }, 837 { } 838}; 839MODULE_DEVICE_TABLE(i2c, adp5588_id); 840 841static const struct of_device_id adp5588_of_match[] = { 842 { .compatible = "adi,adp5588" }, 843 { .compatible = "adi,adp5587" }, 844 {} 845}; 846MODULE_DEVICE_TABLE(of, adp5588_of_match); 847 848static 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 859module_i2c_driver(adp5588_driver); 860 861MODULE_LICENSE("GPL"); 862MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>"); 863MODULE_DESCRIPTION("ADP5588/87 Keypad driver"); 864