root/drivers/input/keyboard/pmic8xxx-keypad.c

DEFINITIONS

1. pmic8xxx_col_state
2. pmic8xxx_chk_sync_read
3. pmic8xxx_kp_read_data
4. pmic8xxx_kp_read_matrix
5. __pmic8xxx_kp_scan_matrix
6. pmic8xxx_detect_ghost_keys
7. pmic8xxx_kp_scan_matrix
8. pmic8xxx_kp_stuck_irq
9. pmic8xxx_kp_irq
10. pmic8xxx_kpd_init
11. pmic8xxx_kp_enable
12. pmic8xxx_kp_disable
13. pmic8xxx_kp_open
14. pmic8xxx_kp_close
15. pmic8xxx_kp_probe
16. pmic8xxx_kp_suspend
17. pmic8xxx_kp_resume

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright (c) 2009-2011, Code Aurora Forum. All rights reserved.
   3  */
   4 
   5 #include <linux/module.h>
   6 #include <linux/platform_device.h>
   7 #include <linux/kernel.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/slab.h>
  10 #include <linux/input.h>
  11 #include <linux/bitops.h>
  12 #include <linux/delay.h>
  13 #include <linux/mutex.h>
  14 #include <linux/regmap.h>
  15 #include <linux/of.h>
  16 #include <linux/input/matrix_keypad.h>
  17 
  18 #define PM8XXX_MAX_ROWS         18
  19 #define PM8XXX_MAX_COLS         8
  20 #define PM8XXX_ROW_SHIFT        3
  21 #define PM8XXX_MATRIX_MAX_SIZE  (PM8XXX_MAX_ROWS * PM8XXX_MAX_COLS)
  22 
  23 #define PM8XXX_MIN_ROWS         5
  24 #define PM8XXX_MIN_COLS         5
  25 
  26 #define MAX_SCAN_DELAY          128
  27 #define MIN_SCAN_DELAY          1
  28 
  29 /* in nanoseconds */
  30 #define MAX_ROW_HOLD_DELAY      122000
  31 #define MIN_ROW_HOLD_DELAY      30500
  32 
  33 #define MAX_DEBOUNCE_TIME       20
  34 #define MIN_DEBOUNCE_TIME       5
  35 
  36 #define KEYP_CTRL                       0x148
  37 
  38 #define KEYP_CTRL_EVNTS                 BIT(0)
  39 #define KEYP_CTRL_EVNTS_MASK            0x3
  40 
  41 #define KEYP_CTRL_SCAN_COLS_SHIFT       5
  42 #define KEYP_CTRL_SCAN_COLS_MIN         5
  43 #define KEYP_CTRL_SCAN_COLS_BITS        0x3
  44 
  45 #define KEYP_CTRL_SCAN_ROWS_SHIFT       2
  46 #define KEYP_CTRL_SCAN_ROWS_MIN         5
  47 #define KEYP_CTRL_SCAN_ROWS_BITS        0x7
  48 
  49 #define KEYP_CTRL_KEYP_EN               BIT(7)
  50 
  51 #define KEYP_SCAN                       0x149
  52 
  53 #define KEYP_SCAN_READ_STATE            BIT(0)
  54 #define KEYP_SCAN_DBOUNCE_SHIFT         1
  55 #define KEYP_SCAN_PAUSE_SHIFT           3
  56 #define KEYP_SCAN_ROW_HOLD_SHIFT        6
  57 
  58 #define KEYP_TEST                       0x14A
  59 
  60 #define KEYP_TEST_CLEAR_RECENT_SCAN     BIT(6)
  61 #define KEYP_TEST_CLEAR_OLD_SCAN        BIT(5)
  62 #define KEYP_TEST_READ_RESET            BIT(4)
  63 #define KEYP_TEST_DTEST_EN              BIT(3)
  64 #define KEYP_TEST_ABORT_READ            BIT(0)
  65 
  66 #define KEYP_TEST_DBG_SELECT_SHIFT      1
  67 
  68 /* bits of these registers represent
  69  * '0' for key press
  70  * '1' for key release
  71  */
  72 #define KEYP_RECENT_DATA                0x14B
  73 #define KEYP_OLD_DATA                   0x14C
  74 
  75 #define KEYP_CLOCK_FREQ                 32768
  76 
  77 /**
  78  * struct pmic8xxx_kp - internal keypad data structure
  79  * @num_cols - number of columns of keypad
  80  * @num_rows - number of row of keypad
  81  * @input - input device pointer for keypad
  82  * @regmap - regmap handle
  83  * @key_sense_irq - key press/release irq number
  84  * @key_stuck_irq - key stuck notification irq number
  85  * @keycodes - array to hold the key codes
  86  * @dev - parent device pointer
  87  * @keystate - present key press/release state
  88  * @stuckstate - present state when key stuck irq
  89  * @ctrl_reg - control register value
  90  */
  91 struct pmic8xxx_kp {
  92         unsigned int num_rows;
  93         unsigned int num_cols;
  94         struct input_dev *input;
  95         struct regmap *regmap;
  96         int key_sense_irq;
  97         int key_stuck_irq;
  98 
  99         unsigned short keycodes[PM8XXX_MATRIX_MAX_SIZE];
 100 
 101         struct device *dev;
 102         u16 keystate[PM8XXX_MAX_ROWS];
 103         u16 stuckstate[PM8XXX_MAX_ROWS];
 104 
 105         u8 ctrl_reg;
 106 };
 107 
 108 static u8 pmic8xxx_col_state(struct pmic8xxx_kp *kp, u8 col)
 109 {
 110         /* all keys pressed on that particular row? */
 111         if (col == 0x00)
 112                 return 1 << kp->num_cols;
 113         else
 114                 return col & ((1 << kp->num_cols) - 1);
 115 }
 116 
 117 /*
 118  * Synchronous read protocol for RevB0 onwards:
 119  *
 120  * 1. Write '1' to ReadState bit in KEYP_SCAN register
 121  * 2. Wait 2*32KHz clocks, so that HW can successfully enter read mode
 122  *    synchronously
 123  * 3. Read rows in old array first if events are more than one
 124  * 4. Read rows in recent array
 125  * 5. Wait 4*32KHz clocks
 126  * 6. Write '0' to ReadState bit of KEYP_SCAN register so that hw can
 127  *    synchronously exit read mode.
 128  */
 129 static int pmic8xxx_chk_sync_read(struct pmic8xxx_kp *kp)
 130 {
 131         int rc;
 132         unsigned int scan_val;
 133 
 134         rc = regmap_read(kp->regmap, KEYP_SCAN, &scan_val);
 135         if (rc < 0) {
 136                 dev_err(kp->dev, "Error reading KEYP_SCAN reg, rc=%d\n", rc);
 137                 return rc;
 138         }
 139 
 140         scan_val |= 0x1;
 141 
 142         rc = regmap_write(kp->regmap, KEYP_SCAN, scan_val);
 143         if (rc < 0) {
 144                 dev_err(kp->dev, "Error writing KEYP_SCAN reg, rc=%d\n", rc);
 145                 return rc;
 146         }
 147 
 148         /* 2 * 32KHz clocks */
 149         udelay((2 * DIV_ROUND_UP(USEC_PER_SEC, KEYP_CLOCK_FREQ)) + 1);
 150 
 151         return rc;
 152 }
 153 
 154 static int pmic8xxx_kp_read_data(struct pmic8xxx_kp *kp, u16 *state,
 155                                         u16 data_reg, int read_rows)
 156 {
 157         int rc, row;
 158         unsigned int val;
 159 
 160         for (row = 0; row < read_rows; row++) {
 161                 rc = regmap_read(kp->regmap, data_reg, &val);
 162                 if (rc)
 163                         return rc;
 164                 dev_dbg(kp->dev, "%d = %d\n", row, val);
 165                 state[row] = pmic8xxx_col_state(kp, val);
 166         }
 167 
 168         return 0;
 169 }
 170 
 171 static int pmic8xxx_kp_read_matrix(struct pmic8xxx_kp *kp, u16 *new_state,
 172                                          u16 *old_state)
 173 {
 174         int rc, read_rows;
 175         unsigned int scan_val;
 176 
 177         if (kp->num_rows < PM8XXX_MIN_ROWS)
 178                 read_rows = PM8XXX_MIN_ROWS;
 179         else
 180                 read_rows = kp->num_rows;
 181 
 182         pmic8xxx_chk_sync_read(kp);
 183 
 184         if (old_state) {
 185                 rc = pmic8xxx_kp_read_data(kp, old_state, KEYP_OLD_DATA,
 186                                                 read_rows);
 187                 if (rc < 0) {
 188                         dev_err(kp->dev,
 189                                 "Error reading KEYP_OLD_DATA, rc=%d\n", rc);
 190                         return rc;
 191                 }
 192         }
 193 
 194         rc = pmic8xxx_kp_read_data(kp, new_state, KEYP_RECENT_DATA,
 195                                          read_rows);
 196         if (rc < 0) {
 197                 dev_err(kp->dev,
 198                         "Error reading KEYP_RECENT_DATA, rc=%d\n", rc);
 199                 return rc;
 200         }
 201 
 202         /* 4 * 32KHz clocks */
 203         udelay((4 * DIV_ROUND_UP(USEC_PER_SEC, KEYP_CLOCK_FREQ)) + 1);
 204 
 205         rc = regmap_read(kp->regmap, KEYP_SCAN, &scan_val);
 206         if (rc < 0) {
 207                 dev_err(kp->dev, "Error reading KEYP_SCAN reg, rc=%d\n", rc);
 208                 return rc;
 209         }
 210 
 211         scan_val &= 0xFE;
 212         rc = regmap_write(kp->regmap, KEYP_SCAN, scan_val);
 213         if (rc < 0)
 214                 dev_err(kp->dev, "Error writing KEYP_SCAN reg, rc=%d\n", rc);
 215 
 216         return rc;
 217 }
 218 
 219 static void __pmic8xxx_kp_scan_matrix(struct pmic8xxx_kp *kp, u16 *new_state,
 220                                          u16 *old_state)
 221 {
 222         int row, col, code;
 223 
 224         for (row = 0; row < kp->num_rows; row++) {
 225                 int bits_changed = new_state[row] ^ old_state[row];
 226 
 227                 if (!bits_changed)
 228                         continue;
 229 
 230                 for (col = 0; col < kp->num_cols; col++) {
 231                         if (!(bits_changed & (1 << col)))
 232                                 continue;
 233 
 234                         dev_dbg(kp->dev, "key [%d:%d] %s\n", row, col,
 235                                         !(new_state[row] & (1 << col)) ?
 236                                         "pressed" : "released");
 237 
 238                         code = MATRIX_SCAN_CODE(row, col, PM8XXX_ROW_SHIFT);
 239 
 240                         input_event(kp->input, EV_MSC, MSC_SCAN, code);
 241                         input_report_key(kp->input,
 242                                         kp->keycodes[code],
 243                                         !(new_state[row] & (1 << col)));
 244 
 245                         input_sync(kp->input);
 246                 }
 247         }
 248 }
 249 
 250 static bool pmic8xxx_detect_ghost_keys(struct pmic8xxx_kp *kp, u16 *new_state)
 251 {
 252         int row, found_first = -1;
 253         u16 check, row_state;
 254 
 255         check = 0;
 256         for (row = 0; row < kp->num_rows; row++) {
 257                 row_state = (~new_state[row]) &
 258                                  ((1 << kp->num_cols) - 1);
 259 
 260                 if (hweight16(row_state) > 1) {
 261                         if (found_first == -1)
 262                                 found_first = row;
 263                         if (check & row_state) {
 264                                 dev_dbg(kp->dev, "detected ghost key on row[%d]"
 265                                          " and row[%d]\n", found_first, row);
 266                                 return true;
 267                         }
 268                 }
 269                 check |= row_state;
 270         }
 271         return false;
 272 }
 273 
 274 static int pmic8xxx_kp_scan_matrix(struct pmic8xxx_kp *kp, unsigned int events)
 275 {
 276         u16 new_state[PM8XXX_MAX_ROWS];
 277         u16 old_state[PM8XXX_MAX_ROWS];
 278         int rc;
 279 
 280         switch (events) {
 281         case 0x1:
 282                 rc = pmic8xxx_kp_read_matrix(kp, new_state, NULL);
 283                 if (rc < 0)
 284                         return rc;
 285 
 286                 /* detecting ghost key is not an error */
 287                 if (pmic8xxx_detect_ghost_keys(kp, new_state))
 288                         return 0;
 289                 __pmic8xxx_kp_scan_matrix(kp, new_state, kp->keystate);
 290                 memcpy(kp->keystate, new_state, sizeof(new_state));
 291         break;
 292         case 0x3: /* two events - eventcounter is gray-coded */
 293                 rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
 294                 if (rc < 0)
 295                         return rc;
 296 
 297                 __pmic8xxx_kp_scan_matrix(kp, old_state, kp->keystate);
 298                 __pmic8xxx_kp_scan_matrix(kp, new_state, old_state);
 299                 memcpy(kp->keystate, new_state, sizeof(new_state));
 300         break;
 301         case 0x2:
 302                 dev_dbg(kp->dev, "Some key events were lost\n");
 303                 rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
 304                 if (rc < 0)
 305                         return rc;
 306                 __pmic8xxx_kp_scan_matrix(kp, old_state, kp->keystate);
 307                 __pmic8xxx_kp_scan_matrix(kp, new_state, old_state);
 308                 memcpy(kp->keystate, new_state, sizeof(new_state));
 309         break;
 310         default:
 311                 rc = -EINVAL;
 312         }
 313         return rc;
 314 }
 315 
 316 /*
 317  * NOTE: We are reading recent and old data registers blindly
 318  * whenever key-stuck interrupt happens, because events counter doesn't
 319  * get updated when this interrupt happens due to key stuck doesn't get
 320  * considered as key state change.
 321  *
 322  * We are not using old data register contents after they are being read
 323  * because it might report the key which was pressed before the key being stuck
 324  * as stuck key because it's pressed status is stored in the old data
 325  * register.
 326  */
 327 static irqreturn_t pmic8xxx_kp_stuck_irq(int irq, void *data)
 328 {
 329         u16 new_state[PM8XXX_MAX_ROWS];
 330         u16 old_state[PM8XXX_MAX_ROWS];
 331         int rc;
 332         struct pmic8xxx_kp *kp = data;
 333 
 334         rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
 335         if (rc < 0) {
 336                 dev_err(kp->dev, "failed to read keypad matrix\n");
 337                 return IRQ_HANDLED;
 338         }
 339 
 340         __pmic8xxx_kp_scan_matrix(kp, new_state, kp->stuckstate);
 341 
 342         return IRQ_HANDLED;
 343 }
 344 
 345 static irqreturn_t pmic8xxx_kp_irq(int irq, void *data)
 346 {
 347         struct pmic8xxx_kp *kp = data;
 348         unsigned int ctrl_val, events;
 349         int rc;
 350 
 351         rc = regmap_read(kp->regmap, KEYP_CTRL, &ctrl_val);
 352         if (rc < 0) {
 353                 dev_err(kp->dev, "failed to read keyp_ctrl register\n");
 354                 return IRQ_HANDLED;
 355         }
 356 
 357         events = ctrl_val & KEYP_CTRL_EVNTS_MASK;
 358 
 359         rc = pmic8xxx_kp_scan_matrix(kp, events);
 360         if (rc < 0)
 361                 dev_err(kp->dev, "failed to scan matrix\n");
 362 
 363         return IRQ_HANDLED;
 364 }
 365 
 366 static int pmic8xxx_kpd_init(struct pmic8xxx_kp *kp,
 367                              struct platform_device *pdev)
 368 {
 369         const struct device_node *of_node = pdev->dev.of_node;
 370         unsigned int scan_delay_ms;
 371         unsigned int row_hold_ns;
 372         unsigned int debounce_ms;
 373         int bits, rc, cycles;
 374         u8 scan_val = 0, ctrl_val = 0;
 375         static const u8 row_bits[] = {
 376                 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 7, 7, 7,
 377         };
 378 
 379         /* Find column bits */
 380         if (kp->num_cols < KEYP_CTRL_SCAN_COLS_MIN)
 381                 bits = 0;
 382         else
 383                 bits = kp->num_cols - KEYP_CTRL_SCAN_COLS_MIN;
 384         ctrl_val = (bits & KEYP_CTRL_SCAN_COLS_BITS) <<
 385                 KEYP_CTRL_SCAN_COLS_SHIFT;
 386 
 387         /* Find row bits */
 388         if (kp->num_rows < KEYP_CTRL_SCAN_ROWS_MIN)
 389                 bits = 0;
 390         else
 391                 bits = row_bits[kp->num_rows - KEYP_CTRL_SCAN_ROWS_MIN];
 392 
 393         ctrl_val |= (bits << KEYP_CTRL_SCAN_ROWS_SHIFT);
 394 
 395         rc = regmap_write(kp->regmap, KEYP_CTRL, ctrl_val);
 396         if (rc < 0) {
 397                 dev_err(kp->dev, "Error writing KEYP_CTRL reg, rc=%d\n", rc);
 398                 return rc;
 399         }
 400 
 401         if (of_property_read_u32(of_node, "scan-delay", &scan_delay_ms))
 402                 scan_delay_ms = MIN_SCAN_DELAY;
 403 
 404         if (scan_delay_ms > MAX_SCAN_DELAY || scan_delay_ms < MIN_SCAN_DELAY ||
 405             !is_power_of_2(scan_delay_ms)) {
 406                 dev_err(&pdev->dev, "invalid keypad scan time supplied\n");
 407                 return -EINVAL;
 408         }
 409 
 410         if (of_property_read_u32(of_node, "row-hold", &row_hold_ns))
 411                 row_hold_ns = MIN_ROW_HOLD_DELAY;
 412 
 413         if (row_hold_ns > MAX_ROW_HOLD_DELAY ||
 414             row_hold_ns < MIN_ROW_HOLD_DELAY ||
 415             ((row_hold_ns % MIN_ROW_HOLD_DELAY) != 0)) {
 416                 dev_err(&pdev->dev, "invalid keypad row hold time supplied\n");
 417                 return -EINVAL;
 418         }
 419 
 420         if (of_property_read_u32(of_node, "debounce", &debounce_ms))
 421                 debounce_ms = MIN_DEBOUNCE_TIME;
 422 
 423         if (((debounce_ms % 5) != 0) ||
 424             debounce_ms > MAX_DEBOUNCE_TIME ||
 425             debounce_ms < MIN_DEBOUNCE_TIME) {
 426                 dev_err(&pdev->dev, "invalid debounce time supplied\n");
 427                 return -EINVAL;
 428         }
 429 
 430         bits = (debounce_ms / 5) - 1;
 431 
 432         scan_val |= (bits << KEYP_SCAN_DBOUNCE_SHIFT);
 433 
 434         bits = fls(scan_delay_ms) - 1;
 435         scan_val |= (bits << KEYP_SCAN_PAUSE_SHIFT);
 436 
 437         /* Row hold time is a multiple of 32KHz cycles. */
 438         cycles = (row_hold_ns * KEYP_CLOCK_FREQ) / NSEC_PER_SEC;
 439 
 440         scan_val |= (cycles << KEYP_SCAN_ROW_HOLD_SHIFT);
 441 
 442         rc = regmap_write(kp->regmap, KEYP_SCAN, scan_val);
 443         if (rc)
 444                 dev_err(kp->dev, "Error writing KEYP_SCAN reg, rc=%d\n", rc);
 445 
 446         return rc;
 447 
 448 }
 449 
 450 static int pmic8xxx_kp_enable(struct pmic8xxx_kp *kp)
 451 {
 452         int rc;
 453 
 454         kp->ctrl_reg |= KEYP_CTRL_KEYP_EN;
 455 
 456         rc = regmap_write(kp->regmap, KEYP_CTRL, kp->ctrl_reg);
 457         if (rc < 0)
 458                 dev_err(kp->dev, "Error writing KEYP_CTRL reg, rc=%d\n", rc);
 459 
 460         return rc;
 461 }
 462 
 463 static int pmic8xxx_kp_disable(struct pmic8xxx_kp *kp)
 464 {
 465         int rc;
 466 
 467         kp->ctrl_reg &= ~KEYP_CTRL_KEYP_EN;
 468 
 469         rc = regmap_write(kp->regmap, KEYP_CTRL, kp->ctrl_reg);
 470         if (rc < 0)
 471                 return rc;
 472 
 473         return rc;
 474 }
 475 
 476 static int pmic8xxx_kp_open(struct input_dev *dev)
 477 {
 478         struct pmic8xxx_kp *kp = input_get_drvdata(dev);
 479 
 480         return pmic8xxx_kp_enable(kp);
 481 }
 482 
 483 static void pmic8xxx_kp_close(struct input_dev *dev)
 484 {
 485         struct pmic8xxx_kp *kp = input_get_drvdata(dev);
 486 
 487         pmic8xxx_kp_disable(kp);
 488 }
 489 
 490 /*
 491  * keypad controller should be initialized in the following sequence
 492  * only, otherwise it might get into FSM stuck state.
 493  *
 494  * - Initialize keypad control parameters, like no. of rows, columns,
 495  *   timing values etc.,
 496  * - configure rows and column gpios pull up/down.
 497  * - set irq edge type.
 498  * - enable the keypad controller.
 499  */
 500 static int pmic8xxx_kp_probe(struct platform_device *pdev)
 501 {
 502         struct device_node *np = pdev->dev.of_node;
 503         unsigned int rows, cols;
 504         bool repeat;
 505         bool wakeup;
 506         struct pmic8xxx_kp *kp;
 507         int rc;
 508         unsigned int ctrl_val;
 509 
 510         rc = matrix_keypad_parse_properties(&pdev->dev, &rows, &cols);
 511         if (rc)
 512                 return rc;
 513 
 514         if (cols > PM8XXX_MAX_COLS || rows > PM8XXX_MAX_ROWS ||
 515             cols < PM8XXX_MIN_COLS) {
 516                 dev_err(&pdev->dev, "invalid platform data\n");
 517                 return -EINVAL;
 518         }
 519 
 520         repeat = !of_property_read_bool(np, "linux,input-no-autorepeat");
 521 
 522         wakeup = of_property_read_bool(np, "wakeup-source") ||
 523                  /* legacy name */
 524                  of_property_read_bool(np, "linux,keypad-wakeup");
 525 
 526         kp = devm_kzalloc(&pdev->dev, sizeof(*kp), GFP_KERNEL);
 527         if (!kp)
 528                 return -ENOMEM;
 529 
 530         kp->regmap = dev_get_regmap(pdev->dev.parent, NULL);
 531         if (!kp->regmap)
 532                 return -ENODEV;
 533 
 534         platform_set_drvdata(pdev, kp);
 535 
 536         kp->num_rows    = rows;
 537         kp->num_cols    = cols;
 538         kp->dev         = &pdev->dev;
 539 
 540         kp->input = devm_input_allocate_device(&pdev->dev);
 541         if (!kp->input) {
 542                 dev_err(&pdev->dev, "unable to allocate input device\n");
 543                 return -ENOMEM;
 544         }
 545 
 546         kp->key_sense_irq = platform_get_irq(pdev, 0);
 547         if (kp->key_sense_irq < 0)
 548                 return kp->key_sense_irq;
 549 
 550         kp->key_stuck_irq = platform_get_irq(pdev, 1);
 551         if (kp->key_stuck_irq < 0)
 552                 return kp->key_stuck_irq;
 553 
 554         kp->input->name = "PMIC8XXX keypad";
 555         kp->input->phys = "pmic8xxx_keypad/input0";
 556 
 557         kp->input->id.bustype   = BUS_I2C;
 558         kp->input->id.version   = 0x0001;
 559         kp->input->id.product   = 0x0001;
 560         kp->input->id.vendor    = 0x0001;
 561 
 562         kp->input->open         = pmic8xxx_kp_open;
 563         kp->input->close        = pmic8xxx_kp_close;
 564 
 565         rc = matrix_keypad_build_keymap(NULL, NULL,
 566                                         PM8XXX_MAX_ROWS, PM8XXX_MAX_COLS,
 567                                         kp->keycodes, kp->input);
 568         if (rc) {
 569                 dev_err(&pdev->dev, "failed to build keymap\n");
 570                 return rc;
 571         }
 572 
 573         if (repeat)
 574                 __set_bit(EV_REP, kp->input->evbit);
 575         input_set_capability(kp->input, EV_MSC, MSC_SCAN);
 576 
 577         input_set_drvdata(kp->input, kp);
 578 
 579         /* initialize keypad state */
 580         memset(kp->keystate, 0xff, sizeof(kp->keystate));
 581         memset(kp->stuckstate, 0xff, sizeof(kp->stuckstate));
 582 
 583         rc = pmic8xxx_kpd_init(kp, pdev);
 584         if (rc < 0) {
 585                 dev_err(&pdev->dev, "unable to initialize keypad controller\n");
 586                 return rc;
 587         }
 588 
 589         rc = devm_request_any_context_irq(&pdev->dev, kp->key_sense_irq,
 590                         pmic8xxx_kp_irq, IRQF_TRIGGER_RISING, "pmic-keypad",
 591                         kp);
 592         if (rc < 0) {
 593                 dev_err(&pdev->dev, "failed to request keypad sense irq\n");
 594                 return rc;
 595         }
 596 
 597         rc = devm_request_any_context_irq(&pdev->dev, kp->key_stuck_irq,
 598                         pmic8xxx_kp_stuck_irq, IRQF_TRIGGER_RISING,
 599                         "pmic-keypad-stuck", kp);
 600         if (rc < 0) {
 601                 dev_err(&pdev->dev, "failed to request keypad stuck irq\n");
 602                 return rc;
 603         }
 604 
 605         rc = regmap_read(kp->regmap, KEYP_CTRL, &ctrl_val);
 606         if (rc < 0) {
 607                 dev_err(&pdev->dev, "failed to read KEYP_CTRL register\n");
 608                 return rc;
 609         }
 610 
 611         kp->ctrl_reg = ctrl_val;
 612 
 613         rc = input_register_device(kp->input);
 614         if (rc < 0) {
 615                 dev_err(&pdev->dev, "unable to register keypad input device\n");
 616                 return rc;
 617         }
 618 
 619         device_init_wakeup(&pdev->dev, wakeup);
 620 
 621         return 0;
 622 }
 623 
 624 #ifdef CONFIG_PM_SLEEP
 625 static int pmic8xxx_kp_suspend(struct device *dev)
 626 {
 627         struct platform_device *pdev = to_platform_device(dev);
 628         struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
 629         struct input_dev *input_dev = kp->input;
 630 
 631         if (device_may_wakeup(dev)) {
 632                 enable_irq_wake(kp->key_sense_irq);
 633         } else {
 634                 mutex_lock(&input_dev->mutex);
 635 
 636                 if (input_dev->users)
 637                         pmic8xxx_kp_disable(kp);
 638 
 639                 mutex_unlock(&input_dev->mutex);
 640         }
 641 
 642         return 0;
 643 }
 644 
 645 static int pmic8xxx_kp_resume(struct device *dev)
 646 {
 647         struct platform_device *pdev = to_platform_device(dev);
 648         struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
 649         struct input_dev *input_dev = kp->input;
 650 
 651         if (device_may_wakeup(dev)) {
 652                 disable_irq_wake(kp->key_sense_irq);
 653         } else {
 654                 mutex_lock(&input_dev->mutex);
 655 
 656                 if (input_dev->users)
 657                         pmic8xxx_kp_enable(kp);
 658 
 659                 mutex_unlock(&input_dev->mutex);
 660         }
 661 
 662         return 0;
 663 }
 664 #endif
 665 
 666 static SIMPLE_DEV_PM_OPS(pm8xxx_kp_pm_ops,
 667                          pmic8xxx_kp_suspend, pmic8xxx_kp_resume);
 668 
 669 static const struct of_device_id pm8xxx_match_table[] = {
 670         { .compatible = "qcom,pm8058-keypad" },
 671         { .compatible = "qcom,pm8921-keypad" },
 672         { }
 673 };
 674 MODULE_DEVICE_TABLE(of, pm8xxx_match_table);
 675 
 676 static struct platform_driver pmic8xxx_kp_driver = {
 677         .probe          = pmic8xxx_kp_probe,
 678         .driver         = {
 679                 .name = "pm8xxx-keypad",
 680                 .pm = &pm8xxx_kp_pm_ops,
 681                 .of_match_table = pm8xxx_match_table,
 682         },
 683 };
 684 module_platform_driver(pmic8xxx_kp_driver);
 685 
 686 MODULE_LICENSE("GPL v2");
 687 MODULE_DESCRIPTION("PMIC8XXX keypad driver");
 688 MODULE_ALIAS("platform:pmic8xxx_keypad");
 689 MODULE_AUTHOR("Trilok Soni <tsoni@codeaurora.org>");