linux/drivers/input/keyboard/adp5589-keys.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Description:  keypad driver for ADP5589, ADP5585
   4 *               I2C QWERTY Keypad and IO Expander
   5 * Bugs: Enter bugs at http://blackfin.uclinux.org/
   6 *
   7 * Copyright (C) 2010-2011 Analog Devices Inc.
   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.parent = dev;
 509        kpad->gc.ngpio = adp5589_build_gpiomap(kpad, pdata);
 510        if (kpad->gc.ngpio == 0) {
 511                dev_info(dev, "No unused gpios left to export\n");
 512                return 0;
 513        }
 514
 515        kpad->export_gpio = true;
 516
 517        kpad->gc.direction_input = adp5589_gpio_direction_input;
 518        kpad->gc.direction_output = adp5589_gpio_direction_output;
 519        kpad->gc.get = adp5589_gpio_get_value;
 520        kpad->gc.set = adp5589_gpio_set_value;
 521        kpad->gc.can_sleep = 1;
 522
 523        kpad->gc.base = gpio_data->gpio_start;
 524        kpad->gc.label = kpad->client->name;
 525        kpad->gc.owner = THIS_MODULE;
 526
 527        mutex_init(&kpad->gpio_lock);
 528
 529        error = gpiochip_add_data(&kpad->gc, kpad);
 530        if (error) {
 531                dev_err(dev, "gpiochip_add_data() failed, err: %d\n", error);
 532                return error;
 533        }
 534
 535        for (i = 0; i <= kpad->var->bank(kpad->var->maxgpio); i++) {
 536                kpad->dat_out[i] = adp5589_read(kpad->client, kpad->var->reg(
 537                                                ADP5589_GPO_DATA_OUT_A) + i);
 538                kpad->dir[i] = adp5589_read(kpad->client, kpad->var->reg(
 539                                            ADP5589_GPIO_DIRECTION_A) + i);
 540        }
 541
 542        if (gpio_data->setup) {
 543                error = gpio_data->setup(kpad->client,
 544                                         kpad->gc.base, kpad->gc.ngpio,
 545                                         gpio_data->context);
 546                if (error)
 547                        dev_warn(dev, "setup failed, %d\n", error);
 548        }
 549
 550        return 0;
 551}
 552
 553static void adp5589_gpio_remove(struct adp5589_kpad *kpad)
 554{
 555        struct device *dev = &kpad->client->dev;
 556        const struct adp5589_kpad_platform_data *pdata = dev_get_platdata(dev);
 557        const struct adp5589_gpio_platform_data *gpio_data = pdata->gpio_data;
 558        int error;
 559
 560        if (!kpad->export_gpio)
 561                return;
 562
 563        if (gpio_data->teardown) {
 564                error = gpio_data->teardown(kpad->client,
 565                                            kpad->gc.base, kpad->gc.ngpio,
 566                                            gpio_data->context);
 567                if (error)
 568                        dev_warn(dev, "teardown failed %d\n", error);
 569        }
 570
 571        gpiochip_remove(&kpad->gc);
 572}
 573#else
 574static inline int adp5589_gpio_add(struct adp5589_kpad *kpad)
 575{
 576        return 0;
 577}
 578
 579static inline void adp5589_gpio_remove(struct adp5589_kpad *kpad)
 580{
 581}
 582#endif
 583
 584static void adp5589_report_switches(struct adp5589_kpad *kpad,
 585                                    int key, int key_val)
 586{
 587        int i;
 588
 589        for (i = 0; i < kpad->gpimapsize; i++) {
 590                if (key_val == kpad->gpimap[i].pin) {
 591                        input_report_switch(kpad->input,
 592                                            kpad->gpimap[i].sw_evt,
 593                                            key & KEY_EV_PRESSED);
 594                        break;
 595                }
 596        }
 597}
 598
 599static void adp5589_report_events(struct adp5589_kpad *kpad, int ev_cnt)
 600{
 601        int i;
 602
 603        for (i = 0; i < ev_cnt; i++) {
 604                int key = adp5589_read(kpad->client, ADP5589_5_FIFO_1 + i);
 605                int key_val = key & KEY_EV_MASK;
 606
 607                if (key_val >= kpad->var->gpi_pin_base &&
 608                    key_val <= kpad->var->gpi_pin_end) {
 609                        adp5589_report_switches(kpad, key, key_val);
 610                } else {
 611                        input_report_key(kpad->input,
 612                                         kpad->keycode[key_val - 1],
 613                                         key & KEY_EV_PRESSED);
 614                }
 615        }
 616}
 617
 618static irqreturn_t adp5589_irq(int irq, void *handle)
 619{
 620        struct adp5589_kpad *kpad = handle;
 621        struct i2c_client *client = kpad->client;
 622        int status, ev_cnt;
 623
 624        status = adp5589_read(client, ADP5589_5_INT_STATUS);
 625
 626        if (status & OVRFLOW_INT)       /* Unlikely and should never happen */
 627                dev_err(&client->dev, "Event Overflow Error\n");
 628
 629        if (status & EVENT_INT) {
 630                ev_cnt = adp5589_read(client, ADP5589_5_STATUS) & KEC;
 631                if (ev_cnt) {
 632                        adp5589_report_events(kpad, ev_cnt);
 633                        input_sync(kpad->input);
 634                }
 635        }
 636
 637        adp5589_write(client, ADP5589_5_INT_STATUS, status); /* Status is W1C */
 638
 639        return IRQ_HANDLED;
 640}
 641
 642static int adp5589_get_evcode(struct adp5589_kpad *kpad, unsigned short key)
 643{
 644        int i;
 645
 646        for (i = 0; i < kpad->var->keymapsize; i++)
 647                if (key == kpad->keycode[i])
 648                        return (i + 1) | KEY_EV_PRESSED;
 649
 650        dev_err(&kpad->client->dev, "RESET/UNLOCK key not in keycode map\n");
 651
 652        return -EINVAL;
 653}
 654
 655static int adp5589_setup(struct adp5589_kpad *kpad)
 656{
 657        struct i2c_client *client = kpad->client;
 658        const struct adp5589_kpad_platform_data *pdata =
 659                dev_get_platdata(&client->dev);
 660        u8 (*reg) (u8) = kpad->var->reg;
 661        unsigned char evt_mode1 = 0, evt_mode2 = 0, evt_mode3 = 0;
 662        unsigned char pull_mask = 0;
 663        int i, ret;
 664
 665        ret = adp5589_write(client, reg(ADP5589_PIN_CONFIG_A),
 666                            pdata->keypad_en_mask & kpad->var->row_mask);
 667        ret |= adp5589_write(client, reg(ADP5589_PIN_CONFIG_B),
 668                             (pdata->keypad_en_mask >> kpad->var->col_shift) &
 669                             kpad->var->col_mask);
 670
 671        if (!kpad->is_adp5585)
 672                ret |= adp5589_write(client, ADP5589_PIN_CONFIG_C,
 673                                     (pdata->keypad_en_mask >> 16) & 0xFF);
 674
 675        if (!kpad->is_adp5585 && pdata->en_keylock) {
 676                ret |= adp5589_write(client, ADP5589_UNLOCK1,
 677                                     pdata->unlock_key1);
 678                ret |= adp5589_write(client, ADP5589_UNLOCK2,
 679                                     pdata->unlock_key2);
 680                ret |= adp5589_write(client, ADP5589_UNLOCK_TIMERS,
 681                                     pdata->unlock_timer & LTIME_MASK);
 682                ret |= adp5589_write(client, ADP5589_LOCK_CFG, LOCK_EN);
 683        }
 684
 685        for (i = 0; i < KEYP_MAX_EVENT; i++)
 686                ret |= adp5589_read(client, ADP5589_5_FIFO_1 + i);
 687
 688        for (i = 0; i < pdata->gpimapsize; i++) {
 689                unsigned short pin = pdata->gpimap[i].pin;
 690
 691                if (pin <= kpad->var->gpi_pin_row_end) {
 692                        evt_mode1 |= (1 << (pin - kpad->var->gpi_pin_row_base));
 693                } else {
 694                        evt_mode2 |=
 695                            ((1 << (pin - kpad->var->gpi_pin_col_base)) & 0xFF);
 696                        if (!kpad->is_adp5585)
 697                                evt_mode3 |= ((1 << (pin -
 698                                        kpad->var->gpi_pin_col_base)) >> 8);
 699                }
 700        }
 701
 702        if (pdata->gpimapsize) {
 703                ret |= adp5589_write(client, reg(ADP5589_GPI_EVENT_EN_A),
 704                                     evt_mode1);
 705                ret |= adp5589_write(client, reg(ADP5589_GPI_EVENT_EN_B),
 706                                     evt_mode2);
 707                if (!kpad->is_adp5585)
 708                        ret |= adp5589_write(client,
 709                                             reg(ADP5589_GPI_EVENT_EN_C),
 710                                             evt_mode3);
 711        }
 712
 713        if (pdata->pull_dis_mask & pdata->pullup_en_100k &
 714                pdata->pullup_en_300k & pdata->pulldown_en_300k)
 715                dev_warn(&client->dev, "Conflicting pull resistor config\n");
 716
 717        for (i = 0; i <= kpad->var->max_row_num; i++) {
 718                unsigned val = 0, bit = (1 << i);
 719                if (pdata->pullup_en_300k & bit)
 720                        val = 0;
 721                else if (pdata->pulldown_en_300k & bit)
 722                        val = 1;
 723                else if (pdata->pullup_en_100k & bit)
 724                        val = 2;
 725                else if (pdata->pull_dis_mask & bit)
 726                        val = 3;
 727
 728                pull_mask |= val << (2 * (i & 0x3));
 729
 730                if (i % 4 == 3 || i == kpad->var->max_row_num) {
 731                        ret |= adp5589_write(client, reg(ADP5585_RPULL_CONFIG_A)
 732                                             + (i >> 2), pull_mask);
 733                        pull_mask = 0;
 734                }
 735        }
 736
 737        for (i = 0; i <= kpad->var->max_col_num; i++) {
 738                unsigned val = 0, bit = 1 << (i + kpad->var->col_shift);
 739                if (pdata->pullup_en_300k & bit)
 740                        val = 0;
 741                else if (pdata->pulldown_en_300k & bit)
 742                        val = 1;
 743                else if (pdata->pullup_en_100k & bit)
 744                        val = 2;
 745                else if (pdata->pull_dis_mask & bit)
 746                        val = 3;
 747
 748                pull_mask |= val << (2 * (i & 0x3));
 749
 750                if (i % 4 == 3 || i == kpad->var->max_col_num) {
 751                        ret |= adp5589_write(client,
 752                                             reg(ADP5585_RPULL_CONFIG_C) +
 753                                             (i >> 2), pull_mask);
 754                        pull_mask = 0;
 755                }
 756        }
 757
 758        if (pdata->reset1_key_1 && pdata->reset1_key_2 && pdata->reset1_key_3) {
 759                ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_A),
 760                                     adp5589_get_evcode(kpad,
 761                                                        pdata->reset1_key_1));
 762                ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_B),
 763                                     adp5589_get_evcode(kpad,
 764                                                        pdata->reset1_key_2));
 765                ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_C),
 766                                     adp5589_get_evcode(kpad,
 767                                                        pdata->reset1_key_3));
 768                kpad->extend_cfg |= R4_EXTEND_CFG;
 769        }
 770
 771        if (pdata->reset2_key_1 && pdata->reset2_key_2) {
 772                ret |= adp5589_write(client, reg(ADP5589_RESET2_EVENT_A),
 773                                     adp5589_get_evcode(kpad,
 774                                                        pdata->reset2_key_1));
 775                ret |= adp5589_write(client, reg(ADP5589_RESET2_EVENT_B),
 776                                     adp5589_get_evcode(kpad,
 777                                                        pdata->reset2_key_2));
 778                kpad->extend_cfg |= C4_EXTEND_CFG;
 779        }
 780
 781        if (kpad->extend_cfg) {
 782                ret |= adp5589_write(client, reg(ADP5589_RESET_CFG),
 783                                     pdata->reset_cfg);
 784                ret |= adp5589_write(client, reg(ADP5589_PIN_CONFIG_D),
 785                                     kpad->extend_cfg);
 786        }
 787
 788        ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_A),
 789                            pdata->debounce_dis_mask & kpad->var->row_mask);
 790
 791        ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_B),
 792                             (pdata->debounce_dis_mask >> kpad->var->col_shift)
 793                             & kpad->var->col_mask);
 794
 795        if (!kpad->is_adp5585)
 796                ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_C),
 797                                     (pdata->debounce_dis_mask >> 16) & 0xFF);
 798
 799        ret |= adp5589_write(client, reg(ADP5589_POLL_PTIME_CFG),
 800                             pdata->scan_cycle_time & PTIME_MASK);
 801        ret |= adp5589_write(client, ADP5589_5_INT_STATUS,
 802                             (kpad->is_adp5585 ? 0 : LOGIC2_INT) |
 803                             LOGIC1_INT | OVRFLOW_INT |
 804                             (kpad->is_adp5585 ? 0 : LOCK_INT) |
 805                             GPI_INT | EVENT_INT);      /* Status is W1C */
 806
 807        ret |= adp5589_write(client, reg(ADP5589_GENERAL_CFG),
 808                             INT_CFG | OSC_EN | CORE_CLK(3));
 809        ret |= adp5589_write(client, reg(ADP5589_INT_EN),
 810                             OVRFLOW_IEN | GPI_IEN | EVENT_IEN);
 811
 812        if (ret < 0) {
 813                dev_err(&client->dev, "Write Error\n");
 814                return ret;
 815        }
 816
 817        return 0;
 818}
 819
 820static void adp5589_report_switch_state(struct adp5589_kpad *kpad)
 821{
 822        int gpi_stat_tmp, pin_loc;
 823        int i;
 824        int gpi_stat1 = adp5589_read(kpad->client,
 825                                     kpad->var->reg(ADP5589_GPI_STATUS_A));
 826        int gpi_stat2 = adp5589_read(kpad->client,
 827                                     kpad->var->reg(ADP5589_GPI_STATUS_B));
 828        int gpi_stat3 = !kpad->is_adp5585 ?
 829                        adp5589_read(kpad->client, ADP5589_GPI_STATUS_C) : 0;
 830
 831        for (i = 0; i < kpad->gpimapsize; i++) {
 832                unsigned short pin = kpad->gpimap[i].pin;
 833
 834                if (pin <= kpad->var->gpi_pin_row_end) {
 835                        gpi_stat_tmp = gpi_stat1;
 836                        pin_loc = pin - kpad->var->gpi_pin_row_base;
 837                } else if ((pin - kpad->var->gpi_pin_col_base) < 8) {
 838                        gpi_stat_tmp = gpi_stat2;
 839                        pin_loc = pin - kpad->var->gpi_pin_col_base;
 840                } else {
 841                        gpi_stat_tmp = gpi_stat3;
 842                        pin_loc = pin - kpad->var->gpi_pin_col_base - 8;
 843                }
 844
 845                if (gpi_stat_tmp < 0) {
 846                        dev_err(&kpad->client->dev,
 847                                "Can't read GPIO_DAT_STAT switch %d, default to OFF\n",
 848                                pin);
 849                        gpi_stat_tmp = 0;
 850                }
 851
 852                input_report_switch(kpad->input,
 853                                    kpad->gpimap[i].sw_evt,
 854                                    !(gpi_stat_tmp & (1 << pin_loc)));
 855        }
 856
 857        input_sync(kpad->input);
 858}
 859
 860static int adp5589_probe(struct i2c_client *client,
 861                         const struct i2c_device_id *id)
 862{
 863        struct adp5589_kpad *kpad;
 864        const struct adp5589_kpad_platform_data *pdata =
 865                dev_get_platdata(&client->dev);
 866        struct input_dev *input;
 867        unsigned int revid;
 868        int ret, i;
 869        int error;
 870
 871        if (!i2c_check_functionality(client->adapter,
 872                                     I2C_FUNC_SMBUS_BYTE_DATA)) {
 873                dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
 874                return -EIO;
 875        }
 876
 877        if (!pdata) {
 878                dev_err(&client->dev, "no platform data?\n");
 879                return -EINVAL;
 880        }
 881
 882        kpad = kzalloc(sizeof(*kpad), GFP_KERNEL);
 883        if (!kpad)
 884                return -ENOMEM;
 885
 886        switch (id->driver_data) {
 887        case ADP5585_02:
 888                kpad->support_row5 = true;
 889                /* fall through */
 890        case ADP5585_01:
 891                kpad->is_adp5585 = true;
 892                kpad->var = &const_adp5585;
 893                break;
 894        case ADP5589:
 895                kpad->support_row5 = true;
 896                kpad->var = &const_adp5589;
 897                break;
 898        }
 899
 900        if (!((pdata->keypad_en_mask & kpad->var->row_mask) &&
 901                        (pdata->keypad_en_mask >> kpad->var->col_shift)) ||
 902                        !pdata->keymap) {
 903                dev_err(&client->dev, "no rows, cols or keymap from pdata\n");
 904                error = -EINVAL;
 905                goto err_free_mem;
 906        }
 907
 908        if (pdata->keymapsize != kpad->var->keymapsize) {
 909                dev_err(&client->dev, "invalid keymapsize\n");
 910                error = -EINVAL;
 911                goto err_free_mem;
 912        }
 913
 914        if (!pdata->gpimap && pdata->gpimapsize) {
 915                dev_err(&client->dev, "invalid gpimap from pdata\n");
 916                error = -EINVAL;
 917                goto err_free_mem;
 918        }
 919
 920        if (pdata->gpimapsize > kpad->var->gpimapsize_max) {
 921                dev_err(&client->dev, "invalid gpimapsize\n");
 922                error = -EINVAL;
 923                goto err_free_mem;
 924        }
 925
 926        for (i = 0; i < pdata->gpimapsize; i++) {
 927                unsigned short pin = pdata->gpimap[i].pin;
 928
 929                if (pin < kpad->var->gpi_pin_base ||
 930                                pin > kpad->var->gpi_pin_end) {
 931                        dev_err(&client->dev, "invalid gpi pin data\n");
 932                        error = -EINVAL;
 933                        goto err_free_mem;
 934                }
 935
 936                if ((1 << (pin - kpad->var->gpi_pin_row_base)) &
 937                                pdata->keypad_en_mask) {
 938                        dev_err(&client->dev, "invalid gpi row/col data\n");
 939                        error = -EINVAL;
 940                        goto err_free_mem;
 941                }
 942        }
 943
 944        if (!client->irq) {
 945                dev_err(&client->dev, "no IRQ?\n");
 946                error = -EINVAL;
 947                goto err_free_mem;
 948        }
 949
 950        input = input_allocate_device();
 951        if (!input) {
 952                error = -ENOMEM;
 953                goto err_free_mem;
 954        }
 955
 956        kpad->client = client;
 957        kpad->input = input;
 958
 959        ret = adp5589_read(client, ADP5589_5_ID);
 960        if (ret < 0) {
 961                error = ret;
 962                goto err_free_input;
 963        }
 964
 965        revid = (u8) ret & ADP5589_5_DEVICE_ID_MASK;
 966
 967        input->name = client->name;
 968        input->phys = "adp5589-keys/input0";
 969        input->dev.parent = &client->dev;
 970
 971        input_set_drvdata(input, kpad);
 972
 973        input->id.bustype = BUS_I2C;
 974        input->id.vendor = 0x0001;
 975        input->id.product = 0x0001;
 976        input->id.version = revid;
 977
 978        input->keycodesize = sizeof(kpad->keycode[0]);
 979        input->keycodemax = pdata->keymapsize;
 980        input->keycode = kpad->keycode;
 981
 982        memcpy(kpad->keycode, pdata->keymap,
 983               pdata->keymapsize * input->keycodesize);
 984
 985        kpad->gpimap = pdata->gpimap;
 986        kpad->gpimapsize = pdata->gpimapsize;
 987
 988        /* setup input device */
 989        __set_bit(EV_KEY, input->evbit);
 990
 991        if (pdata->repeat)
 992                __set_bit(EV_REP, input->evbit);
 993
 994        for (i = 0; i < input->keycodemax; i++)
 995                if (kpad->keycode[i] <= KEY_MAX)
 996                        __set_bit(kpad->keycode[i], input->keybit);
 997        __clear_bit(KEY_RESERVED, input->keybit);
 998
 999        if (kpad->gpimapsize)
1000                __set_bit(EV_SW, input->evbit);
1001        for (i = 0; i < kpad->gpimapsize; i++)
1002                __set_bit(kpad->gpimap[i].sw_evt, input->swbit);
1003
1004        error = input_register_device(input);
1005        if (error) {
1006                dev_err(&client->dev, "unable to register input device\n");
1007                goto err_free_input;
1008        }
1009
1010        error = request_threaded_irq(client->irq, NULL, adp5589_irq,
1011                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1012                                     client->dev.driver->name, kpad);
1013        if (error) {
1014                dev_err(&client->dev, "irq %d busy?\n", client->irq);
1015                goto err_unreg_dev;
1016        }
1017
1018        error = adp5589_setup(kpad);
1019        if (error)
1020                goto err_free_irq;
1021
1022        if (kpad->gpimapsize)
1023                adp5589_report_switch_state(kpad);
1024
1025        error = adp5589_gpio_add(kpad);
1026        if (error)
1027                goto err_free_irq;
1028
1029        device_init_wakeup(&client->dev, 1);
1030        i2c_set_clientdata(client, kpad);
1031
1032        dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq);
1033        return 0;
1034
1035err_free_irq:
1036        free_irq(client->irq, kpad);
1037err_unreg_dev:
1038        input_unregister_device(input);
1039        input = NULL;
1040err_free_input:
1041        input_free_device(input);
1042err_free_mem:
1043        kfree(kpad);
1044
1045        return error;
1046}
1047
1048static int adp5589_remove(struct i2c_client *client)
1049{
1050        struct adp5589_kpad *kpad = i2c_get_clientdata(client);
1051
1052        adp5589_write(client, kpad->var->reg(ADP5589_GENERAL_CFG), 0);
1053        free_irq(client->irq, kpad);
1054        input_unregister_device(kpad->input);
1055        adp5589_gpio_remove(kpad);
1056        kfree(kpad);
1057
1058        return 0;
1059}
1060
1061#ifdef CONFIG_PM_SLEEP
1062static int adp5589_suspend(struct device *dev)
1063{
1064        struct adp5589_kpad *kpad = dev_get_drvdata(dev);
1065        struct i2c_client *client = kpad->client;
1066
1067        disable_irq(client->irq);
1068
1069        if (device_may_wakeup(&client->dev))
1070                enable_irq_wake(client->irq);
1071
1072        return 0;
1073}
1074
1075static int adp5589_resume(struct device *dev)
1076{
1077        struct adp5589_kpad *kpad = dev_get_drvdata(dev);
1078        struct i2c_client *client = kpad->client;
1079
1080        if (device_may_wakeup(&client->dev))
1081                disable_irq_wake(client->irq);
1082
1083        enable_irq(client->irq);
1084
1085        return 0;
1086}
1087#endif
1088
1089static SIMPLE_DEV_PM_OPS(adp5589_dev_pm_ops, adp5589_suspend, adp5589_resume);
1090
1091static const struct i2c_device_id adp5589_id[] = {
1092        {"adp5589-keys", ADP5589},
1093        {"adp5585-keys", ADP5585_01},
1094        {"adp5585-02-keys", ADP5585_02}, /* Adds ROW5 to ADP5585 */
1095        {}
1096};
1097
1098MODULE_DEVICE_TABLE(i2c, adp5589_id);
1099
1100static struct i2c_driver adp5589_driver = {
1101        .driver = {
1102                .name = KBUILD_MODNAME,
1103                .pm = &adp5589_dev_pm_ops,
1104        },
1105        .probe = adp5589_probe,
1106        .remove = adp5589_remove,
1107        .id_table = adp5589_id,
1108};
1109
1110module_i2c_driver(adp5589_driver);
1111
1112MODULE_LICENSE("GPL");
1113MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
1114MODULE_DESCRIPTION("ADP5589/ADP5585 Keypad driver");
1115