linux/drivers/input/keyboard/adp5589-keys.c
<<
>>
Prefs
   1/*
   2 * Description:  keypad driver for ADP5589, ADP5585
   3 *               I2C QWERTY Keypad and IO Expander
   4 * Bugs: Enter bugs at http://blackfin.uclinux.org/
   5 *
   6 * Copyright (C) 2010-2011 Analog Devices Inc.
   7 * Licensed under the GPL-2.
   8 */
   9
  10#include <linux/module.h>
  11#include <linux/interrupt.h>
  12#include <linux/irq.h>
  13#include <linux/workqueue.h>
  14#include <linux/errno.h>
  15#include <linux/pm.h>
  16#include <linux/platform_device.h>
  17#include <linux/input.h>
  18#include <linux/i2c.h>
  19#include <linux/gpio.h>
  20#include <linux/slab.h>
  21
  22#include <linux/input/adp5589.h>
  23
  24/* ADP5589/ADP5585 Common Registers */
  25#define ADP5589_5_ID                    0x00
  26#define ADP5589_5_INT_STATUS            0x01
  27#define ADP5589_5_STATUS                0x02
  28#define ADP5589_5_FIFO_1                0x03
  29#define ADP5589_5_FIFO_2                0x04
  30#define ADP5589_5_FIFO_3                0x05
  31#define ADP5589_5_FIFO_4                0x06
  32#define ADP5589_5_FIFO_5                0x07
  33#define ADP5589_5_FIFO_6                0x08
  34#define ADP5589_5_FIFO_7                0x09
  35#define ADP5589_5_FIFO_8                0x0A
  36#define ADP5589_5_FIFO_9                0x0B
  37#define ADP5589_5_FIFO_10               0x0C
  38#define ADP5589_5_FIFO_11               0x0D
  39#define ADP5589_5_FIFO_12               0x0E
  40#define ADP5589_5_FIFO_13               0x0F
  41#define ADP5589_5_FIFO_14               0x10
  42#define ADP5589_5_FIFO_15               0x11
  43#define ADP5589_5_FIFO_16               0x12
  44#define ADP5589_5_GPI_INT_STAT_A        0x13
  45#define ADP5589_5_GPI_INT_STAT_B        0x14
  46
  47/* ADP5589 Registers */
  48#define ADP5589_GPI_INT_STAT_C          0x15
  49#define ADP5589_GPI_STATUS_A            0x16
  50#define ADP5589_GPI_STATUS_B            0x17
  51#define ADP5589_GPI_STATUS_C            0x18
  52#define ADP5589_RPULL_CONFIG_A          0x19
  53#define ADP5589_RPULL_CONFIG_B          0x1A
  54#define ADP5589_RPULL_CONFIG_C          0x1B
  55#define ADP5589_RPULL_CONFIG_D          0x1C
  56#define ADP5589_RPULL_CONFIG_E          0x1D
  57#define ADP5589_GPI_INT_LEVEL_A         0x1E
  58#define ADP5589_GPI_INT_LEVEL_B         0x1F
  59#define ADP5589_GPI_INT_LEVEL_C         0x20
  60#define ADP5589_GPI_EVENT_EN_A          0x21
  61#define ADP5589_GPI_EVENT_EN_B          0x22
  62#define ADP5589_GPI_EVENT_EN_C          0x23
  63#define ADP5589_GPI_INTERRUPT_EN_A      0x24
  64#define ADP5589_GPI_INTERRUPT_EN_B      0x25
  65#define ADP5589_GPI_INTERRUPT_EN_C      0x26
  66#define ADP5589_DEBOUNCE_DIS_A          0x27
  67#define ADP5589_DEBOUNCE_DIS_B          0x28
  68#define ADP5589_DEBOUNCE_DIS_C          0x29
  69#define ADP5589_GPO_DATA_OUT_A          0x2A
  70#define ADP5589_GPO_DATA_OUT_B          0x2B
  71#define ADP5589_GPO_DATA_OUT_C          0x2C
  72#define ADP5589_GPO_OUT_MODE_A          0x2D
  73#define ADP5589_GPO_OUT_MODE_B          0x2E
  74#define ADP5589_GPO_OUT_MODE_C          0x2F
  75#define ADP5589_GPIO_DIRECTION_A        0x30
  76#define ADP5589_GPIO_DIRECTION_B        0x31
  77#define ADP5589_GPIO_DIRECTION_C        0x32
  78#define ADP5589_UNLOCK1                 0x33
  79#define ADP5589_UNLOCK2                 0x34
  80#define ADP5589_EXT_LOCK_EVENT          0x35
  81#define ADP5589_UNLOCK_TIMERS           0x36
  82#define ADP5589_LOCK_CFG                0x37
  83#define ADP5589_RESET1_EVENT_A          0x38
  84#define ADP5589_RESET1_EVENT_B          0x39
  85#define ADP5589_RESET1_EVENT_C          0x3A
  86#define ADP5589_RESET2_EVENT_A          0x3B
  87#define ADP5589_RESET2_EVENT_B          0x3C
  88#define ADP5589_RESET_CFG               0x3D
  89#define ADP5589_PWM_OFFT_LOW            0x3E
  90#define ADP5589_PWM_OFFT_HIGH           0x3F
  91#define ADP5589_PWM_ONT_LOW             0x40
  92#define ADP5589_PWM_ONT_HIGH            0x41
  93#define ADP5589_PWM_CFG                 0x42
  94#define ADP5589_CLOCK_DIV_CFG           0x43
  95#define ADP5589_LOGIC_1_CFG             0x44
  96#define ADP5589_LOGIC_2_CFG             0x45
  97#define ADP5589_LOGIC_FF_CFG            0x46
  98#define ADP5589_LOGIC_INT_EVENT_EN      0x47
  99#define ADP5589_POLL_PTIME_CFG          0x48
 100#define ADP5589_PIN_CONFIG_A            0x49
 101#define ADP5589_PIN_CONFIG_B            0x4A
 102#define ADP5589_PIN_CONFIG_C            0x4B
 103#define ADP5589_PIN_CONFIG_D            0x4C
 104#define ADP5589_GENERAL_CFG             0x4D
 105#define ADP5589_INT_EN                  0x4E
 106
 107/* ADP5585 Registers */
 108#define ADP5585_GPI_STATUS_A            0x15
 109#define ADP5585_GPI_STATUS_B            0x16
 110#define ADP5585_RPULL_CONFIG_A          0x17
 111#define ADP5585_RPULL_CONFIG_B          0x18
 112#define ADP5585_RPULL_CONFIG_C          0x19
 113#define ADP5585_RPULL_CONFIG_D          0x1A
 114#define ADP5585_GPI_INT_LEVEL_A         0x1B
 115#define ADP5585_GPI_INT_LEVEL_B         0x1C
 116#define ADP5585_GPI_EVENT_EN_A          0x1D
 117#define ADP5585_GPI_EVENT_EN_B          0x1E
 118#define ADP5585_GPI_INTERRUPT_EN_A      0x1F
 119#define ADP5585_GPI_INTERRUPT_EN_B      0x20
 120#define ADP5585_DEBOUNCE_DIS_A          0x21
 121#define ADP5585_DEBOUNCE_DIS_B          0x22
 122#define ADP5585_GPO_DATA_OUT_A          0x23
 123#define ADP5585_GPO_DATA_OUT_B          0x24
 124#define ADP5585_GPO_OUT_MODE_A          0x25
 125#define ADP5585_GPO_OUT_MODE_B          0x26
 126#define ADP5585_GPIO_DIRECTION_A        0x27
 127#define ADP5585_GPIO_DIRECTION_B        0x28
 128#define ADP5585_RESET1_EVENT_A          0x29
 129#define ADP5585_RESET1_EVENT_B          0x2A
 130#define ADP5585_RESET1_EVENT_C          0x2B
 131#define ADP5585_RESET2_EVENT_A          0x2C
 132#define ADP5585_RESET2_EVENT_B          0x2D
 133#define ADP5585_RESET_CFG               0x2E
 134#define ADP5585_PWM_OFFT_LOW            0x2F
 135#define ADP5585_PWM_OFFT_HIGH           0x30
 136#define ADP5585_PWM_ONT_LOW             0x31
 137#define ADP5585_PWM_ONT_HIGH            0x32
 138#define ADP5585_PWM_CFG                 0x33
 139#define ADP5585_LOGIC_CFG               0x34
 140#define ADP5585_LOGIC_FF_CFG            0x35
 141#define ADP5585_LOGIC_INT_EVENT_EN      0x36
 142#define ADP5585_POLL_PTIME_CFG          0x37
 143#define ADP5585_PIN_CONFIG_A            0x38
 144#define ADP5585_PIN_CONFIG_B            0x39
 145#define ADP5585_PIN_CONFIG_D            0x3A
 146#define ADP5585_GENERAL_CFG             0x3B
 147#define ADP5585_INT_EN                  0x3C
 148
 149/* ID Register */
 150#define ADP5589_5_DEVICE_ID_MASK        0xF
 151#define ADP5589_5_MAN_ID_MASK           0xF
 152#define ADP5589_5_MAN_ID_SHIFT          4
 153#define ADP5589_5_MAN_ID                0x02
 154
 155/* GENERAL_CFG Register */
 156#define OSC_EN          (1 << 7)
 157#define CORE_CLK(x)     (((x) & 0x3) << 5)
 158#define LCK_TRK_LOGIC   (1 << 4)        /* ADP5589 only */
 159#define LCK_TRK_GPI     (1 << 3)        /* ADP5589 only */
 160#define INT_CFG         (1 << 1)
 161#define RST_CFG         (1 << 0)
 162
 163/* INT_EN Register */
 164#define LOGIC2_IEN      (1 << 5)        /* ADP5589 only */
 165#define LOGIC1_IEN      (1 << 4)
 166#define LOCK_IEN        (1 << 3)        /* ADP5589 only */
 167#define OVRFLOW_IEN     (1 << 2)
 168#define GPI_IEN         (1 << 1)
 169#define EVENT_IEN       (1 << 0)
 170
 171/* Interrupt Status Register */
 172#define LOGIC2_INT      (1 << 5)        /* ADP5589 only */
 173#define LOGIC1_INT      (1 << 4)
 174#define LOCK_INT        (1 << 3)        /* ADP5589 only */
 175#define OVRFLOW_INT     (1 << 2)
 176#define GPI_INT         (1 << 1)
 177#define EVENT_INT       (1 << 0)
 178
 179/* STATUS Register */
 180#define LOGIC2_STAT     (1 << 7)        /* ADP5589 only */
 181#define LOGIC1_STAT     (1 << 6)
 182#define LOCK_STAT       (1 << 5)        /* ADP5589 only */
 183#define KEC             0x1F
 184
 185/* PIN_CONFIG_D Register */
 186#define C4_EXTEND_CFG   (1 << 6)        /* RESET2 */
 187#define R4_EXTEND_CFG   (1 << 5)        /* RESET1 */
 188
 189/* LOCK_CFG */
 190#define LOCK_EN         (1 << 0)
 191
 192#define PTIME_MASK      0x3
 193#define LTIME_MASK      0x3             /* ADP5589 only */
 194
 195/* Key Event Register xy */
 196#define KEY_EV_PRESSED          (1 << 7)
 197#define KEY_EV_MASK             (0x7F)
 198
 199#define KEYP_MAX_EVENT          16
 200#define ADP5589_MAXGPIO         19
 201#define ADP5585_MAXGPIO         11 /* 10 on the ADP5585-01, 11 on ADP5585-02 */
 202
 203enum {
 204        ADP5589,
 205        ADP5585_01,
 206        ADP5585_02
 207};
 208
 209struct adp_constants {
 210        u8 maxgpio;
 211        u8 keymapsize;
 212        u8 gpi_pin_row_base;
 213        u8 gpi_pin_row_end;
 214        u8 gpi_pin_col_base;
 215        u8 gpi_pin_base;
 216        u8 gpi_pin_end;
 217        u8 gpimapsize_max;
 218        u8 max_row_num;
 219        u8 max_col_num;
 220        u8 row_mask;
 221        u8 col_mask;
 222        u8 col_shift;
 223        u8 c4_extend_cfg;
 224        u8 (*bank) (u8 offset);
 225        u8 (*bit) (u8 offset);
 226        u8 (*reg) (u8 reg);
 227};
 228
 229struct adp5589_kpad {
 230        struct i2c_client *client;
 231        struct input_dev *input;
 232        const struct adp_constants *var;
 233        unsigned short keycode[ADP5589_KEYMAPSIZE];
 234        const struct adp5589_gpi_map *gpimap;
 235        unsigned short gpimapsize;
 236        unsigned extend_cfg;
 237        bool is_adp5585;
 238        bool support_row5;
 239#ifdef CONFIG_GPIOLIB
 240        unsigned char gpiomap[ADP5589_MAXGPIO];
 241        bool export_gpio;
 242        struct gpio_chip gc;
 243        struct mutex gpio_lock; /* Protect cached dir, dat_out */
 244        u8 dat_out[3];
 245        u8 dir[3];
 246#endif
 247};
 248
 249/*
 250 *  ADP5589 / ADP5585 derivative / variant handling
 251 */
 252
 253
 254/* ADP5589 */
 255
 256static unsigned char adp5589_bank(unsigned char offset)
 257{
 258        return offset >> 3;
 259}
 260
 261static unsigned char adp5589_bit(unsigned char offset)
 262{
 263        return 1u << (offset & 0x7);
 264}
 265
 266static unsigned char adp5589_reg(unsigned char reg)
 267{
 268        return reg;
 269}
 270
 271static const struct adp_constants const_adp5589 = {
 272        .maxgpio                = ADP5589_MAXGPIO,
 273        .keymapsize             = ADP5589_KEYMAPSIZE,
 274        .gpi_pin_row_base       = ADP5589_GPI_PIN_ROW_BASE,
 275        .gpi_pin_row_end        = ADP5589_GPI_PIN_ROW_END,
 276        .gpi_pin_col_base       = ADP5589_GPI_PIN_COL_BASE,
 277        .gpi_pin_base           = ADP5589_GPI_PIN_BASE,
 278        .gpi_pin_end            = ADP5589_GPI_PIN_END,
 279        .gpimapsize_max         = ADP5589_GPIMAPSIZE_MAX,
 280        .c4_extend_cfg          = 12,
 281        .max_row_num            = ADP5589_MAX_ROW_NUM,
 282        .max_col_num            = ADP5589_MAX_COL_NUM,
 283        .row_mask               = ADP5589_ROW_MASK,
 284        .col_mask               = ADP5589_COL_MASK,
 285        .col_shift              = ADP5589_COL_SHIFT,
 286        .bank                   = adp5589_bank,
 287        .bit                    = adp5589_bit,
 288        .reg                    = adp5589_reg,
 289};
 290
 291/* ADP5585 */
 292
 293static unsigned char adp5585_bank(unsigned char offset)
 294{
 295        return offset > ADP5585_MAX_ROW_NUM;
 296}
 297
 298static unsigned char adp5585_bit(unsigned char offset)
 299{
 300        return (offset > ADP5585_MAX_ROW_NUM) ?
 301                1u << (offset - ADP5585_COL_SHIFT) : 1u << offset;
 302}
 303
 304static const unsigned char adp5585_reg_lut[] = {
 305        [ADP5589_GPI_STATUS_A]          = ADP5585_GPI_STATUS_A,
 306        [ADP5589_GPI_STATUS_B]          = ADP5585_GPI_STATUS_B,
 307        [ADP5589_RPULL_CONFIG_A]        = ADP5585_RPULL_CONFIG_A,
 308        [ADP5589_RPULL_CONFIG_B]        = ADP5585_RPULL_CONFIG_B,
 309        [ADP5589_RPULL_CONFIG_C]        = ADP5585_RPULL_CONFIG_C,
 310        [ADP5589_RPULL_CONFIG_D]        = ADP5585_RPULL_CONFIG_D,
 311        [ADP5589_GPI_INT_LEVEL_A]       = ADP5585_GPI_INT_LEVEL_A,
 312        [ADP5589_GPI_INT_LEVEL_B]       = ADP5585_GPI_INT_LEVEL_B,
 313        [ADP5589_GPI_EVENT_EN_A]        = ADP5585_GPI_EVENT_EN_A,
 314        [ADP5589_GPI_EVENT_EN_B]        = ADP5585_GPI_EVENT_EN_B,
 315        [ADP5589_GPI_INTERRUPT_EN_A]    = ADP5585_GPI_INTERRUPT_EN_A,
 316        [ADP5589_GPI_INTERRUPT_EN_B]    = ADP5585_GPI_INTERRUPT_EN_B,
 317        [ADP5589_DEBOUNCE_DIS_A]        = ADP5585_DEBOUNCE_DIS_A,
 318        [ADP5589_DEBOUNCE_DIS_B]        = ADP5585_DEBOUNCE_DIS_B,
 319        [ADP5589_GPO_DATA_OUT_A]        = ADP5585_GPO_DATA_OUT_A,
 320        [ADP5589_GPO_DATA_OUT_B]        = ADP5585_GPO_DATA_OUT_B,
 321        [ADP5589_GPO_OUT_MODE_A]        = ADP5585_GPO_OUT_MODE_A,
 322        [ADP5589_GPO_OUT_MODE_B]        = ADP5585_GPO_OUT_MODE_B,
 323        [ADP5589_GPIO_DIRECTION_A]      = ADP5585_GPIO_DIRECTION_A,
 324        [ADP5589_GPIO_DIRECTION_B]      = ADP5585_GPIO_DIRECTION_B,
 325        [ADP5589_RESET1_EVENT_A]        = ADP5585_RESET1_EVENT_A,
 326        [ADP5589_RESET1_EVENT_B]        = ADP5585_RESET1_EVENT_B,
 327        [ADP5589_RESET1_EVENT_C]        = ADP5585_RESET1_EVENT_C,
 328        [ADP5589_RESET2_EVENT_A]        = ADP5585_RESET2_EVENT_A,
 329        [ADP5589_RESET2_EVENT_B]        = ADP5585_RESET2_EVENT_B,
 330        [ADP5589_RESET_CFG]             = ADP5585_RESET_CFG,
 331        [ADP5589_PWM_OFFT_LOW]          = ADP5585_PWM_OFFT_LOW,
 332        [ADP5589_PWM_OFFT_HIGH]         = ADP5585_PWM_OFFT_HIGH,
 333        [ADP5589_PWM_ONT_LOW]           = ADP5585_PWM_ONT_LOW,
 334        [ADP5589_PWM_ONT_HIGH]          = ADP5585_PWM_ONT_HIGH,
 335        [ADP5589_PWM_CFG]               = ADP5585_PWM_CFG,
 336        [ADP5589_LOGIC_1_CFG]           = ADP5585_LOGIC_CFG,
 337        [ADP5589_LOGIC_FF_CFG]          = ADP5585_LOGIC_FF_CFG,
 338        [ADP5589_LOGIC_INT_EVENT_EN]    = ADP5585_LOGIC_INT_EVENT_EN,
 339        [ADP5589_POLL_PTIME_CFG]        = ADP5585_POLL_PTIME_CFG,
 340        [ADP5589_PIN_CONFIG_A]          = ADP5585_PIN_CONFIG_A,
 341        [ADP5589_PIN_CONFIG_B]          = ADP5585_PIN_CONFIG_B,
 342        [ADP5589_PIN_CONFIG_D]          = ADP5585_PIN_CONFIG_D,
 343        [ADP5589_GENERAL_CFG]           = ADP5585_GENERAL_CFG,
 344        [ADP5589_INT_EN]                = ADP5585_INT_EN,
 345};
 346
 347static unsigned char adp5585_reg(unsigned char reg)
 348{
 349        return adp5585_reg_lut[reg];
 350}
 351
 352static const struct adp_constants const_adp5585 = {
 353        .maxgpio                = ADP5585_MAXGPIO,
 354        .keymapsize             = ADP5585_KEYMAPSIZE,
 355        .gpi_pin_row_base       = ADP5585_GPI_PIN_ROW_BASE,
 356        .gpi_pin_row_end        = ADP5585_GPI_PIN_ROW_END,
 357        .gpi_pin_col_base       = ADP5585_GPI_PIN_COL_BASE,
 358        .gpi_pin_base           = ADP5585_GPI_PIN_BASE,
 359        .gpi_pin_end            = ADP5585_GPI_PIN_END,
 360        .gpimapsize_max         = ADP5585_GPIMAPSIZE_MAX,
 361        .c4_extend_cfg          = 10,
 362        .max_row_num            = ADP5585_MAX_ROW_NUM,
 363        .max_col_num            = ADP5585_MAX_COL_NUM,
 364        .row_mask               = ADP5585_ROW_MASK,
 365        .col_mask               = ADP5585_COL_MASK,
 366        .col_shift              = ADP5585_COL_SHIFT,
 367        .bank                   = adp5585_bank,
 368        .bit                    = adp5585_bit,
 369        .reg                    = adp5585_reg,
 370};
 371
 372static int adp5589_read(struct i2c_client *client, u8 reg)
 373{
 374        int ret = i2c_smbus_read_byte_data(client, reg);
 375
 376        if (ret < 0)
 377                dev_err(&client->dev, "Read Error\n");
 378
 379        return ret;
 380}
 381
 382static int adp5589_write(struct i2c_client *client, u8 reg, u8 val)
 383{
 384        return i2c_smbus_write_byte_data(client, reg, val);
 385}
 386
 387#ifdef CONFIG_GPIOLIB
 388static int adp5589_gpio_get_value(struct gpio_chip *chip, unsigned off)
 389{
 390        struct adp5589_kpad *kpad = gpiochip_get_data(chip);
 391        unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
 392        unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
 393
 394        return !!(adp5589_read(kpad->client,
 395                               kpad->var->reg(ADP5589_GPI_STATUS_A) + bank) &
 396                               bit);
 397}
 398
 399static void adp5589_gpio_set_value(struct gpio_chip *chip,
 400                                   unsigned off, int val)
 401{
 402        struct adp5589_kpad *kpad = gpiochip_get_data(chip);
 403        unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
 404        unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
 405
 406        mutex_lock(&kpad->gpio_lock);
 407
 408        if (val)
 409                kpad->dat_out[bank] |= bit;
 410        else
 411                kpad->dat_out[bank] &= ~bit;
 412
 413        adp5589_write(kpad->client, kpad->var->reg(ADP5589_GPO_DATA_OUT_A) +
 414                      bank, kpad->dat_out[bank]);
 415
 416        mutex_unlock(&kpad->gpio_lock);
 417}
 418
 419static int adp5589_gpio_direction_input(struct gpio_chip *chip, unsigned off)
 420{
 421        struct adp5589_kpad *kpad = gpiochip_get_data(chip);
 422        unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
 423        unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
 424        int ret;
 425
 426        mutex_lock(&kpad->gpio_lock);
 427
 428        kpad->dir[bank] &= ~bit;
 429        ret = adp5589_write(kpad->client,
 430                            kpad->var->reg(ADP5589_GPIO_DIRECTION_A) + bank,
 431                            kpad->dir[bank]);
 432
 433        mutex_unlock(&kpad->gpio_lock);
 434
 435        return ret;
 436}
 437
 438static int adp5589_gpio_direction_output(struct gpio_chip *chip,
 439                                         unsigned off, int val)
 440{
 441        struct adp5589_kpad *kpad = gpiochip_get_data(chip);
 442        unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
 443        unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
 444        int ret;
 445
 446        mutex_lock(&kpad->gpio_lock);
 447
 448        kpad->dir[bank] |= bit;
 449
 450        if (val)
 451                kpad->dat_out[bank] |= bit;
 452        else
 453                kpad->dat_out[bank] &= ~bit;
 454
 455        ret = adp5589_write(kpad->client, kpad->var->reg(ADP5589_GPO_DATA_OUT_A)
 456                            + bank, kpad->dat_out[bank]);
 457        ret |= adp5589_write(kpad->client,
 458                             kpad->var->reg(ADP5589_GPIO_DIRECTION_A) + bank,
 459                             kpad->dir[bank]);
 460
 461        mutex_unlock(&kpad->gpio_lock);
 462
 463        return ret;
 464}
 465
 466static int adp5589_build_gpiomap(struct adp5589_kpad *kpad,
 467                                const struct adp5589_kpad_platform_data *pdata)
 468{
 469        bool pin_used[ADP5589_MAXGPIO];
 470        int n_unused = 0;
 471        int i;
 472
 473        memset(pin_used, false, sizeof(pin_used));
 474
 475        for (i = 0; i < kpad->var->maxgpio; i++)
 476                if (pdata->keypad_en_mask & (1 << i))
 477                        pin_used[i] = true;
 478
 479        for (i = 0; i < kpad->gpimapsize; i++)
 480                pin_used[kpad->gpimap[i].pin - kpad->var->gpi_pin_base] = true;
 481
 482        if (kpad->extend_cfg & R4_EXTEND_CFG)
 483                pin_used[4] = true;
 484
 485        if (kpad->extend_cfg & C4_EXTEND_CFG)
 486                pin_used[kpad->var->c4_extend_cfg] = true;
 487
 488        if (!kpad->support_row5)
 489                pin_used[5] = true;
 490
 491        for (i = 0; i < kpad->var->maxgpio; i++)
 492                if (!pin_used[i])
 493                        kpad->gpiomap[n_unused++] = i;
 494
 495        return n_unused;
 496}
 497
 498static int adp5589_gpio_add(struct adp5589_kpad *kpad)
 499{
 500        struct device *dev = &kpad->client->dev;
 501        const struct adp5589_kpad_platform_data *pdata = dev_get_platdata(dev);
 502        const struct adp5589_gpio_platform_data *gpio_data = pdata->gpio_data;
 503        int i, error;
 504
 505        if (!gpio_data)
 506                return 0;
 507
 508        kpad->gc.ngpio = adp5589_build_gpiomap(kpad, pdata);
 509        if (kpad->gc.ngpio == 0) {
 510                dev_info(dev, "No unused gpios left to export\n");
 511                return 0;
 512        }
 513
 514        kpad->export_gpio = true;
 515
 516        kpad->gc.direction_input = adp5589_gpio_direction_input;
 517        kpad->gc.direction_output = adp5589_gpio_direction_output;
 518        kpad->gc.get = adp5589_gpio_get_value;
 519        kpad->gc.set = adp5589_gpio_set_value;
 520        kpad->gc.can_sleep = 1;
 521
 522        kpad->gc.base = gpio_data->gpio_start;
 523        kpad->gc.label = kpad->client->name;
 524        kpad->gc.owner = THIS_MODULE;
 525
 526        mutex_init(&kpad->gpio_lock);
 527
 528        error = gpiochip_add_data(&kpad->gc, kpad);
 529        if (error) {
 530                dev_err(dev, "gpiochip_add_data() failed, err: %d\n", error);
 531                return error;
 532        }
 533
 534        for (i = 0; i <= kpad->var->bank(kpad->var->maxgpio); i++) {
 535                kpad->dat_out[i] = adp5589_read(kpad->client, kpad->var->reg(
 536                                                ADP5589_GPO_DATA_OUT_A) + i);
 537                kpad->dir[i] = adp5589_read(kpad->client, kpad->var->reg(
 538                                            ADP5589_GPIO_DIRECTION_A) + i);
 539        }
 540
 541        if (gpio_data->setup) {
 542                error = gpio_data->setup(kpad->client,
 543                                         kpad->gc.base, kpad->gc.ngpio,
 544                                         gpio_data->context);
 545                if (error)
 546                        dev_warn(dev, "setup failed, %d\n", error);
 547        }
 548
 549        return 0;
 550}
 551
 552static void adp5589_gpio_remove(struct adp5589_kpad *kpad)
 553{
 554        struct device *dev = &kpad->client->dev;
 555        const struct adp5589_kpad_platform_data *pdata = dev_get_platdata(dev);
 556        const struct adp5589_gpio_platform_data *gpio_data = pdata->gpio_data;
 557        int error;
 558
 559        if (!kpad->export_gpio)
 560                return;
 561
 562        if (gpio_data->teardown) {
 563                error = gpio_data->teardown(kpad->client,
 564                                            kpad->gc.base, kpad->gc.ngpio,
 565                                            gpio_data->context);
 566                if (error)
 567                        dev_warn(dev, "teardown failed %d\n", error);
 568        }
 569
 570        gpiochip_remove(&kpad->gc);
 571}
 572#else
 573static inline int adp5589_gpio_add(struct adp5589_kpad *kpad)
 574{
 575        return 0;
 576}
 577
 578static inline void adp5589_gpio_remove(struct adp5589_kpad *kpad)
 579{
 580}
 581#endif
 582
 583static void adp5589_report_switches(struct adp5589_kpad *kpad,
 584                                    int key, int key_val)
 585{
 586        int i;
 587
 588        for (i = 0; i < kpad->gpimapsize; i++) {
 589                if (key_val == kpad->gpimap[i].pin) {
 590                        input_report_switch(kpad->input,
 591                                            kpad->gpimap[i].sw_evt,
 592                                            key & KEY_EV_PRESSED);
 593                        break;
 594                }
 595        }
 596}
 597
 598static void adp5589_report_events(struct adp5589_kpad *kpad, int ev_cnt)
 599{
 600        int i;
 601
 602        for (i = 0; i < ev_cnt; i++) {
 603                int key = adp5589_read(kpad->client, ADP5589_5_FIFO_1 + i);
 604                int key_val = key & KEY_EV_MASK;
 605
 606                if (key_val >= kpad->var->gpi_pin_base &&
 607                    key_val <= kpad->var->gpi_pin_end) {
 608                        adp5589_report_switches(kpad, key, key_val);
 609                } else {
 610                        input_report_key(kpad->input,
 611                                         kpad->keycode[key_val - 1],
 612                                         key & KEY_EV_PRESSED);
 613                }
 614        }
 615}
 616
 617static irqreturn_t adp5589_irq(int irq, void *handle)
 618{
 619        struct adp5589_kpad *kpad = handle;
 620        struct i2c_client *client = kpad->client;
 621        int status, ev_cnt;
 622
 623        status = adp5589_read(client, ADP5589_5_INT_STATUS);
 624
 625        if (status & OVRFLOW_INT)       /* Unlikely and should never happen */
 626                dev_err(&client->dev, "Event Overflow Error\n");
 627
 628        if (status & EVENT_INT) {
 629                ev_cnt = adp5589_read(client, ADP5589_5_STATUS) & KEC;
 630                if (ev_cnt) {
 631                        adp5589_report_events(kpad, ev_cnt);
 632                        input_sync(kpad->input);
 633                }
 634        }
 635
 636        adp5589_write(client, ADP5589_5_INT_STATUS, status); /* Status is W1C */
 637
 638        return IRQ_HANDLED;
 639}
 640
 641static int adp5589_get_evcode(struct adp5589_kpad *kpad, unsigned short key)
 642{
 643        int i;
 644
 645        for (i = 0; i < kpad->var->keymapsize; i++)
 646                if (key == kpad->keycode[i])
 647                        return (i + 1) | KEY_EV_PRESSED;
 648
 649        dev_err(&kpad->client->dev, "RESET/UNLOCK key not in keycode map\n");
 650
 651        return -EINVAL;
 652}
 653
 654static int adp5589_setup(struct adp5589_kpad *kpad)
 655{
 656        struct i2c_client *client = kpad->client;
 657        const struct adp5589_kpad_platform_data *pdata =
 658                dev_get_platdata(&client->dev);
 659        u8 (*reg) (u8) = kpad->var->reg;
 660        unsigned char evt_mode1 = 0, evt_mode2 = 0, evt_mode3 = 0;
 661        unsigned char pull_mask = 0;
 662        int i, ret;
 663
 664        ret = adp5589_write(client, reg(ADP5589_PIN_CONFIG_A),
 665                            pdata->keypad_en_mask & kpad->var->row_mask);
 666        ret |= adp5589_write(client, reg(ADP5589_PIN_CONFIG_B),
 667                             (pdata->keypad_en_mask >> kpad->var->col_shift) &
 668                             kpad->var->col_mask);
 669
 670        if (!kpad->is_adp5585)
 671                ret |= adp5589_write(client, ADP5589_PIN_CONFIG_C,
 672                                     (pdata->keypad_en_mask >> 16) & 0xFF);
 673
 674        if (!kpad->is_adp5585 && pdata->en_keylock) {
 675                ret |= adp5589_write(client, ADP5589_UNLOCK1,
 676                                     pdata->unlock_key1);
 677                ret |= adp5589_write(client, ADP5589_UNLOCK2,
 678                                     pdata->unlock_key2);
 679                ret |= adp5589_write(client, ADP5589_UNLOCK_TIMERS,
 680                                     pdata->unlock_timer & LTIME_MASK);
 681                ret |= adp5589_write(client, ADP5589_LOCK_CFG, LOCK_EN);
 682        }
 683
 684        for (i = 0; i < KEYP_MAX_EVENT; i++)
 685                ret |= adp5589_read(client, ADP5589_5_FIFO_1 + i);
 686
 687        for (i = 0; i < pdata->gpimapsize; i++) {
 688                unsigned short pin = pdata->gpimap[i].pin;
 689
 690                if (pin <= kpad->var->gpi_pin_row_end) {
 691                        evt_mode1 |= (1 << (pin - kpad->var->gpi_pin_row_base));
 692                } else {
 693                        evt_mode2 |=
 694                            ((1 << (pin - kpad->var->gpi_pin_col_base)) & 0xFF);
 695                        if (!kpad->is_adp5585)
 696                                evt_mode3 |= ((1 << (pin -
 697                                        kpad->var->gpi_pin_col_base)) >> 8);
 698                }
 699        }
 700
 701        if (pdata->gpimapsize) {
 702                ret |= adp5589_write(client, reg(ADP5589_GPI_EVENT_EN_A),
 703                                     evt_mode1);
 704                ret |= adp5589_write(client, reg(ADP5589_GPI_EVENT_EN_B),
 705                                     evt_mode2);
 706                if (!kpad->is_adp5585)
 707                        ret |= adp5589_write(client,
 708                                             reg(ADP5589_GPI_EVENT_EN_C),
 709                                             evt_mode3);
 710        }
 711
 712        if (pdata->pull_dis_mask & pdata->pullup_en_100k &
 713                pdata->pullup_en_300k & pdata->pulldown_en_300k)
 714                dev_warn(&client->dev, "Conflicting pull resistor config\n");
 715
 716        for (i = 0; i <= kpad->var->max_row_num; i++) {
 717                unsigned val = 0, bit = (1 << i);
 718                if (pdata->pullup_en_300k & bit)
 719                        val = 0;
 720                else if (pdata->pulldown_en_300k & bit)
 721                        val = 1;
 722                else if (pdata->pullup_en_100k & bit)
 723                        val = 2;
 724                else if (pdata->pull_dis_mask & bit)
 725                        val = 3;
 726
 727                pull_mask |= val << (2 * (i & 0x3));
 728
 729                if (i % 4 == 3 || i == kpad->var->max_row_num) {
 730                        ret |= adp5589_write(client, reg(ADP5585_RPULL_CONFIG_A)
 731                                             + (i >> 2), pull_mask);
 732                        pull_mask = 0;
 733                }
 734        }
 735
 736        for (i = 0; i <= kpad->var->max_col_num; i++) {
 737                unsigned val = 0, bit = 1 << (i + kpad->var->col_shift);
 738                if (pdata->pullup_en_300k & bit)
 739                        val = 0;
 740                else if (pdata->pulldown_en_300k & bit)
 741                        val = 1;
 742                else if (pdata->pullup_en_100k & bit)
 743                        val = 2;
 744                else if (pdata->pull_dis_mask & bit)
 745                        val = 3;
 746
 747                pull_mask |= val << (2 * (i & 0x3));
 748
 749                if (i % 4 == 3 || i == kpad->var->max_col_num) {
 750                        ret |= adp5589_write(client,
 751                                             reg(ADP5585_RPULL_CONFIG_C) +
 752                                             (i >> 2), pull_mask);
 753                        pull_mask = 0;
 754                }
 755        }
 756
 757        if (pdata->reset1_key_1 && pdata->reset1_key_2 && pdata->reset1_key_3) {
 758                ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_A),
 759                                     adp5589_get_evcode(kpad,
 760                                                        pdata->reset1_key_1));
 761                ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_B),
 762                                     adp5589_get_evcode(kpad,
 763                                                        pdata->reset1_key_2));
 764                ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_C),
 765                                     adp5589_get_evcode(kpad,
 766                                                        pdata->reset1_key_3));
 767                kpad->extend_cfg |= R4_EXTEND_CFG;
 768        }
 769
 770        if (pdata->reset2_key_1 && pdata->reset2_key_2) {
 771                ret |= adp5589_write(client, reg(ADP5589_RESET2_EVENT_A),
 772                                     adp5589_get_evcode(kpad,
 773                                                        pdata->reset2_key_1));
 774                ret |= adp5589_write(client, reg(ADP5589_RESET2_EVENT_B),
 775                                     adp5589_get_evcode(kpad,
 776                                                        pdata->reset2_key_2));
 777                kpad->extend_cfg |= C4_EXTEND_CFG;
 778        }
 779
 780        if (kpad->extend_cfg) {
 781                ret |= adp5589_write(client, reg(ADP5589_RESET_CFG),
 782                                     pdata->reset_cfg);
 783                ret |= adp5589_write(client, reg(ADP5589_PIN_CONFIG_D),
 784                                     kpad->extend_cfg);
 785        }
 786
 787        ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_A),
 788                            pdata->debounce_dis_mask & kpad->var->row_mask);
 789
 790        ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_B),
 791                             (pdata->debounce_dis_mask >> kpad->var->col_shift)
 792                             & kpad->var->col_mask);
 793
 794        if (!kpad->is_adp5585)
 795                ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_C),
 796                                     (pdata->debounce_dis_mask >> 16) & 0xFF);
 797
 798        ret |= adp5589_write(client, reg(ADP5589_POLL_PTIME_CFG),
 799                             pdata->scan_cycle_time & PTIME_MASK);
 800        ret |= adp5589_write(client, ADP5589_5_INT_STATUS,
 801                             (kpad->is_adp5585 ? 0 : LOGIC2_INT) |
 802                             LOGIC1_INT | OVRFLOW_INT |
 803                             (kpad->is_adp5585 ? 0 : LOCK_INT) |
 804                             GPI_INT | EVENT_INT);      /* Status is W1C */
 805
 806        ret |= adp5589_write(client, reg(ADP5589_GENERAL_CFG),
 807                             INT_CFG | OSC_EN | CORE_CLK(3));
 808        ret |= adp5589_write(client, reg(ADP5589_INT_EN),
 809                             OVRFLOW_IEN | GPI_IEN | EVENT_IEN);
 810
 811        if (ret < 0) {
 812                dev_err(&client->dev, "Write Error\n");
 813                return ret;
 814        }
 815
 816        return 0;
 817}
 818
 819static void adp5589_report_switch_state(struct adp5589_kpad *kpad)
 820{
 821        int gpi_stat_tmp, pin_loc;
 822        int i;
 823        int gpi_stat1 = adp5589_read(kpad->client,
 824                                     kpad->var->reg(ADP5589_GPI_STATUS_A));
 825        int gpi_stat2 = adp5589_read(kpad->client,
 826                                     kpad->var->reg(ADP5589_GPI_STATUS_B));
 827        int gpi_stat3 = !kpad->is_adp5585 ?
 828                        adp5589_read(kpad->client, ADP5589_GPI_STATUS_C) : 0;
 829
 830        for (i = 0; i < kpad->gpimapsize; i++) {
 831                unsigned short pin = kpad->gpimap[i].pin;
 832
 833                if (pin <= kpad->var->gpi_pin_row_end) {
 834                        gpi_stat_tmp = gpi_stat1;
 835                        pin_loc = pin - kpad->var->gpi_pin_row_base;
 836                } else if ((pin - kpad->var->gpi_pin_col_base) < 8) {
 837                        gpi_stat_tmp = gpi_stat2;
 838                        pin_loc = pin - kpad->var->gpi_pin_col_base;
 839                } else {
 840                        gpi_stat_tmp = gpi_stat3;
 841                        pin_loc = pin - kpad->var->gpi_pin_col_base - 8;
 842                }
 843
 844                if (gpi_stat_tmp < 0) {
 845                        dev_err(&kpad->client->dev,
 846                                "Can't read GPIO_DAT_STAT switch %d, default to OFF\n",
 847                                pin);
 848                        gpi_stat_tmp = 0;
 849                }
 850
 851                input_report_switch(kpad->input,
 852                                    kpad->gpimap[i].sw_evt,
 853                                    !(gpi_stat_tmp & (1 << pin_loc)));
 854        }
 855
 856        input_sync(kpad->input);
 857}
 858
 859static int adp5589_probe(struct i2c_client *client,
 860                         const struct i2c_device_id *id)
 861{
 862        struct adp5589_kpad *kpad;
 863        const struct adp5589_kpad_platform_data *pdata =
 864                dev_get_platdata(&client->dev);
 865        struct input_dev *input;
 866        unsigned int revid;
 867        int ret, i;
 868        int error;
 869
 870        if (!i2c_check_functionality(client->adapter,
 871                                     I2C_FUNC_SMBUS_BYTE_DATA)) {
 872                dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
 873                return -EIO;
 874        }
 875
 876        if (!pdata) {
 877                dev_err(&client->dev, "no platform data?\n");
 878                return -EINVAL;
 879        }
 880
 881        kpad = kzalloc(sizeof(*kpad), GFP_KERNEL);
 882        if (!kpad)
 883                return -ENOMEM;
 884
 885        switch (id->driver_data) {
 886        case ADP5585_02:
 887                kpad->support_row5 = true;
 888        case ADP5585_01:
 889                kpad->is_adp5585 = true;
 890                kpad->var = &const_adp5585;
 891                break;
 892        case ADP5589:
 893                kpad->support_row5 = true;
 894                kpad->var = &const_adp5589;
 895                break;
 896        }
 897
 898        if (!((pdata->keypad_en_mask & kpad->var->row_mask) &&
 899                        (pdata->keypad_en_mask >> kpad->var->col_shift)) ||
 900                        !pdata->keymap) {
 901                dev_err(&client->dev, "no rows, cols or keymap from pdata\n");
 902                error = -EINVAL;
 903                goto err_free_mem;
 904        }
 905
 906        if (pdata->keymapsize != kpad->var->keymapsize) {
 907                dev_err(&client->dev, "invalid keymapsize\n");
 908                error = -EINVAL;
 909                goto err_free_mem;
 910        }
 911
 912        if (!pdata->gpimap && pdata->gpimapsize) {
 913                dev_err(&client->dev, "invalid gpimap from pdata\n");
 914                error = -EINVAL;
 915                goto err_free_mem;
 916        }
 917
 918        if (pdata->gpimapsize > kpad->var->gpimapsize_max) {
 919                dev_err(&client->dev, "invalid gpimapsize\n");
 920                error = -EINVAL;
 921                goto err_free_mem;
 922        }
 923
 924        for (i = 0; i < pdata->gpimapsize; i++) {
 925                unsigned short pin = pdata->gpimap[i].pin;
 926
 927                if (pin < kpad->var->gpi_pin_base ||
 928                                pin > kpad->var->gpi_pin_end) {
 929                        dev_err(&client->dev, "invalid gpi pin data\n");
 930                        error = -EINVAL;
 931                        goto err_free_mem;
 932                }
 933
 934                if ((1 << (pin - kpad->var->gpi_pin_row_base)) &
 935                                pdata->keypad_en_mask) {
 936                        dev_err(&client->dev, "invalid gpi row/col data\n");
 937                        error = -EINVAL;
 938                        goto err_free_mem;
 939                }
 940        }
 941
 942        if (!client->irq) {
 943                dev_err(&client->dev, "no IRQ?\n");
 944                error = -EINVAL;
 945                goto err_free_mem;
 946        }
 947
 948        input = input_allocate_device();
 949        if (!input) {
 950                error = -ENOMEM;
 951                goto err_free_mem;
 952        }
 953
 954        kpad->client = client;
 955        kpad->input = input;
 956
 957        ret = adp5589_read(client, ADP5589_5_ID);
 958        if (ret < 0) {
 959                error = ret;
 960                goto err_free_input;
 961        }
 962
 963        revid = (u8) ret & ADP5589_5_DEVICE_ID_MASK;
 964
 965        input->name = client->name;
 966        input->phys = "adp5589-keys/input0";
 967        input->dev.parent = &client->dev;
 968
 969        input_set_drvdata(input, kpad);
 970
 971        input->id.bustype = BUS_I2C;
 972        input->id.vendor = 0x0001;
 973        input->id.product = 0x0001;
 974        input->id.version = revid;
 975
 976        input->keycodesize = sizeof(kpad->keycode[0]);
 977        input->keycodemax = pdata->keymapsize;
 978        input->keycode = kpad->keycode;
 979
 980        memcpy(kpad->keycode, pdata->keymap,
 981               pdata->keymapsize * input->keycodesize);
 982
 983        kpad->gpimap = pdata->gpimap;
 984        kpad->gpimapsize = pdata->gpimapsize;
 985
 986        /* setup input device */
 987        __set_bit(EV_KEY, input->evbit);
 988
 989        if (pdata->repeat)
 990                __set_bit(EV_REP, input->evbit);
 991
 992        for (i = 0; i < input->keycodemax; i++)
 993                if (kpad->keycode[i] <= KEY_MAX)
 994                        __set_bit(kpad->keycode[i], input->keybit);
 995        __clear_bit(KEY_RESERVED, input->keybit);
 996
 997        if (kpad->gpimapsize)
 998                __set_bit(EV_SW, input->evbit);
 999        for (i = 0; i < kpad->gpimapsize; i++)
1000                __set_bit(kpad->gpimap[i].sw_evt, input->swbit);
1001
1002        error = input_register_device(input);
1003        if (error) {
1004                dev_err(&client->dev, "unable to register input device\n");
1005                goto err_free_input;
1006        }
1007
1008        error = request_threaded_irq(client->irq, NULL, adp5589_irq,
1009                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1010                                     client->dev.driver->name, kpad);
1011        if (error) {
1012                dev_err(&client->dev, "irq %d busy?\n", client->irq);
1013                goto err_unreg_dev;
1014        }
1015
1016        error = adp5589_setup(kpad);
1017        if (error)
1018                goto err_free_irq;
1019
1020        if (kpad->gpimapsize)
1021                adp5589_report_switch_state(kpad);
1022
1023        error = adp5589_gpio_add(kpad);
1024        if (error)
1025                goto err_free_irq;
1026
1027        device_init_wakeup(&client->dev, 1);
1028        i2c_set_clientdata(client, kpad);
1029
1030        dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq);
1031        return 0;
1032
1033err_free_irq:
1034        free_irq(client->irq, kpad);
1035err_unreg_dev:
1036        input_unregister_device(input);
1037        input = NULL;
1038err_free_input:
1039        input_free_device(input);
1040err_free_mem:
1041        kfree(kpad);
1042
1043        return error;
1044}
1045
1046static int adp5589_remove(struct i2c_client *client)
1047{
1048        struct adp5589_kpad *kpad = i2c_get_clientdata(client);
1049
1050        adp5589_write(client, kpad->var->reg(ADP5589_GENERAL_CFG), 0);
1051        free_irq(client->irq, kpad);
1052        input_unregister_device(kpad->input);
1053        adp5589_gpio_remove(kpad);
1054        kfree(kpad);
1055
1056        return 0;
1057}
1058
1059#ifdef CONFIG_PM_SLEEP
1060static int adp5589_suspend(struct device *dev)
1061{
1062        struct adp5589_kpad *kpad = dev_get_drvdata(dev);
1063        struct i2c_client *client = kpad->client;
1064
1065        disable_irq(client->irq);
1066
1067        if (device_may_wakeup(&client->dev))
1068                enable_irq_wake(client->irq);
1069
1070        return 0;
1071}
1072
1073static int adp5589_resume(struct device *dev)
1074{
1075        struct adp5589_kpad *kpad = dev_get_drvdata(dev);
1076        struct i2c_client *client = kpad->client;
1077
1078        if (device_may_wakeup(&client->dev))
1079                disable_irq_wake(client->irq);
1080
1081        enable_irq(client->irq);
1082
1083        return 0;
1084}
1085#endif
1086
1087static SIMPLE_DEV_PM_OPS(adp5589_dev_pm_ops, adp5589_suspend, adp5589_resume);
1088
1089static const struct i2c_device_id adp5589_id[] = {
1090        {"adp5589-keys", ADP5589},
1091        {"adp5585-keys", ADP5585_01},
1092        {"adp5585-02-keys", ADP5585_02}, /* Adds ROW5 to ADP5585 */
1093        {}
1094};
1095
1096MODULE_DEVICE_TABLE(i2c, adp5589_id);
1097
1098static struct i2c_driver adp5589_driver = {
1099        .driver = {
1100                .name = KBUILD_MODNAME,
1101                .pm = &adp5589_dev_pm_ops,
1102        },
1103        .probe = adp5589_probe,
1104        .remove = adp5589_remove,
1105        .id_table = adp5589_id,
1106};
1107
1108module_i2c_driver(adp5589_driver);
1109
1110MODULE_LICENSE("GPL");
1111MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
1112MODULE_DESCRIPTION("ADP5589/ADP5585 Keypad driver");
1113