drivers/input/keyboard/adp5588-keys.c

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