Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Description:  keypad driver for ADP5589, ADP5585
0004  *       I2C QWERTY Keypad and IO Expander
0005  * Bugs: Enter bugs at http://blackfin.uclinux.org/
0006  *
0007  * Copyright (C) 2010-2011 Analog Devices Inc.
0008  */
0009 
0010 #include <linux/bitops.h>
0011 #include <linux/module.h>
0012 #include <linux/interrupt.h>
0013 #include <linux/irq.h>
0014 #include <linux/workqueue.h>
0015 #include <linux/errno.h>
0016 #include <linux/pm.h>
0017 #include <linux/pm_wakeirq.h>
0018 #include <linux/platform_device.h>
0019 #include <linux/input.h>
0020 #include <linux/i2c.h>
0021 #include <linux/gpio/driver.h>
0022 #include <linux/slab.h>
0023 
0024 #include <linux/input/adp5589.h>
0025 
0026 /* ADP5589/ADP5585 Common Registers */
0027 #define ADP5589_5_ID            0x00
0028 #define ADP5589_5_INT_STATUS        0x01
0029 #define ADP5589_5_STATUS        0x02
0030 #define ADP5589_5_FIFO_1        0x03
0031 #define ADP5589_5_FIFO_2        0x04
0032 #define ADP5589_5_FIFO_3        0x05
0033 #define ADP5589_5_FIFO_4        0x06
0034 #define ADP5589_5_FIFO_5        0x07
0035 #define ADP5589_5_FIFO_6        0x08
0036 #define ADP5589_5_FIFO_7        0x09
0037 #define ADP5589_5_FIFO_8        0x0A
0038 #define ADP5589_5_FIFO_9        0x0B
0039 #define ADP5589_5_FIFO_10       0x0C
0040 #define ADP5589_5_FIFO_11       0x0D
0041 #define ADP5589_5_FIFO_12       0x0E
0042 #define ADP5589_5_FIFO_13       0x0F
0043 #define ADP5589_5_FIFO_14       0x10
0044 #define ADP5589_5_FIFO_15       0x11
0045 #define ADP5589_5_FIFO_16       0x12
0046 #define ADP5589_5_GPI_INT_STAT_A    0x13
0047 #define ADP5589_5_GPI_INT_STAT_B    0x14
0048 
0049 /* ADP5589 Registers */
0050 #define ADP5589_GPI_INT_STAT_C      0x15
0051 #define ADP5589_GPI_STATUS_A        0x16
0052 #define ADP5589_GPI_STATUS_B        0x17
0053 #define ADP5589_GPI_STATUS_C        0x18
0054 #define ADP5589_RPULL_CONFIG_A      0x19
0055 #define ADP5589_RPULL_CONFIG_B      0x1A
0056 #define ADP5589_RPULL_CONFIG_C      0x1B
0057 #define ADP5589_RPULL_CONFIG_D      0x1C
0058 #define ADP5589_RPULL_CONFIG_E      0x1D
0059 #define ADP5589_GPI_INT_LEVEL_A     0x1E
0060 #define ADP5589_GPI_INT_LEVEL_B     0x1F
0061 #define ADP5589_GPI_INT_LEVEL_C     0x20
0062 #define ADP5589_GPI_EVENT_EN_A      0x21
0063 #define ADP5589_GPI_EVENT_EN_B      0x22
0064 #define ADP5589_GPI_EVENT_EN_C      0x23
0065 #define ADP5589_GPI_INTERRUPT_EN_A  0x24
0066 #define ADP5589_GPI_INTERRUPT_EN_B  0x25
0067 #define ADP5589_GPI_INTERRUPT_EN_C  0x26
0068 #define ADP5589_DEBOUNCE_DIS_A      0x27
0069 #define ADP5589_DEBOUNCE_DIS_B      0x28
0070 #define ADP5589_DEBOUNCE_DIS_C      0x29
0071 #define ADP5589_GPO_DATA_OUT_A      0x2A
0072 #define ADP5589_GPO_DATA_OUT_B      0x2B
0073 #define ADP5589_GPO_DATA_OUT_C      0x2C
0074 #define ADP5589_GPO_OUT_MODE_A      0x2D
0075 #define ADP5589_GPO_OUT_MODE_B      0x2E
0076 #define ADP5589_GPO_OUT_MODE_C      0x2F
0077 #define ADP5589_GPIO_DIRECTION_A    0x30
0078 #define ADP5589_GPIO_DIRECTION_B    0x31
0079 #define ADP5589_GPIO_DIRECTION_C    0x32
0080 #define ADP5589_UNLOCK1         0x33
0081 #define ADP5589_UNLOCK2         0x34
0082 #define ADP5589_EXT_LOCK_EVENT      0x35
0083 #define ADP5589_UNLOCK_TIMERS       0x36
0084 #define ADP5589_LOCK_CFG        0x37
0085 #define ADP5589_RESET1_EVENT_A      0x38
0086 #define ADP5589_RESET1_EVENT_B      0x39
0087 #define ADP5589_RESET1_EVENT_C      0x3A
0088 #define ADP5589_RESET2_EVENT_A      0x3B
0089 #define ADP5589_RESET2_EVENT_B      0x3C
0090 #define ADP5589_RESET_CFG       0x3D
0091 #define ADP5589_PWM_OFFT_LOW        0x3E
0092 #define ADP5589_PWM_OFFT_HIGH       0x3F
0093 #define ADP5589_PWM_ONT_LOW     0x40
0094 #define ADP5589_PWM_ONT_HIGH        0x41
0095 #define ADP5589_PWM_CFG         0x42
0096 #define ADP5589_CLOCK_DIV_CFG       0x43
0097 #define ADP5589_LOGIC_1_CFG     0x44
0098 #define ADP5589_LOGIC_2_CFG     0x45
0099 #define ADP5589_LOGIC_FF_CFG        0x46
0100 #define ADP5589_LOGIC_INT_EVENT_EN  0x47
0101 #define ADP5589_POLL_PTIME_CFG      0x48
0102 #define ADP5589_PIN_CONFIG_A        0x49
0103 #define ADP5589_PIN_CONFIG_B        0x4A
0104 #define ADP5589_PIN_CONFIG_C        0x4B
0105 #define ADP5589_PIN_CONFIG_D        0x4C
0106 #define ADP5589_GENERAL_CFG     0x4D
0107 #define ADP5589_INT_EN          0x4E
0108 
0109 /* ADP5585 Registers */
0110 #define ADP5585_GPI_STATUS_A        0x15
0111 #define ADP5585_GPI_STATUS_B        0x16
0112 #define ADP5585_RPULL_CONFIG_A      0x17
0113 #define ADP5585_RPULL_CONFIG_B      0x18
0114 #define ADP5585_RPULL_CONFIG_C      0x19
0115 #define ADP5585_RPULL_CONFIG_D      0x1A
0116 #define ADP5585_GPI_INT_LEVEL_A     0x1B
0117 #define ADP5585_GPI_INT_LEVEL_B     0x1C
0118 #define ADP5585_GPI_EVENT_EN_A      0x1D
0119 #define ADP5585_GPI_EVENT_EN_B      0x1E
0120 #define ADP5585_GPI_INTERRUPT_EN_A  0x1F
0121 #define ADP5585_GPI_INTERRUPT_EN_B  0x20
0122 #define ADP5585_DEBOUNCE_DIS_A      0x21
0123 #define ADP5585_DEBOUNCE_DIS_B      0x22
0124 #define ADP5585_GPO_DATA_OUT_A      0x23
0125 #define ADP5585_GPO_DATA_OUT_B      0x24
0126 #define ADP5585_GPO_OUT_MODE_A      0x25
0127 #define ADP5585_GPO_OUT_MODE_B      0x26
0128 #define ADP5585_GPIO_DIRECTION_A    0x27
0129 #define ADP5585_GPIO_DIRECTION_B    0x28
0130 #define ADP5585_RESET1_EVENT_A      0x29
0131 #define ADP5585_RESET1_EVENT_B      0x2A
0132 #define ADP5585_RESET1_EVENT_C      0x2B
0133 #define ADP5585_RESET2_EVENT_A      0x2C
0134 #define ADP5585_RESET2_EVENT_B      0x2D
0135 #define ADP5585_RESET_CFG       0x2E
0136 #define ADP5585_PWM_OFFT_LOW        0x2F
0137 #define ADP5585_PWM_OFFT_HIGH       0x30
0138 #define ADP5585_PWM_ONT_LOW     0x31
0139 #define ADP5585_PWM_ONT_HIGH        0x32
0140 #define ADP5585_PWM_CFG         0x33
0141 #define ADP5585_LOGIC_CFG       0x34
0142 #define ADP5585_LOGIC_FF_CFG        0x35
0143 #define ADP5585_LOGIC_INT_EVENT_EN  0x36
0144 #define ADP5585_POLL_PTIME_CFG      0x37
0145 #define ADP5585_PIN_CONFIG_A        0x38
0146 #define ADP5585_PIN_CONFIG_B        0x39
0147 #define ADP5585_PIN_CONFIG_D        0x3A
0148 #define ADP5585_GENERAL_CFG     0x3B
0149 #define ADP5585_INT_EN          0x3C
0150 
0151 /* ID Register */
0152 #define ADP5589_5_DEVICE_ID_MASK    0xF
0153 #define ADP5589_5_MAN_ID_MASK       0xF
0154 #define ADP5589_5_MAN_ID_SHIFT      4
0155 #define ADP5589_5_MAN_ID        0x02
0156 
0157 /* GENERAL_CFG Register */
0158 #define OSC_EN      BIT(7)
0159 #define CORE_CLK(x) (((x) & 0x3) << 5)
0160 #define LCK_TRK_LOGIC   BIT(4)      /* ADP5589 only */
0161 #define LCK_TRK_GPI BIT(3)      /* ADP5589 only */
0162 #define INT_CFG     BIT(1)
0163 #define RST_CFG     BIT(0)
0164 
0165 /* INT_EN Register */
0166 #define LOGIC2_IEN  BIT(5)      /* ADP5589 only */
0167 #define LOGIC1_IEN  BIT(4)
0168 #define LOCK_IEN    BIT(3)      /* ADP5589 only */
0169 #define OVRFLOW_IEN BIT(2)
0170 #define GPI_IEN     BIT(1)
0171 #define EVENT_IEN   BIT(0)
0172 
0173 /* Interrupt Status Register */
0174 #define LOGIC2_INT  BIT(5)      /* ADP5589 only */
0175 #define LOGIC1_INT  BIT(4)
0176 #define LOCK_INT    BIT(3)      /* ADP5589 only */
0177 #define OVRFLOW_INT BIT(2)
0178 #define GPI_INT     BIT(1)
0179 #define EVENT_INT   BIT(0)
0180 
0181 /* STATUS Register */
0182 #define LOGIC2_STAT BIT(7)      /* ADP5589 only */
0183 #define LOGIC1_STAT BIT(6)
0184 #define LOCK_STAT   BIT(5)      /* ADP5589 only */
0185 #define KEC     0x1F
0186 
0187 /* PIN_CONFIG_D Register */
0188 #define C4_EXTEND_CFG   BIT(6)      /* RESET2 */
0189 #define R4_EXTEND_CFG   BIT(5)      /* RESET1 */
0190 
0191 /* LOCK_CFG */
0192 #define LOCK_EN     BIT(0)
0193 
0194 #define PTIME_MASK  0x3
0195 #define LTIME_MASK  0x3     /* ADP5589 only */
0196 
0197 /* Key Event Register xy */
0198 #define KEY_EV_PRESSED  BIT(7)
0199 #define KEY_EV_MASK 0x7F
0200 
0201 #define KEYP_MAX_EVENT      16
0202 #define ADP5589_MAXGPIO     19
0203 #define ADP5585_MAXGPIO     11 /* 10 on the ADP5585-01, 11 on ADP5585-02 */
0204 
0205 enum {
0206     ADP5589,
0207     ADP5585_01,
0208     ADP5585_02
0209 };
0210 
0211 struct adp_constants {
0212     u8 maxgpio;
0213     u8 keymapsize;
0214     u8 gpi_pin_row_base;
0215     u8 gpi_pin_row_end;
0216     u8 gpi_pin_col_base;
0217     u8 gpi_pin_base;
0218     u8 gpi_pin_end;
0219     u8 gpimapsize_max;
0220     u8 max_row_num;
0221     u8 max_col_num;
0222     u8 row_mask;
0223     u8 col_mask;
0224     u8 col_shift;
0225     u8 c4_extend_cfg;
0226     u8 (*bank) (u8 offset);
0227     u8 (*bit) (u8 offset);
0228     u8 (*reg) (u8 reg);
0229 };
0230 
0231 struct adp5589_kpad {
0232     struct i2c_client *client;
0233     struct input_dev *input;
0234     const struct adp_constants *var;
0235     unsigned short keycode[ADP5589_KEYMAPSIZE];
0236     const struct adp5589_gpi_map *gpimap;
0237     unsigned short gpimapsize;
0238     unsigned extend_cfg;
0239     bool is_adp5585;
0240     bool support_row5;
0241 #ifdef CONFIG_GPIOLIB
0242     unsigned char gpiomap[ADP5589_MAXGPIO];
0243     struct gpio_chip gc;
0244     struct mutex gpio_lock; /* Protect cached dir, dat_out */
0245     u8 dat_out[3];
0246     u8 dir[3];
0247 #endif
0248 };
0249 
0250 /*
0251  *  ADP5589 / ADP5585 derivative / variant handling
0252  */
0253 
0254 
0255 /* ADP5589 */
0256 
0257 static unsigned char adp5589_bank(unsigned char offset)
0258 {
0259     return offset >> 3;
0260 }
0261 
0262 static unsigned char adp5589_bit(unsigned char offset)
0263 {
0264     return 1u << (offset & 0x7);
0265 }
0266 
0267 static unsigned char adp5589_reg(unsigned char reg)
0268 {
0269     return reg;
0270 }
0271 
0272 static const struct adp_constants const_adp5589 = {
0273     .maxgpio        = ADP5589_MAXGPIO,
0274     .keymapsize     = ADP5589_KEYMAPSIZE,
0275     .gpi_pin_row_base   = ADP5589_GPI_PIN_ROW_BASE,
0276     .gpi_pin_row_end    = ADP5589_GPI_PIN_ROW_END,
0277     .gpi_pin_col_base   = ADP5589_GPI_PIN_COL_BASE,
0278     .gpi_pin_base       = ADP5589_GPI_PIN_BASE,
0279     .gpi_pin_end        = ADP5589_GPI_PIN_END,
0280     .gpimapsize_max     = ADP5589_GPIMAPSIZE_MAX,
0281     .c4_extend_cfg      = 12,
0282     .max_row_num        = ADP5589_MAX_ROW_NUM,
0283     .max_col_num        = ADP5589_MAX_COL_NUM,
0284     .row_mask       = ADP5589_ROW_MASK,
0285     .col_mask       = ADP5589_COL_MASK,
0286     .col_shift      = ADP5589_COL_SHIFT,
0287     .bank           = adp5589_bank,
0288     .bit            = adp5589_bit,
0289     .reg            = adp5589_reg,
0290 };
0291 
0292 /* ADP5585 */
0293 
0294 static unsigned char adp5585_bank(unsigned char offset)
0295 {
0296     return offset > ADP5585_MAX_ROW_NUM;
0297 }
0298 
0299 static unsigned char adp5585_bit(unsigned char offset)
0300 {
0301     return (offset > ADP5585_MAX_ROW_NUM) ?
0302         1u << (offset - ADP5585_COL_SHIFT) : 1u << offset;
0303 }
0304 
0305 static const unsigned char adp5585_reg_lut[] = {
0306     [ADP5589_GPI_STATUS_A]      = ADP5585_GPI_STATUS_A,
0307     [ADP5589_GPI_STATUS_B]      = ADP5585_GPI_STATUS_B,
0308     [ADP5589_RPULL_CONFIG_A]    = ADP5585_RPULL_CONFIG_A,
0309     [ADP5589_RPULL_CONFIG_B]    = ADP5585_RPULL_CONFIG_B,
0310     [ADP5589_RPULL_CONFIG_C]    = ADP5585_RPULL_CONFIG_C,
0311     [ADP5589_RPULL_CONFIG_D]    = ADP5585_RPULL_CONFIG_D,
0312     [ADP5589_GPI_INT_LEVEL_A]   = ADP5585_GPI_INT_LEVEL_A,
0313     [ADP5589_GPI_INT_LEVEL_B]   = ADP5585_GPI_INT_LEVEL_B,
0314     [ADP5589_GPI_EVENT_EN_A]    = ADP5585_GPI_EVENT_EN_A,
0315     [ADP5589_GPI_EVENT_EN_B]    = ADP5585_GPI_EVENT_EN_B,
0316     [ADP5589_GPI_INTERRUPT_EN_A]    = ADP5585_GPI_INTERRUPT_EN_A,
0317     [ADP5589_GPI_INTERRUPT_EN_B]    = ADP5585_GPI_INTERRUPT_EN_B,
0318     [ADP5589_DEBOUNCE_DIS_A]    = ADP5585_DEBOUNCE_DIS_A,
0319     [ADP5589_DEBOUNCE_DIS_B]    = ADP5585_DEBOUNCE_DIS_B,
0320     [ADP5589_GPO_DATA_OUT_A]    = ADP5585_GPO_DATA_OUT_A,
0321     [ADP5589_GPO_DATA_OUT_B]    = ADP5585_GPO_DATA_OUT_B,
0322     [ADP5589_GPO_OUT_MODE_A]    = ADP5585_GPO_OUT_MODE_A,
0323     [ADP5589_GPO_OUT_MODE_B]    = ADP5585_GPO_OUT_MODE_B,
0324     [ADP5589_GPIO_DIRECTION_A]  = ADP5585_GPIO_DIRECTION_A,
0325     [ADP5589_GPIO_DIRECTION_B]  = ADP5585_GPIO_DIRECTION_B,
0326     [ADP5589_RESET1_EVENT_A]    = ADP5585_RESET1_EVENT_A,
0327     [ADP5589_RESET1_EVENT_B]    = ADP5585_RESET1_EVENT_B,
0328     [ADP5589_RESET1_EVENT_C]    = ADP5585_RESET1_EVENT_C,
0329     [ADP5589_RESET2_EVENT_A]    = ADP5585_RESET2_EVENT_A,
0330     [ADP5589_RESET2_EVENT_B]    = ADP5585_RESET2_EVENT_B,
0331     [ADP5589_RESET_CFG]     = ADP5585_RESET_CFG,
0332     [ADP5589_PWM_OFFT_LOW]      = ADP5585_PWM_OFFT_LOW,
0333     [ADP5589_PWM_OFFT_HIGH]     = ADP5585_PWM_OFFT_HIGH,
0334     [ADP5589_PWM_ONT_LOW]       = ADP5585_PWM_ONT_LOW,
0335     [ADP5589_PWM_ONT_HIGH]      = ADP5585_PWM_ONT_HIGH,
0336     [ADP5589_PWM_CFG]       = ADP5585_PWM_CFG,
0337     [ADP5589_LOGIC_1_CFG]       = ADP5585_LOGIC_CFG,
0338     [ADP5589_LOGIC_FF_CFG]      = ADP5585_LOGIC_FF_CFG,
0339     [ADP5589_LOGIC_INT_EVENT_EN]    = ADP5585_LOGIC_INT_EVENT_EN,
0340     [ADP5589_POLL_PTIME_CFG]    = ADP5585_POLL_PTIME_CFG,
0341     [ADP5589_PIN_CONFIG_A]      = ADP5585_PIN_CONFIG_A,
0342     [ADP5589_PIN_CONFIG_B]      = ADP5585_PIN_CONFIG_B,
0343     [ADP5589_PIN_CONFIG_D]      = ADP5585_PIN_CONFIG_D,
0344     [ADP5589_GENERAL_CFG]       = ADP5585_GENERAL_CFG,
0345     [ADP5589_INT_EN]        = ADP5585_INT_EN,
0346 };
0347 
0348 static unsigned char adp5585_reg(unsigned char reg)
0349 {
0350     return adp5585_reg_lut[reg];
0351 }
0352 
0353 static const struct adp_constants const_adp5585 = {
0354     .maxgpio        = ADP5585_MAXGPIO,
0355     .keymapsize     = ADP5585_KEYMAPSIZE,
0356     .gpi_pin_row_base   = ADP5585_GPI_PIN_ROW_BASE,
0357     .gpi_pin_row_end    = ADP5585_GPI_PIN_ROW_END,
0358     .gpi_pin_col_base   = ADP5585_GPI_PIN_COL_BASE,
0359     .gpi_pin_base       = ADP5585_GPI_PIN_BASE,
0360     .gpi_pin_end        = ADP5585_GPI_PIN_END,
0361     .gpimapsize_max     = ADP5585_GPIMAPSIZE_MAX,
0362     .c4_extend_cfg      = 10,
0363     .max_row_num        = ADP5585_MAX_ROW_NUM,
0364     .max_col_num        = ADP5585_MAX_COL_NUM,
0365     .row_mask       = ADP5585_ROW_MASK,
0366     .col_mask       = ADP5585_COL_MASK,
0367     .col_shift      = ADP5585_COL_SHIFT,
0368     .bank           = adp5585_bank,
0369     .bit            = adp5585_bit,
0370     .reg            = adp5585_reg,
0371 };
0372 
0373 static int adp5589_read(struct i2c_client *client, u8 reg)
0374 {
0375     int ret = i2c_smbus_read_byte_data(client, reg);
0376 
0377     if (ret < 0)
0378         dev_err(&client->dev, "Read Error\n");
0379 
0380     return ret;
0381 }
0382 
0383 static int adp5589_write(struct i2c_client *client, u8 reg, u8 val)
0384 {
0385     return i2c_smbus_write_byte_data(client, reg, val);
0386 }
0387 
0388 #ifdef CONFIG_GPIOLIB
0389 static int adp5589_gpio_get_value(struct gpio_chip *chip, unsigned off)
0390 {
0391     struct adp5589_kpad *kpad = gpiochip_get_data(chip);
0392     unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
0393     unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
0394 
0395     return !!(adp5589_read(kpad->client,
0396                    kpad->var->reg(ADP5589_GPI_STATUS_A) + bank) &
0397                    bit);
0398 }
0399 
0400 static void adp5589_gpio_set_value(struct gpio_chip *chip,
0401                    unsigned off, int val)
0402 {
0403     struct adp5589_kpad *kpad = gpiochip_get_data(chip);
0404     unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
0405     unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
0406 
0407     mutex_lock(&kpad->gpio_lock);
0408 
0409     if (val)
0410         kpad->dat_out[bank] |= bit;
0411     else
0412         kpad->dat_out[bank] &= ~bit;
0413 
0414     adp5589_write(kpad->client, kpad->var->reg(ADP5589_GPO_DATA_OUT_A) +
0415               bank, kpad->dat_out[bank]);
0416 
0417     mutex_unlock(&kpad->gpio_lock);
0418 }
0419 
0420 static int adp5589_gpio_direction_input(struct gpio_chip *chip, unsigned off)
0421 {
0422     struct adp5589_kpad *kpad = gpiochip_get_data(chip);
0423     unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
0424     unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
0425     int ret;
0426 
0427     mutex_lock(&kpad->gpio_lock);
0428 
0429     kpad->dir[bank] &= ~bit;
0430     ret = adp5589_write(kpad->client,
0431                 kpad->var->reg(ADP5589_GPIO_DIRECTION_A) + bank,
0432                 kpad->dir[bank]);
0433 
0434     mutex_unlock(&kpad->gpio_lock);
0435 
0436     return ret;
0437 }
0438 
0439 static int adp5589_gpio_direction_output(struct gpio_chip *chip,
0440                      unsigned off, int val)
0441 {
0442     struct adp5589_kpad *kpad = gpiochip_get_data(chip);
0443     unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
0444     unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
0445     int ret;
0446 
0447     mutex_lock(&kpad->gpio_lock);
0448 
0449     kpad->dir[bank] |= bit;
0450 
0451     if (val)
0452         kpad->dat_out[bank] |= bit;
0453     else
0454         kpad->dat_out[bank] &= ~bit;
0455 
0456     ret = adp5589_write(kpad->client, kpad->var->reg(ADP5589_GPO_DATA_OUT_A)
0457                 + bank, kpad->dat_out[bank]);
0458     ret |= adp5589_write(kpad->client,
0459                  kpad->var->reg(ADP5589_GPIO_DIRECTION_A) + bank,
0460                  kpad->dir[bank]);
0461 
0462     mutex_unlock(&kpad->gpio_lock);
0463 
0464     return ret;
0465 }
0466 
0467 static int adp5589_build_gpiomap(struct adp5589_kpad *kpad,
0468                 const struct adp5589_kpad_platform_data *pdata)
0469 {
0470     bool pin_used[ADP5589_MAXGPIO];
0471     int n_unused = 0;
0472     int i;
0473 
0474     memset(pin_used, false, sizeof(pin_used));
0475 
0476     for (i = 0; i < kpad->var->maxgpio; i++)
0477         if (pdata->keypad_en_mask & BIT(i))
0478             pin_used[i] = true;
0479 
0480     for (i = 0; i < kpad->gpimapsize; i++)
0481         pin_used[kpad->gpimap[i].pin - kpad->var->gpi_pin_base] = true;
0482 
0483     if (kpad->extend_cfg & R4_EXTEND_CFG)
0484         pin_used[4] = true;
0485 
0486     if (kpad->extend_cfg & C4_EXTEND_CFG)
0487         pin_used[kpad->var->c4_extend_cfg] = true;
0488 
0489     if (!kpad->support_row5)
0490         pin_used[5] = true;
0491 
0492     for (i = 0; i < kpad->var->maxgpio; i++)
0493         if (!pin_used[i])
0494             kpad->gpiomap[n_unused++] = i;
0495 
0496     return n_unused;
0497 }
0498 
0499 static int adp5589_gpio_add(struct adp5589_kpad *kpad)
0500 {
0501     struct device *dev = &kpad->client->dev;
0502     const struct adp5589_kpad_platform_data *pdata = dev_get_platdata(dev);
0503     const struct adp5589_gpio_platform_data *gpio_data = pdata->gpio_data;
0504     int i, error;
0505 
0506     if (!gpio_data)
0507         return 0;
0508 
0509     kpad->gc.parent = dev;
0510     kpad->gc.ngpio = adp5589_build_gpiomap(kpad, pdata);
0511     if (kpad->gc.ngpio == 0) {
0512         dev_info(dev, "No unused gpios left to export\n");
0513         return 0;
0514     }
0515 
0516     kpad->gc.direction_input = adp5589_gpio_direction_input;
0517     kpad->gc.direction_output = adp5589_gpio_direction_output;
0518     kpad->gc.get = adp5589_gpio_get_value;
0519     kpad->gc.set = adp5589_gpio_set_value;
0520     kpad->gc.can_sleep = 1;
0521 
0522     kpad->gc.base = gpio_data->gpio_start;
0523     kpad->gc.label = kpad->client->name;
0524     kpad->gc.owner = THIS_MODULE;
0525 
0526     mutex_init(&kpad->gpio_lock);
0527 
0528     error = devm_gpiochip_add_data(dev, &kpad->gc, kpad);
0529     if (error)
0530         return error;
0531 
0532     for (i = 0; i <= kpad->var->bank(kpad->var->maxgpio); i++) {
0533         kpad->dat_out[i] = adp5589_read(kpad->client, kpad->var->reg(
0534                         ADP5589_GPO_DATA_OUT_A) + i);
0535         kpad->dir[i] = adp5589_read(kpad->client, kpad->var->reg(
0536                         ADP5589_GPIO_DIRECTION_A) + i);
0537     }
0538 
0539     return 0;
0540 }
0541 #else
0542 static inline int adp5589_gpio_add(struct adp5589_kpad *kpad)
0543 {
0544     return 0;
0545 }
0546 #endif
0547 
0548 static void adp5589_report_switches(struct adp5589_kpad *kpad,
0549                     int key, int key_val)
0550 {
0551     int i;
0552 
0553     for (i = 0; i < kpad->gpimapsize; i++) {
0554         if (key_val == kpad->gpimap[i].pin) {
0555             input_report_switch(kpad->input,
0556                         kpad->gpimap[i].sw_evt,
0557                         key & KEY_EV_PRESSED);
0558             break;
0559         }
0560     }
0561 }
0562 
0563 static void adp5589_report_events(struct adp5589_kpad *kpad, int ev_cnt)
0564 {
0565     int i;
0566 
0567     for (i = 0; i < ev_cnt; i++) {
0568         int key = adp5589_read(kpad->client, ADP5589_5_FIFO_1 + i);
0569         int key_val = key & KEY_EV_MASK;
0570 
0571         if (key_val >= kpad->var->gpi_pin_base &&
0572             key_val <= kpad->var->gpi_pin_end) {
0573             adp5589_report_switches(kpad, key, key_val);
0574         } else {
0575             input_report_key(kpad->input,
0576                      kpad->keycode[key_val - 1],
0577                      key & KEY_EV_PRESSED);
0578         }
0579     }
0580 }
0581 
0582 static irqreturn_t adp5589_irq(int irq, void *handle)
0583 {
0584     struct adp5589_kpad *kpad = handle;
0585     struct i2c_client *client = kpad->client;
0586     int status, ev_cnt;
0587 
0588     status = adp5589_read(client, ADP5589_5_INT_STATUS);
0589 
0590     if (status & OVRFLOW_INT)   /* Unlikely and should never happen */
0591         dev_err(&client->dev, "Event Overflow Error\n");
0592 
0593     if (status & EVENT_INT) {
0594         ev_cnt = adp5589_read(client, ADP5589_5_STATUS) & KEC;
0595         if (ev_cnt) {
0596             adp5589_report_events(kpad, ev_cnt);
0597             input_sync(kpad->input);
0598         }
0599     }
0600 
0601     adp5589_write(client, ADP5589_5_INT_STATUS, status); /* Status is W1C */
0602 
0603     return IRQ_HANDLED;
0604 }
0605 
0606 static int adp5589_get_evcode(struct adp5589_kpad *kpad, unsigned short key)
0607 {
0608     int i;
0609 
0610     for (i = 0; i < kpad->var->keymapsize; i++)
0611         if (key == kpad->keycode[i])
0612             return (i + 1) | KEY_EV_PRESSED;
0613 
0614     dev_err(&kpad->client->dev, "RESET/UNLOCK key not in keycode map\n");
0615 
0616     return -EINVAL;
0617 }
0618 
0619 static int adp5589_setup(struct adp5589_kpad *kpad)
0620 {
0621     struct i2c_client *client = kpad->client;
0622     const struct adp5589_kpad_platform_data *pdata =
0623         dev_get_platdata(&client->dev);
0624     u8 (*reg) (u8) = kpad->var->reg;
0625     unsigned char evt_mode1 = 0, evt_mode2 = 0, evt_mode3 = 0;
0626     unsigned char pull_mask = 0;
0627     int i, ret;
0628 
0629     ret = adp5589_write(client, reg(ADP5589_PIN_CONFIG_A),
0630                 pdata->keypad_en_mask & kpad->var->row_mask);
0631     ret |= adp5589_write(client, reg(ADP5589_PIN_CONFIG_B),
0632                  (pdata->keypad_en_mask >> kpad->var->col_shift) &
0633                  kpad->var->col_mask);
0634 
0635     if (!kpad->is_adp5585)
0636         ret |= adp5589_write(client, ADP5589_PIN_CONFIG_C,
0637                      (pdata->keypad_en_mask >> 16) & 0xFF);
0638 
0639     if (!kpad->is_adp5585 && pdata->en_keylock) {
0640         ret |= adp5589_write(client, ADP5589_UNLOCK1,
0641                      pdata->unlock_key1);
0642         ret |= adp5589_write(client, ADP5589_UNLOCK2,
0643                      pdata->unlock_key2);
0644         ret |= adp5589_write(client, ADP5589_UNLOCK_TIMERS,
0645                      pdata->unlock_timer & LTIME_MASK);
0646         ret |= adp5589_write(client, ADP5589_LOCK_CFG, LOCK_EN);
0647     }
0648 
0649     for (i = 0; i < KEYP_MAX_EVENT; i++)
0650         ret |= adp5589_read(client, ADP5589_5_FIFO_1 + i);
0651 
0652     for (i = 0; i < pdata->gpimapsize; i++) {
0653         unsigned short pin = pdata->gpimap[i].pin;
0654 
0655         if (pin <= kpad->var->gpi_pin_row_end) {
0656             evt_mode1 |= BIT(pin - kpad->var->gpi_pin_row_base);
0657         } else {
0658             evt_mode2 |=
0659                 BIT(pin - kpad->var->gpi_pin_col_base) & 0xFF;
0660             if (!kpad->is_adp5585)
0661                 evt_mode3 |=
0662                     BIT(pin - kpad->var->gpi_pin_col_base) >> 8;
0663         }
0664     }
0665 
0666     if (pdata->gpimapsize) {
0667         ret |= adp5589_write(client, reg(ADP5589_GPI_EVENT_EN_A),
0668                      evt_mode1);
0669         ret |= adp5589_write(client, reg(ADP5589_GPI_EVENT_EN_B),
0670                      evt_mode2);
0671         if (!kpad->is_adp5585)
0672             ret |= adp5589_write(client,
0673                          reg(ADP5589_GPI_EVENT_EN_C),
0674                          evt_mode3);
0675     }
0676 
0677     if (pdata->pull_dis_mask & pdata->pullup_en_100k &
0678         pdata->pullup_en_300k & pdata->pulldown_en_300k)
0679         dev_warn(&client->dev, "Conflicting pull resistor config\n");
0680 
0681     for (i = 0; i <= kpad->var->max_row_num; i++) {
0682         unsigned int val = 0, bit = BIT(i);
0683         if (pdata->pullup_en_300k & bit)
0684             val = 0;
0685         else if (pdata->pulldown_en_300k & bit)
0686             val = 1;
0687         else if (pdata->pullup_en_100k & bit)
0688             val = 2;
0689         else if (pdata->pull_dis_mask & bit)
0690             val = 3;
0691 
0692         pull_mask |= val << (2 * (i & 0x3));
0693 
0694         if (i % 4 == 3 || i == kpad->var->max_row_num) {
0695             ret |= adp5589_write(client, reg(ADP5585_RPULL_CONFIG_A)
0696                          + (i >> 2), pull_mask);
0697             pull_mask = 0;
0698         }
0699     }
0700 
0701     for (i = 0; i <= kpad->var->max_col_num; i++) {
0702         unsigned int val = 0, bit = BIT(i + kpad->var->col_shift);
0703         if (pdata->pullup_en_300k & bit)
0704             val = 0;
0705         else if (pdata->pulldown_en_300k & bit)
0706             val = 1;
0707         else if (pdata->pullup_en_100k & bit)
0708             val = 2;
0709         else if (pdata->pull_dis_mask & bit)
0710             val = 3;
0711 
0712         pull_mask |= val << (2 * (i & 0x3));
0713 
0714         if (i % 4 == 3 || i == kpad->var->max_col_num) {
0715             ret |= adp5589_write(client,
0716                          reg(ADP5585_RPULL_CONFIG_C) +
0717                          (i >> 2), pull_mask);
0718             pull_mask = 0;
0719         }
0720     }
0721 
0722     if (pdata->reset1_key_1 && pdata->reset1_key_2 && pdata->reset1_key_3) {
0723         ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_A),
0724                      adp5589_get_evcode(kpad,
0725                             pdata->reset1_key_1));
0726         ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_B),
0727                      adp5589_get_evcode(kpad,
0728                             pdata->reset1_key_2));
0729         ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_C),
0730                      adp5589_get_evcode(kpad,
0731                             pdata->reset1_key_3));
0732         kpad->extend_cfg |= R4_EXTEND_CFG;
0733     }
0734 
0735     if (pdata->reset2_key_1 && pdata->reset2_key_2) {
0736         ret |= adp5589_write(client, reg(ADP5589_RESET2_EVENT_A),
0737                      adp5589_get_evcode(kpad,
0738                             pdata->reset2_key_1));
0739         ret |= adp5589_write(client, reg(ADP5589_RESET2_EVENT_B),
0740                      adp5589_get_evcode(kpad,
0741                             pdata->reset2_key_2));
0742         kpad->extend_cfg |= C4_EXTEND_CFG;
0743     }
0744 
0745     if (kpad->extend_cfg) {
0746         ret |= adp5589_write(client, reg(ADP5589_RESET_CFG),
0747                      pdata->reset_cfg);
0748         ret |= adp5589_write(client, reg(ADP5589_PIN_CONFIG_D),
0749                      kpad->extend_cfg);
0750     }
0751 
0752     ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_A),
0753                 pdata->debounce_dis_mask & kpad->var->row_mask);
0754 
0755     ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_B),
0756                  (pdata->debounce_dis_mask >> kpad->var->col_shift)
0757                  & kpad->var->col_mask);
0758 
0759     if (!kpad->is_adp5585)
0760         ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_C),
0761                      (pdata->debounce_dis_mask >> 16) & 0xFF);
0762 
0763     ret |= adp5589_write(client, reg(ADP5589_POLL_PTIME_CFG),
0764                  pdata->scan_cycle_time & PTIME_MASK);
0765     ret |= adp5589_write(client, ADP5589_5_INT_STATUS,
0766                  (kpad->is_adp5585 ? 0 : LOGIC2_INT) |
0767                  LOGIC1_INT | OVRFLOW_INT |
0768                  (kpad->is_adp5585 ? 0 : LOCK_INT) |
0769                  GPI_INT | EVENT_INT);  /* Status is W1C */
0770 
0771     ret |= adp5589_write(client, reg(ADP5589_GENERAL_CFG),
0772                  INT_CFG | OSC_EN | CORE_CLK(3));
0773     ret |= adp5589_write(client, reg(ADP5589_INT_EN),
0774                  OVRFLOW_IEN | GPI_IEN | EVENT_IEN);
0775 
0776     if (ret < 0) {
0777         dev_err(&client->dev, "Write Error\n");
0778         return ret;
0779     }
0780 
0781     return 0;
0782 }
0783 
0784 static void adp5589_report_switch_state(struct adp5589_kpad *kpad)
0785 {
0786     int gpi_stat_tmp, pin_loc;
0787     int i;
0788     int gpi_stat1 = adp5589_read(kpad->client,
0789                      kpad->var->reg(ADP5589_GPI_STATUS_A));
0790     int gpi_stat2 = adp5589_read(kpad->client,
0791                      kpad->var->reg(ADP5589_GPI_STATUS_B));
0792     int gpi_stat3 = !kpad->is_adp5585 ?
0793             adp5589_read(kpad->client, ADP5589_GPI_STATUS_C) : 0;
0794 
0795     for (i = 0; i < kpad->gpimapsize; i++) {
0796         unsigned short pin = kpad->gpimap[i].pin;
0797 
0798         if (pin <= kpad->var->gpi_pin_row_end) {
0799             gpi_stat_tmp = gpi_stat1;
0800             pin_loc = pin - kpad->var->gpi_pin_row_base;
0801         } else if ((pin - kpad->var->gpi_pin_col_base) < 8) {
0802             gpi_stat_tmp = gpi_stat2;
0803             pin_loc = pin - kpad->var->gpi_pin_col_base;
0804         } else {
0805             gpi_stat_tmp = gpi_stat3;
0806             pin_loc = pin - kpad->var->gpi_pin_col_base - 8;
0807         }
0808 
0809         if (gpi_stat_tmp < 0) {
0810             dev_err(&kpad->client->dev,
0811                 "Can't read GPIO_DAT_STAT switch %d, default to OFF\n",
0812                 pin);
0813             gpi_stat_tmp = 0;
0814         }
0815 
0816         input_report_switch(kpad->input,
0817                     kpad->gpimap[i].sw_evt,
0818                     !(gpi_stat_tmp & BIT(pin_loc)));
0819     }
0820 
0821     input_sync(kpad->input);
0822 }
0823 
0824 static int adp5589_keypad_add(struct adp5589_kpad *kpad, unsigned int revid)
0825 {
0826     struct i2c_client *client = kpad->client;
0827     const struct adp5589_kpad_platform_data *pdata =
0828         dev_get_platdata(&client->dev);
0829     struct input_dev *input;
0830     unsigned int i;
0831     int error;
0832 
0833     if (!((pdata->keypad_en_mask & kpad->var->row_mask) &&
0834             (pdata->keypad_en_mask >> kpad->var->col_shift)) ||
0835             !pdata->keymap) {
0836         dev_err(&client->dev, "no rows, cols or keymap from pdata\n");
0837         return -EINVAL;
0838     }
0839 
0840     if (pdata->keymapsize != kpad->var->keymapsize) {
0841         dev_err(&client->dev, "invalid keymapsize\n");
0842         return -EINVAL;
0843     }
0844 
0845     if (!pdata->gpimap && pdata->gpimapsize) {
0846         dev_err(&client->dev, "invalid gpimap from pdata\n");
0847         return -EINVAL;
0848     }
0849 
0850     if (pdata->gpimapsize > kpad->var->gpimapsize_max) {
0851         dev_err(&client->dev, "invalid gpimapsize\n");
0852         return -EINVAL;
0853     }
0854 
0855     for (i = 0; i < pdata->gpimapsize; i++) {
0856         unsigned short pin = pdata->gpimap[i].pin;
0857 
0858         if (pin < kpad->var->gpi_pin_base ||
0859                 pin > kpad->var->gpi_pin_end) {
0860             dev_err(&client->dev, "invalid gpi pin data\n");
0861             return -EINVAL;
0862         }
0863 
0864         if (BIT(pin - kpad->var->gpi_pin_row_base) &
0865                 pdata->keypad_en_mask) {
0866             dev_err(&client->dev, "invalid gpi row/col data\n");
0867             return -EINVAL;
0868         }
0869     }
0870 
0871     if (!client->irq) {
0872         dev_err(&client->dev, "no IRQ?\n");
0873         return -EINVAL;
0874     }
0875 
0876     input = devm_input_allocate_device(&client->dev);
0877     if (!input)
0878         return -ENOMEM;
0879 
0880     kpad->input = input;
0881 
0882     input->name = client->name;
0883     input->phys = "adp5589-keys/input0";
0884     input->dev.parent = &client->dev;
0885 
0886     input_set_drvdata(input, kpad);
0887 
0888     input->id.bustype = BUS_I2C;
0889     input->id.vendor = 0x0001;
0890     input->id.product = 0x0001;
0891     input->id.version = revid;
0892 
0893     input->keycodesize = sizeof(kpad->keycode[0]);
0894     input->keycodemax = pdata->keymapsize;
0895     input->keycode = kpad->keycode;
0896 
0897     memcpy(kpad->keycode, pdata->keymap,
0898            pdata->keymapsize * input->keycodesize);
0899 
0900     kpad->gpimap = pdata->gpimap;
0901     kpad->gpimapsize = pdata->gpimapsize;
0902 
0903     /* setup input device */
0904     __set_bit(EV_KEY, input->evbit);
0905 
0906     if (pdata->repeat)
0907         __set_bit(EV_REP, input->evbit);
0908 
0909     for (i = 0; i < input->keycodemax; i++)
0910         if (kpad->keycode[i] <= KEY_MAX)
0911             __set_bit(kpad->keycode[i], input->keybit);
0912     __clear_bit(KEY_RESERVED, input->keybit);
0913 
0914     if (kpad->gpimapsize)
0915         __set_bit(EV_SW, input->evbit);
0916     for (i = 0; i < kpad->gpimapsize; i++)
0917         __set_bit(kpad->gpimap[i].sw_evt, input->swbit);
0918 
0919     error = input_register_device(input);
0920     if (error) {
0921         dev_err(&client->dev, "unable to register input device\n");
0922         return error;
0923     }
0924 
0925     error = devm_request_threaded_irq(&client->dev, client->irq,
0926                       NULL, adp5589_irq,
0927                       IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
0928                       client->dev.driver->name, kpad);
0929     if (error) {
0930         dev_err(&client->dev, "unable to request irq %d\n", client->irq);
0931         return error;
0932     }
0933 
0934     return 0;
0935 }
0936 
0937 static void adp5589_clear_config(void *data)
0938 {
0939     struct i2c_client *client = data;
0940     struct adp5589_kpad *kpad = i2c_get_clientdata(client);
0941 
0942     adp5589_write(client, kpad->var->reg(ADP5589_GENERAL_CFG), 0);
0943 }
0944 
0945 static int adp5589_probe(struct i2c_client *client,
0946              const struct i2c_device_id *id)
0947 {
0948     struct adp5589_kpad *kpad;
0949     const struct adp5589_kpad_platform_data *pdata =
0950         dev_get_platdata(&client->dev);
0951     unsigned int revid;
0952     int error, ret;
0953 
0954     if (!i2c_check_functionality(client->adapter,
0955                      I2C_FUNC_SMBUS_BYTE_DATA)) {
0956         dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
0957         return -EIO;
0958     }
0959 
0960     if (!pdata) {
0961         dev_err(&client->dev, "no platform data?\n");
0962         return -EINVAL;
0963     }
0964 
0965     kpad = devm_kzalloc(&client->dev, sizeof(*kpad), GFP_KERNEL);
0966     if (!kpad)
0967         return -ENOMEM;
0968 
0969     kpad->client = client;
0970 
0971     switch (id->driver_data) {
0972     case ADP5585_02:
0973         kpad->support_row5 = true;
0974         fallthrough;
0975     case ADP5585_01:
0976         kpad->is_adp5585 = true;
0977         kpad->var = &const_adp5585;
0978         break;
0979     case ADP5589:
0980         kpad->support_row5 = true;
0981         kpad->var = &const_adp5589;
0982         break;
0983     }
0984 
0985     error = devm_add_action_or_reset(&client->dev, adp5589_clear_config,
0986                      client);
0987     if (error)
0988         return error;
0989 
0990     ret = adp5589_read(client, ADP5589_5_ID);
0991     if (ret < 0)
0992         return ret;
0993 
0994     revid = (u8) ret & ADP5589_5_DEVICE_ID_MASK;
0995 
0996     if (pdata->keymapsize) {
0997         error = adp5589_keypad_add(kpad, revid);
0998         if (error)
0999             return error;
1000     }
1001 
1002     error = adp5589_setup(kpad);
1003     if (error)
1004         return error;
1005 
1006     if (kpad->gpimapsize)
1007         adp5589_report_switch_state(kpad);
1008 
1009     error = adp5589_gpio_add(kpad);
1010     if (error)
1011         return error;
1012 
1013     i2c_set_clientdata(client, kpad);
1014 
1015     dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq);
1016     return 0;
1017 }
1018 
1019 static int __maybe_unused adp5589_suspend(struct device *dev)
1020 {
1021     struct i2c_client *client = to_i2c_client(dev);
1022     struct adp5589_kpad *kpad = i2c_get_clientdata(client);
1023 
1024     if (kpad->input)
1025         disable_irq(client->irq);
1026 
1027     return 0;
1028 }
1029 
1030 static int __maybe_unused adp5589_resume(struct device *dev)
1031 {
1032     struct i2c_client *client = to_i2c_client(dev);
1033     struct adp5589_kpad *kpad = i2c_get_clientdata(client);
1034 
1035     if (kpad->input)
1036         enable_irq(client->irq);
1037 
1038     return 0;
1039 }
1040 
1041 static SIMPLE_DEV_PM_OPS(adp5589_dev_pm_ops, adp5589_suspend, adp5589_resume);
1042 
1043 static const struct i2c_device_id adp5589_id[] = {
1044     {"adp5589-keys", ADP5589},
1045     {"adp5585-keys", ADP5585_01},
1046     {"adp5585-02-keys", ADP5585_02}, /* Adds ROW5 to ADP5585 */
1047     {}
1048 };
1049 
1050 MODULE_DEVICE_TABLE(i2c, adp5589_id);
1051 
1052 static struct i2c_driver adp5589_driver = {
1053     .driver = {
1054         .name = KBUILD_MODNAME,
1055         .pm = &adp5589_dev_pm_ops,
1056     },
1057     .probe = adp5589_probe,
1058     .id_table = adp5589_id,
1059 };
1060 
1061 module_i2c_driver(adp5589_driver);
1062 
1063 MODULE_LICENSE("GPL");
1064 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
1065 MODULE_DESCRIPTION("ADP5589/ADP5585 Keypad driver");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!