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