1 /* 2 * File: drivers/input/keyboard/adp5588_keys.c 3 * Description: keypad driver for ADP5588 and ADP5587 4 * I2C QWERTY Keypad and IO Expander 5 * Bugs: Enter bugs at http://blackfin.uclinux.org/ 6 * 7 * Copyright (C) 2008-2010 Analog Devices Inc. 8 * Licensed under the GPL-2 or later. 9 */ 10 11 #include <linux/module.h> 12 #include <linux/interrupt.h> 13 #include <linux/irq.h> 14 #include <linux/workqueue.h> 15 #include <linux/errno.h> 16 #include <linux/pm.h> 17 #include <linux/platform_device.h> 18 #include <linux/input.h> 19 #include <linux/i2c.h> 20 #include <linux/gpio.h> 21 #include <linux/slab.h> 22 23 #include <linux/i2c/adp5588.h> 24 25 /* Key Event Register xy */ 26 #define KEY_EV_PRESSED (1 << 7) 27 #define KEY_EV_MASK (0x7F) 28 29 #define KP_SEL(x) (0xFFFF >> (16 - x)) /* 2^x-1 */ 30 31 #define KEYP_MAX_EVENT 10 32 33 /* 34 * Early pre 4.0 Silicon required to delay readout by at least 25ms, 35 * since the Event Counter Register updated 25ms after the interrupt 36 * asserted. 37 */ 38 #define WA_DELAYED_READOUT_REVID(rev) ((rev) < 4) 39 40 struct adp5588_kpad { 41 struct i2c_client *client; 42 struct input_dev *input; 43 struct delayed_work work; 44 unsigned long delay; 45 unsigned short keycode[ADP5588_KEYMAPSIZE]; 46 const struct adp5588_gpi_map *gpimap; 47 unsigned short gpimapsize; 48 #ifdef CONFIG_GPIOLIB 49 unsigned char gpiomap[ADP5588_MAXGPIO]; 50 bool export_gpio; 51 struct gpio_chip gc; 52 struct mutex gpio_lock; /* Protect cached dir, dat_out */ 53 u8 dat_out[3]; 54 u8 dir[3]; 55 #endif 56 }; 57 58 static int adp5588_read(struct i2c_client *client, u8 reg) 59 { 60 int ret = i2c_smbus_read_byte_data(client, reg); 61 62 if (ret < 0) 63 dev_err(&client->dev, "Read Error\n"); 64 65 return ret; 66 } 67 68 static int adp5588_write(struct i2c_client *client, u8 reg, u8 val) 69 { 70 return i2c_smbus_write_byte_data(client, reg, val); 71 } 72 73 #ifdef CONFIG_GPIOLIB 74 static int adp5588_gpio_get_value(struct gpio_chip *chip, unsigned off) 75 { 76 struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc); 77 unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]); 78 unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]); 79 int val; 80 81 mutex_lock(&kpad->gpio_lock); 82 83 if (kpad->dir[bank] & bit) 84 val = kpad->dat_out[bank]; 85 else 86 val = adp5588_read(kpad->client, GPIO_DAT_STAT1 + bank); 87 88 mutex_unlock(&kpad->gpio_lock); 89 90 return !!(val & bit); 91 } 92 93 static void adp5588_gpio_set_value(struct gpio_chip *chip, 94 unsigned off, int val) 95 { 96 struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc); 97 unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]); 98 unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]); 99 100 mutex_lock(&kpad->gpio_lock); 101 102 if (val) 103 kpad->dat_out[bank] |= bit; 104 else 105 kpad->dat_out[bank] &= ~bit; 106 107 adp5588_write(kpad->client, GPIO_DAT_OUT1 + bank, 108 kpad->dat_out[bank]); 109 110 mutex_unlock(&kpad->gpio_lock); 111 } 112 113 static int adp5588_gpio_direction_input(struct gpio_chip *chip, unsigned off) 114 { 115 struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc); 116 unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]); 117 unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]); 118 int ret; 119 120 mutex_lock(&kpad->gpio_lock); 121 122 kpad->dir[bank] &= ~bit; 123 ret = adp5588_write(kpad->client, GPIO_DIR1 + bank, kpad->dir[bank]); 124 125 mutex_unlock(&kpad->gpio_lock); 126 127 return ret; 128 } 129 130 static int adp5588_gpio_direction_output(struct gpio_chip *chip, 131 unsigned off, int val) 132 { 133 struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc); 134 unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]); 135 unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]); 136 int ret; 137 138 mutex_lock(&kpad->gpio_lock); 139 140 kpad->dir[bank] |= bit; 141 142 if (val) 143 kpad->dat_out[bank] |= bit; 144 else 145 kpad->dat_out[bank] &= ~bit; 146 147 ret = adp5588_write(kpad->client, GPIO_DAT_OUT1 + bank, 148 kpad->dat_out[bank]); 149 ret |= adp5588_write(kpad->client, GPIO_DIR1 + bank, 150 kpad->dir[bank]); 151 152 mutex_unlock(&kpad->gpio_lock); 153 154 return ret; 155 } 156 157 static int adp5588_build_gpiomap(struct adp5588_kpad *kpad, 158 const struct adp5588_kpad_platform_data *pdata) 159 { 160 bool pin_used[ADP5588_MAXGPIO]; 161 int n_unused = 0; 162 int i; 163 164 memset(pin_used, 0, sizeof(pin_used)); 165 166 for (i = 0; i < pdata->rows; i++) 167 pin_used[i] = true; 168 169 for (i = 0; i < pdata->cols; i++) 170 pin_used[i + GPI_PIN_COL_BASE - GPI_PIN_BASE] = true; 171 172 for (i = 0; i < kpad->gpimapsize; i++) 173 pin_used[kpad->gpimap[i].pin - GPI_PIN_BASE] = true; 174 175 for (i = 0; i < ADP5588_MAXGPIO; i++) 176 if (!pin_used[i]) 177 kpad->gpiomap[n_unused++] = i; 178 179 return n_unused; 180 } 181 182 static int adp5588_gpio_add(struct adp5588_kpad *kpad) 183 { 184 struct device *dev = &kpad->client->dev; 185 const struct adp5588_kpad_platform_data *pdata = dev_get_platdata(dev); 186 const struct adp5588_gpio_platform_data *gpio_data = pdata->gpio_data; 187 int i, error; 188 189 if (!gpio_data) 190 return 0; 191 192 kpad->gc.ngpio = adp5588_build_gpiomap(kpad, pdata); 193 if (kpad->gc.ngpio == 0) { 194 dev_info(dev, "No unused gpios left to export\n"); 195 return 0; 196 } 197 198 kpad->export_gpio = true; 199 200 kpad->gc.direction_input = adp5588_gpio_direction_input; 201 kpad->gc.direction_output = adp5588_gpio_direction_output; 202 kpad->gc.get = adp5588_gpio_get_value; 203 kpad->gc.set = adp5588_gpio_set_value; 204 kpad->gc.can_sleep = 1; 205 206 kpad->gc.base = gpio_data->gpio_start; 207 kpad->gc.label = kpad->client->name; 208 kpad->gc.owner = THIS_MODULE; 209 kpad->gc.names = gpio_data->names; 210 211 mutex_init(&kpad->gpio_lock); 212 213 error = gpiochip_add(&kpad->gc); 214 if (error) { 215 dev_err(dev, "gpiochip_add failed, err: %d\n", error); 216 return error; 217 } 218 219 for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) { 220 kpad->dat_out[i] = adp5588_read(kpad->client, 221 GPIO_DAT_OUT1 + i); 222 kpad->dir[i] = adp5588_read(kpad->client, GPIO_DIR1 + i); 223 } 224 225 if (gpio_data->setup) { 226 error = gpio_data->setup(kpad->client, 227 kpad->gc.base, kpad->gc.ngpio, 228 gpio_data->context); 229 if (error) 230 dev_warn(dev, "setup failed, %d\n", error); 231 } 232 233 return 0; 234 } 235 236 static void adp5588_gpio_remove(struct adp5588_kpad *kpad) 237 { 238 struct device *dev = &kpad->client->dev; 239 const struct adp5588_kpad_platform_data *pdata = dev_get_platdata(dev); 240 const struct adp5588_gpio_platform_data *gpio_data = pdata->gpio_data; 241 int error; 242 243 if (!kpad->export_gpio) 244 return; 245 246 if (gpio_data->teardown) { 247 error = gpio_data->teardown(kpad->client, 248 kpad->gc.base, kpad->gc.ngpio, 249 gpio_data->context); 250 if (error) 251 dev_warn(dev, "teardown failed %d\n", error); 252 } 253 254 gpiochip_remove(&kpad->gc); 255 } 256 #else 257 static inline int adp5588_gpio_add(struct adp5588_kpad *kpad) 258 { 259 return 0; 260 } 261 262 static inline void adp5588_gpio_remove(struct adp5588_kpad *kpad) 263 { 264 } 265 #endif 266 267 static void adp5588_report_events(struct adp5588_kpad *kpad, int ev_cnt) 268 { 269 int i, j; 270 271 for (i = 0; i < ev_cnt; i++) { 272 int key = adp5588_read(kpad->client, Key_EVENTA + i); 273 int key_val = key & KEY_EV_MASK; 274 275 if (key_val >= GPI_PIN_BASE && key_val <= GPI_PIN_END) { 276 for (j = 0; j < kpad->gpimapsize; j++) { 277 if (key_val == kpad->gpimap[j].pin) { 278 input_report_switch(kpad->input, 279 kpad->gpimap[j].sw_evt, 280 key & KEY_EV_PRESSED); 281 break; 282 } 283 } 284 } else { 285 input_report_key(kpad->input, 286 kpad->keycode[key_val - 1], 287 key & KEY_EV_PRESSED); 288 } 289 } 290 } 291 292 static void adp5588_work(struct work_struct *work) 293 { 294 struct adp5588_kpad *kpad = container_of(work, 295 struct adp5588_kpad, work.work); 296 struct i2c_client *client = kpad->client; 297 int status, ev_cnt; 298 299 status = adp5588_read(client, INT_STAT); 300 301 if (status & ADP5588_OVR_FLOW_INT) /* Unlikely and should never happen */ 302 dev_err(&client->dev, "Event Overflow Error\n"); 303 304 if (status & ADP5588_KE_INT) { 305 ev_cnt = adp5588_read(client, KEY_LCK_EC_STAT) & ADP5588_KEC; 306 if (ev_cnt) { 307 adp5588_report_events(kpad, ev_cnt); 308 input_sync(kpad->input); 309 } 310 } 311 adp5588_write(client, INT_STAT, status); /* Status is W1C */ 312 } 313 314 static irqreturn_t adp5588_irq(int irq, void *handle) 315 { 316 struct adp5588_kpad *kpad = handle; 317 318 /* 319 * use keventd context to read the event fifo registers 320 * Schedule readout at least 25ms after notification for 321 * REVID < 4 322 */ 323 324 schedule_delayed_work(&kpad->work, kpad->delay); 325 326 return IRQ_HANDLED; 327 } 328 329 static int adp5588_setup(struct i2c_client *client) 330 { 331 const struct adp5588_kpad_platform_data *pdata = 332 dev_get_platdata(&client->dev); 333 const struct adp5588_gpio_platform_data *gpio_data = pdata->gpio_data; 334 int i, ret; 335 unsigned char evt_mode1 = 0, evt_mode2 = 0, evt_mode3 = 0; 336 337 ret = adp5588_write(client, KP_GPIO1, KP_SEL(pdata->rows)); 338 ret |= adp5588_write(client, KP_GPIO2, KP_SEL(pdata->cols) & 0xFF); 339 ret |= adp5588_write(client, KP_GPIO3, KP_SEL(pdata->cols) >> 8); 340 341 if (pdata->en_keylock) { 342 ret |= adp5588_write(client, UNLOCK1, pdata->unlock_key1); 343 ret |= adp5588_write(client, UNLOCK2, pdata->unlock_key2); 344 ret |= adp5588_write(client, KEY_LCK_EC_STAT, ADP5588_K_LCK_EN); 345 } 346 347 for (i = 0; i < KEYP_MAX_EVENT; i++) 348 ret |= adp5588_read(client, Key_EVENTA); 349 350 for (i = 0; i < pdata->gpimapsize; i++) { 351 unsigned short pin = pdata->gpimap[i].pin; 352 353 if (pin <= GPI_PIN_ROW_END) { 354 evt_mode1 |= (1 << (pin - GPI_PIN_ROW_BASE)); 355 } else { 356 evt_mode2 |= ((1 << (pin - GPI_PIN_COL_BASE)) & 0xFF); 357 evt_mode3 |= ((1 << (pin - GPI_PIN_COL_BASE)) >> 8); 358 } 359 } 360 361 if (pdata->gpimapsize) { 362 ret |= adp5588_write(client, GPI_EM1, evt_mode1); 363 ret |= adp5588_write(client, GPI_EM2, evt_mode2); 364 ret |= adp5588_write(client, GPI_EM3, evt_mode3); 365 } 366 367 if (gpio_data) { 368 for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) { 369 int pull_mask = gpio_data->pullup_dis_mask; 370 371 ret |= adp5588_write(client, GPIO_PULL1 + i, 372 (pull_mask >> (8 * i)) & 0xFF); 373 } 374 } 375 376 ret |= adp5588_write(client, INT_STAT, 377 ADP5588_CMP2_INT | ADP5588_CMP1_INT | 378 ADP5588_OVR_FLOW_INT | ADP5588_K_LCK_INT | 379 ADP5588_GPI_INT | ADP5588_KE_INT); /* Status is W1C */ 380 381 ret |= adp5588_write(client, CFG, ADP5588_INT_CFG | 382 ADP5588_OVR_FLOW_IEN | 383 ADP5588_KE_IEN); 384 385 if (ret < 0) { 386 dev_err(&client->dev, "Write Error\n"); 387 return ret; 388 } 389 390 return 0; 391 } 392 393 static void adp5588_report_switch_state(struct adp5588_kpad *kpad) 394 { 395 int gpi_stat1 = adp5588_read(kpad->client, GPIO_DAT_STAT1); 396 int gpi_stat2 = adp5588_read(kpad->client, GPIO_DAT_STAT2); 397 int gpi_stat3 = adp5588_read(kpad->client, GPIO_DAT_STAT3); 398 int gpi_stat_tmp, pin_loc; 399 int i; 400 401 for (i = 0; i < kpad->gpimapsize; i++) { 402 unsigned short pin = kpad->gpimap[i].pin; 403 404 if (pin <= GPI_PIN_ROW_END) { 405 gpi_stat_tmp = gpi_stat1; 406 pin_loc = pin - GPI_PIN_ROW_BASE; 407 } else if ((pin - GPI_PIN_COL_BASE) < 8) { 408 gpi_stat_tmp = gpi_stat2; 409 pin_loc = pin - GPI_PIN_COL_BASE; 410 } else { 411 gpi_stat_tmp = gpi_stat3; 412 pin_loc = pin - GPI_PIN_COL_BASE - 8; 413 } 414 415 if (gpi_stat_tmp < 0) { 416 dev_err(&kpad->client->dev, 417 "Can't read GPIO_DAT_STAT switch %d default to OFF\n", 418 pin); 419 gpi_stat_tmp = 0; 420 } 421 422 input_report_switch(kpad->input, 423 kpad->gpimap[i].sw_evt, 424 !(gpi_stat_tmp & (1 << pin_loc))); 425 } 426 427 input_sync(kpad->input); 428 } 429 430 431 static int adp5588_probe(struct i2c_client *client, 432 const struct i2c_device_id *id) 433 { 434 struct adp5588_kpad *kpad; 435 const struct adp5588_kpad_platform_data *pdata = 436 dev_get_platdata(&client->dev); 437 struct input_dev *input; 438 unsigned int revid; 439 int ret, i; 440 int error; 441 442 if (!i2c_check_functionality(client->adapter, 443 I2C_FUNC_SMBUS_BYTE_DATA)) { 444 dev_err(&client->dev, "SMBUS Byte Data not Supported\n"); 445 return -EIO; 446 } 447 448 if (!pdata) { 449 dev_err(&client->dev, "no platform data?\n"); 450 return -EINVAL; 451 } 452 453 if (!pdata->rows || !pdata->cols || !pdata->keymap) { 454 dev_err(&client->dev, "no rows, cols or keymap from pdata\n"); 455 return -EINVAL; 456 } 457 458 if (pdata->keymapsize != ADP5588_KEYMAPSIZE) { 459 dev_err(&client->dev, "invalid keymapsize\n"); 460 return -EINVAL; 461 } 462 463 if (!pdata->gpimap && pdata->gpimapsize) { 464 dev_err(&client->dev, "invalid gpimap from pdata\n"); 465 return -EINVAL; 466 } 467 468 if (pdata->gpimapsize > ADP5588_GPIMAPSIZE_MAX) { 469 dev_err(&client->dev, "invalid gpimapsize\n"); 470 return -EINVAL; 471 } 472 473 for (i = 0; i < pdata->gpimapsize; i++) { 474 unsigned short pin = pdata->gpimap[i].pin; 475 476 if (pin < GPI_PIN_BASE || pin > GPI_PIN_END) { 477 dev_err(&client->dev, "invalid gpi pin data\n"); 478 return -EINVAL; 479 } 480 481 if (pin <= GPI_PIN_ROW_END) { 482 if (pin - GPI_PIN_ROW_BASE + 1 <= pdata->rows) { 483 dev_err(&client->dev, "invalid gpi row data\n"); 484 return -EINVAL; 485 } 486 } else { 487 if (pin - GPI_PIN_COL_BASE + 1 <= pdata->cols) { 488 dev_err(&client->dev, "invalid gpi col data\n"); 489 return -EINVAL; 490 } 491 } 492 } 493 494 if (!client->irq) { 495 dev_err(&client->dev, "no IRQ?\n"); 496 return -EINVAL; 497 } 498 499 kpad = kzalloc(sizeof(*kpad), GFP_KERNEL); 500 input = input_allocate_device(); 501 if (!kpad || !input) { 502 error = -ENOMEM; 503 goto err_free_mem; 504 } 505 506 kpad->client = client; 507 kpad->input = input; 508 INIT_DELAYED_WORK(&kpad->work, adp5588_work); 509 510 ret = adp5588_read(client, DEV_ID); 511 if (ret < 0) { 512 error = ret; 513 goto err_free_mem; 514 } 515 516 revid = (u8) ret & ADP5588_DEVICE_ID_MASK; 517 if (WA_DELAYED_READOUT_REVID(revid)) 518 kpad->delay = msecs_to_jiffies(30); 519 520 input->name = client->name; 521 input->phys = "adp5588-keys/input0"; 522 input->dev.parent = &client->dev; 523 524 input_set_drvdata(input, kpad); 525 526 input->id.bustype = BUS_I2C; 527 input->id.vendor = 0x0001; 528 input->id.product = 0x0001; 529 input->id.version = revid; 530 531 input->keycodesize = sizeof(kpad->keycode[0]); 532 input->keycodemax = pdata->keymapsize; 533 input->keycode = kpad->keycode; 534 535 memcpy(kpad->keycode, pdata->keymap, 536 pdata->keymapsize * input->keycodesize); 537 538 kpad->gpimap = pdata->gpimap; 539 kpad->gpimapsize = pdata->gpimapsize; 540 541 /* setup input device */ 542 __set_bit(EV_KEY, input->evbit); 543 544 if (pdata->repeat) 545 __set_bit(EV_REP, input->evbit); 546 547 for (i = 0; i < input->keycodemax; i++) 548 if (kpad->keycode[i] <= KEY_MAX) 549 __set_bit(kpad->keycode[i], input->keybit); 550 __clear_bit(KEY_RESERVED, input->keybit); 551 552 if (kpad->gpimapsize) 553 __set_bit(EV_SW, input->evbit); 554 for (i = 0; i < kpad->gpimapsize; i++) 555 __set_bit(kpad->gpimap[i].sw_evt, input->swbit); 556 557 error = input_register_device(input); 558 if (error) { 559 dev_err(&client->dev, "unable to register input device\n"); 560 goto err_free_mem; 561 } 562 563 error = request_irq(client->irq, adp5588_irq, 564 IRQF_TRIGGER_FALLING, 565 client->dev.driver->name, kpad); 566 if (error) { 567 dev_err(&client->dev, "irq %d busy?\n", client->irq); 568 goto err_unreg_dev; 569 } 570 571 error = adp5588_setup(client); 572 if (error) 573 goto err_free_irq; 574 575 if (kpad->gpimapsize) 576 adp5588_report_switch_state(kpad); 577 578 error = adp5588_gpio_add(kpad); 579 if (error) 580 goto err_free_irq; 581 582 device_init_wakeup(&client->dev, 1); 583 i2c_set_clientdata(client, kpad); 584 585 dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq); 586 return 0; 587 588 err_free_irq: 589 free_irq(client->irq, kpad); 590 cancel_delayed_work_sync(&kpad->work); 591 err_unreg_dev: 592 input_unregister_device(input); 593 input = NULL; 594 err_free_mem: 595 input_free_device(input); 596 kfree(kpad); 597 598 return error; 599 } 600 601 static int adp5588_remove(struct i2c_client *client) 602 { 603 struct adp5588_kpad *kpad = i2c_get_clientdata(client); 604 605 adp5588_write(client, CFG, 0); 606 free_irq(client->irq, kpad); 607 cancel_delayed_work_sync(&kpad->work); 608 input_unregister_device(kpad->input); 609 adp5588_gpio_remove(kpad); 610 kfree(kpad); 611 612 return 0; 613 } 614 615 #ifdef CONFIG_PM 616 static int adp5588_suspend(struct device *dev) 617 { 618 struct adp5588_kpad *kpad = dev_get_drvdata(dev); 619 struct i2c_client *client = kpad->client; 620 621 disable_irq(client->irq); 622 cancel_delayed_work_sync(&kpad->work); 623 624 if (device_may_wakeup(&client->dev)) 625 enable_irq_wake(client->irq); 626 627 return 0; 628 } 629 630 static int adp5588_resume(struct device *dev) 631 { 632 struct adp5588_kpad *kpad = dev_get_drvdata(dev); 633 struct i2c_client *client = kpad->client; 634 635 if (device_may_wakeup(&client->dev)) 636 disable_irq_wake(client->irq); 637 638 enable_irq(client->irq); 639 640 return 0; 641 } 642 643 static const struct dev_pm_ops adp5588_dev_pm_ops = { 644 .suspend = adp5588_suspend, 645 .resume = adp5588_resume, 646 }; 647 #endif 648 649 static const struct i2c_device_id adp5588_id[] = { 650 { "adp5588-keys", 0 }, 651 { "adp5587-keys", 0 }, 652 { } 653 }; 654 MODULE_DEVICE_TABLE(i2c, adp5588_id); 655 656 static struct i2c_driver adp5588_driver = { 657 .driver = { 658 .name = KBUILD_MODNAME, 659 #ifdef CONFIG_PM 660 .pm = &adp5588_dev_pm_ops, 661 #endif 662 }, 663 .probe = adp5588_probe, 664 .remove = adp5588_remove, 665 .id_table = adp5588_id, 666 }; 667 668 module_i2c_driver(adp5588_driver); 669 670 MODULE_LICENSE("GPL"); 671 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>"); 672 MODULE_DESCRIPTION("ADP5588/87 Keypad driver"); 673