drivers/input/keyboard/pmic8xxx-keypad.c

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