linux/drivers/input/keyboard/adp5588-keys.c
<<
>>
Prefs
   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
  40struct 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
  58static 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
  68static 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
  74static int adp5588_gpio_get_value(struct gpio_chip *chip, unsigned off)
  75{
  76        struct adp5588_kpad *kpad = gpiochip_get_data(chip);
  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
  93static void adp5588_gpio_set_value(struct gpio_chip *chip,
  94                                   unsigned off, int val)
  95{
  96        struct adp5588_kpad *kpad = gpiochip_get_data(chip);
  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
 113static int adp5588_gpio_direction_input(struct gpio_chip *chip, unsigned off)
 114{
 115        struct adp5588_kpad *kpad = gpiochip_get_data(chip);
 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
 130static int adp5588_gpio_direction_output(struct gpio_chip *chip,
 131                                         unsigned off, int val)
 132{
 133        struct adp5588_kpad *kpad = gpiochip_get_data(chip);
 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
 157static 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
 182static 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_data(&kpad->gc, kpad);
 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
 236static 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
 257static inline int adp5588_gpio_add(struct adp5588_kpad *kpad)
 258{
 259        return 0;
 260}
 261
 262static inline void adp5588_gpio_remove(struct adp5588_kpad *kpad)
 263{
 264}
 265#endif
 266
 267static 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
 292static 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
 314static 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
 329static 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
 393static 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
 431static 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
 601static 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
 616static 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
 630static 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
 643static const struct dev_pm_ops adp5588_dev_pm_ops = {
 644        .suspend = adp5588_suspend,
 645        .resume  = adp5588_resume,
 646};
 647#endif
 648
 649static const struct i2c_device_id adp5588_id[] = {
 650        { "adp5588-keys", 0 },
 651        { "adp5587-keys", 0 },
 652        { }
 653};
 654MODULE_DEVICE_TABLE(i2c, adp5588_id);
 655
 656static 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
 668module_i2c_driver(adp5588_driver);
 669
 670MODULE_LICENSE("GPL");
 671MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 672MODULE_DESCRIPTION("ADP5588/87 Keypad driver");
 673