Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* Copyright (c) 2009-2011, Code Aurora Forum. All rights reserved.
0003  */
0004 
0005 #include <linux/module.h>
0006 #include <linux/platform_device.h>
0007 #include <linux/kernel.h>
0008 #include <linux/interrupt.h>
0009 #include <linux/slab.h>
0010 #include <linux/input.h>
0011 #include <linux/bitops.h>
0012 #include <linux/delay.h>
0013 #include <linux/mutex.h>
0014 #include <linux/regmap.h>
0015 #include <linux/of.h>
0016 #include <linux/input/matrix_keypad.h>
0017 
0018 #define PM8XXX_MAX_ROWS     18
0019 #define PM8XXX_MAX_COLS     8
0020 #define PM8XXX_ROW_SHIFT    3
0021 #define PM8XXX_MATRIX_MAX_SIZE  (PM8XXX_MAX_ROWS * PM8XXX_MAX_COLS)
0022 
0023 #define PM8XXX_MIN_ROWS     5
0024 #define PM8XXX_MIN_COLS     5
0025 
0026 #define MAX_SCAN_DELAY      128
0027 #define MIN_SCAN_DELAY      1
0028 
0029 /* in nanoseconds */
0030 #define MAX_ROW_HOLD_DELAY  122000
0031 #define MIN_ROW_HOLD_DELAY  30500
0032 
0033 #define MAX_DEBOUNCE_TIME   20
0034 #define MIN_DEBOUNCE_TIME   5
0035 
0036 #define KEYP_CTRL           0x148
0037 
0038 #define KEYP_CTRL_EVNTS         BIT(0)
0039 #define KEYP_CTRL_EVNTS_MASK        0x3
0040 
0041 #define KEYP_CTRL_SCAN_COLS_SHIFT   5
0042 #define KEYP_CTRL_SCAN_COLS_MIN     5
0043 #define KEYP_CTRL_SCAN_COLS_BITS    0x3
0044 
0045 #define KEYP_CTRL_SCAN_ROWS_SHIFT   2
0046 #define KEYP_CTRL_SCAN_ROWS_MIN     5
0047 #define KEYP_CTRL_SCAN_ROWS_BITS    0x7
0048 
0049 #define KEYP_CTRL_KEYP_EN       BIT(7)
0050 
0051 #define KEYP_SCAN           0x149
0052 
0053 #define KEYP_SCAN_READ_STATE        BIT(0)
0054 #define KEYP_SCAN_DBOUNCE_SHIFT     1
0055 #define KEYP_SCAN_PAUSE_SHIFT       3
0056 #define KEYP_SCAN_ROW_HOLD_SHIFT    6
0057 
0058 #define KEYP_TEST           0x14A
0059 
0060 #define KEYP_TEST_CLEAR_RECENT_SCAN BIT(6)
0061 #define KEYP_TEST_CLEAR_OLD_SCAN    BIT(5)
0062 #define KEYP_TEST_READ_RESET        BIT(4)
0063 #define KEYP_TEST_DTEST_EN      BIT(3)
0064 #define KEYP_TEST_ABORT_READ        BIT(0)
0065 
0066 #define KEYP_TEST_DBG_SELECT_SHIFT  1
0067 
0068 /* bits of these registers represent
0069  * '0' for key press
0070  * '1' for key release
0071  */
0072 #define KEYP_RECENT_DATA        0x14B
0073 #define KEYP_OLD_DATA           0x14C
0074 
0075 #define KEYP_CLOCK_FREQ         32768
0076 
0077 /**
0078  * struct pmic8xxx_kp - internal keypad data structure
0079  * @num_cols: number of columns of keypad
0080  * @num_rows: number of row of keypad
0081  * @input: input device pointer for keypad
0082  * @regmap: regmap handle
0083  * @key_sense_irq: key press/release irq number
0084  * @key_stuck_irq: key stuck notification irq number
0085  * @keycodes: array to hold the key codes
0086  * @dev: parent device pointer
0087  * @keystate: present key press/release state
0088  * @stuckstate: present state when key stuck irq
0089  * @ctrl_reg: control register value
0090  */
0091 struct pmic8xxx_kp {
0092     unsigned int num_rows;
0093     unsigned int num_cols;
0094     struct input_dev *input;
0095     struct regmap *regmap;
0096     int key_sense_irq;
0097     int key_stuck_irq;
0098 
0099     unsigned short keycodes[PM8XXX_MATRIX_MAX_SIZE];
0100 
0101     struct device *dev;
0102     u16 keystate[PM8XXX_MAX_ROWS];
0103     u16 stuckstate[PM8XXX_MAX_ROWS];
0104 
0105     u8 ctrl_reg;
0106 };
0107 
0108 static u8 pmic8xxx_col_state(struct pmic8xxx_kp *kp, u8 col)
0109 {
0110     /* all keys pressed on that particular row? */
0111     if (col == 0x00)
0112         return 1 << kp->num_cols;
0113     else
0114         return col & ((1 << kp->num_cols) - 1);
0115 }
0116 
0117 /*
0118  * Synchronous read protocol for RevB0 onwards:
0119  *
0120  * 1. Write '1' to ReadState bit in KEYP_SCAN register
0121  * 2. Wait 2*32KHz clocks, so that HW can successfully enter read mode
0122  *    synchronously
0123  * 3. Read rows in old array first if events are more than one
0124  * 4. Read rows in recent array
0125  * 5. Wait 4*32KHz clocks
0126  * 6. Write '0' to ReadState bit of KEYP_SCAN register so that hw can
0127  *    synchronously exit read mode.
0128  */
0129 static int pmic8xxx_chk_sync_read(struct pmic8xxx_kp *kp)
0130 {
0131     int rc;
0132     unsigned int scan_val;
0133 
0134     rc = regmap_read(kp->regmap, KEYP_SCAN, &scan_val);
0135     if (rc < 0) {
0136         dev_err(kp->dev, "Error reading KEYP_SCAN reg, rc=%d\n", rc);
0137         return rc;
0138     }
0139 
0140     scan_val |= 0x1;
0141 
0142     rc = regmap_write(kp->regmap, KEYP_SCAN, scan_val);
0143     if (rc < 0) {
0144         dev_err(kp->dev, "Error writing KEYP_SCAN reg, rc=%d\n", rc);
0145         return rc;
0146     }
0147 
0148     /* 2 * 32KHz clocks */
0149     udelay((2 * DIV_ROUND_UP(USEC_PER_SEC, KEYP_CLOCK_FREQ)) + 1);
0150 
0151     return rc;
0152 }
0153 
0154 static int pmic8xxx_kp_read_data(struct pmic8xxx_kp *kp, u16 *state,
0155                     u16 data_reg, int read_rows)
0156 {
0157     int rc, row;
0158     unsigned int val;
0159 
0160     for (row = 0; row < read_rows; row++) {
0161         rc = regmap_read(kp->regmap, data_reg, &val);
0162         if (rc)
0163             return rc;
0164         dev_dbg(kp->dev, "%d = %d\n", row, val);
0165         state[row] = pmic8xxx_col_state(kp, val);
0166     }
0167 
0168     return 0;
0169 }
0170 
0171 static int pmic8xxx_kp_read_matrix(struct pmic8xxx_kp *kp, u16 *new_state,
0172                      u16 *old_state)
0173 {
0174     int rc, read_rows;
0175     unsigned int scan_val;
0176 
0177     if (kp->num_rows < PM8XXX_MIN_ROWS)
0178         read_rows = PM8XXX_MIN_ROWS;
0179     else
0180         read_rows = kp->num_rows;
0181 
0182     pmic8xxx_chk_sync_read(kp);
0183 
0184     if (old_state) {
0185         rc = pmic8xxx_kp_read_data(kp, old_state, KEYP_OLD_DATA,
0186                         read_rows);
0187         if (rc < 0) {
0188             dev_err(kp->dev,
0189                 "Error reading KEYP_OLD_DATA, rc=%d\n", rc);
0190             return rc;
0191         }
0192     }
0193 
0194     rc = pmic8xxx_kp_read_data(kp, new_state, KEYP_RECENT_DATA,
0195                      read_rows);
0196     if (rc < 0) {
0197         dev_err(kp->dev,
0198             "Error reading KEYP_RECENT_DATA, rc=%d\n", rc);
0199         return rc;
0200     }
0201 
0202     /* 4 * 32KHz clocks */
0203     udelay((4 * DIV_ROUND_UP(USEC_PER_SEC, KEYP_CLOCK_FREQ)) + 1);
0204 
0205     rc = regmap_read(kp->regmap, KEYP_SCAN, &scan_val);
0206     if (rc < 0) {
0207         dev_err(kp->dev, "Error reading KEYP_SCAN reg, rc=%d\n", rc);
0208         return rc;
0209     }
0210 
0211     scan_val &= 0xFE;
0212     rc = regmap_write(kp->regmap, KEYP_SCAN, scan_val);
0213     if (rc < 0)
0214         dev_err(kp->dev, "Error writing KEYP_SCAN reg, rc=%d\n", rc);
0215 
0216     return rc;
0217 }
0218 
0219 static void __pmic8xxx_kp_scan_matrix(struct pmic8xxx_kp *kp, u16 *new_state,
0220                      u16 *old_state)
0221 {
0222     int row, col, code;
0223 
0224     for (row = 0; row < kp->num_rows; row++) {
0225         int bits_changed = new_state[row] ^ old_state[row];
0226 
0227         if (!bits_changed)
0228             continue;
0229 
0230         for (col = 0; col < kp->num_cols; col++) {
0231             if (!(bits_changed & (1 << col)))
0232                 continue;
0233 
0234             dev_dbg(kp->dev, "key [%d:%d] %s\n", row, col,
0235                     !(new_state[row] & (1 << col)) ?
0236                     "pressed" : "released");
0237 
0238             code = MATRIX_SCAN_CODE(row, col, PM8XXX_ROW_SHIFT);
0239 
0240             input_event(kp->input, EV_MSC, MSC_SCAN, code);
0241             input_report_key(kp->input,
0242                     kp->keycodes[code],
0243                     !(new_state[row] & (1 << col)));
0244 
0245             input_sync(kp->input);
0246         }
0247     }
0248 }
0249 
0250 static bool pmic8xxx_detect_ghost_keys(struct pmic8xxx_kp *kp, u16 *new_state)
0251 {
0252     int row, found_first = -1;
0253     u16 check, row_state;
0254 
0255     check = 0;
0256     for (row = 0; row < kp->num_rows; row++) {
0257         row_state = (~new_state[row]) &
0258                  ((1 << kp->num_cols) - 1);
0259 
0260         if (hweight16(row_state) > 1) {
0261             if (found_first == -1)
0262                 found_first = row;
0263             if (check & row_state) {
0264                 dev_dbg(kp->dev, "detected ghost key on row[%d]"
0265                      " and row[%d]\n", found_first, row);
0266                 return true;
0267             }
0268         }
0269         check |= row_state;
0270     }
0271     return false;
0272 }
0273 
0274 static int pmic8xxx_kp_scan_matrix(struct pmic8xxx_kp *kp, unsigned int events)
0275 {
0276     u16 new_state[PM8XXX_MAX_ROWS];
0277     u16 old_state[PM8XXX_MAX_ROWS];
0278     int rc;
0279 
0280     switch (events) {
0281     case 0x1:
0282         rc = pmic8xxx_kp_read_matrix(kp, new_state, NULL);
0283         if (rc < 0)
0284             return rc;
0285 
0286         /* detecting ghost key is not an error */
0287         if (pmic8xxx_detect_ghost_keys(kp, new_state))
0288             return 0;
0289         __pmic8xxx_kp_scan_matrix(kp, new_state, kp->keystate);
0290         memcpy(kp->keystate, new_state, sizeof(new_state));
0291     break;
0292     case 0x3: /* two events - eventcounter is gray-coded */
0293         rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
0294         if (rc < 0)
0295             return rc;
0296 
0297         __pmic8xxx_kp_scan_matrix(kp, old_state, kp->keystate);
0298         __pmic8xxx_kp_scan_matrix(kp, new_state, old_state);
0299         memcpy(kp->keystate, new_state, sizeof(new_state));
0300     break;
0301     case 0x2:
0302         dev_dbg(kp->dev, "Some key events were lost\n");
0303         rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
0304         if (rc < 0)
0305             return rc;
0306         __pmic8xxx_kp_scan_matrix(kp, old_state, kp->keystate);
0307         __pmic8xxx_kp_scan_matrix(kp, new_state, old_state);
0308         memcpy(kp->keystate, new_state, sizeof(new_state));
0309     break;
0310     default:
0311         rc = -EINVAL;
0312     }
0313     return rc;
0314 }
0315 
0316 /*
0317  * NOTE: We are reading recent and old data registers blindly
0318  * whenever key-stuck interrupt happens, because events counter doesn't
0319  * get updated when this interrupt happens due to key stuck doesn't get
0320  * considered as key state change.
0321  *
0322  * We are not using old data register contents after they are being read
0323  * because it might report the key which was pressed before the key being stuck
0324  * as stuck key because it's pressed status is stored in the old data
0325  * register.
0326  */
0327 static irqreturn_t pmic8xxx_kp_stuck_irq(int irq, void *data)
0328 {
0329     u16 new_state[PM8XXX_MAX_ROWS];
0330     u16 old_state[PM8XXX_MAX_ROWS];
0331     int rc;
0332     struct pmic8xxx_kp *kp = data;
0333 
0334     rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
0335     if (rc < 0) {
0336         dev_err(kp->dev, "failed to read keypad matrix\n");
0337         return IRQ_HANDLED;
0338     }
0339 
0340     __pmic8xxx_kp_scan_matrix(kp, new_state, kp->stuckstate);
0341 
0342     return IRQ_HANDLED;
0343 }
0344 
0345 static irqreturn_t pmic8xxx_kp_irq(int irq, void *data)
0346 {
0347     struct pmic8xxx_kp *kp = data;
0348     unsigned int ctrl_val, events;
0349     int rc;
0350 
0351     rc = regmap_read(kp->regmap, KEYP_CTRL, &ctrl_val);
0352     if (rc < 0) {
0353         dev_err(kp->dev, "failed to read keyp_ctrl register\n");
0354         return IRQ_HANDLED;
0355     }
0356 
0357     events = ctrl_val & KEYP_CTRL_EVNTS_MASK;
0358 
0359     rc = pmic8xxx_kp_scan_matrix(kp, events);
0360     if (rc < 0)
0361         dev_err(kp->dev, "failed to scan matrix\n");
0362 
0363     return IRQ_HANDLED;
0364 }
0365 
0366 static int pmic8xxx_kpd_init(struct pmic8xxx_kp *kp,
0367                  struct platform_device *pdev)
0368 {
0369     const struct device_node *of_node = pdev->dev.of_node;
0370     unsigned int scan_delay_ms;
0371     unsigned int row_hold_ns;
0372     unsigned int debounce_ms;
0373     int bits, rc, cycles;
0374     u8 scan_val = 0, ctrl_val = 0;
0375     static const u8 row_bits[] = {
0376         0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 7, 7, 7,
0377     };
0378 
0379     /* Find column bits */
0380     if (kp->num_cols < KEYP_CTRL_SCAN_COLS_MIN)
0381         bits = 0;
0382     else
0383         bits = kp->num_cols - KEYP_CTRL_SCAN_COLS_MIN;
0384     ctrl_val = (bits & KEYP_CTRL_SCAN_COLS_BITS) <<
0385         KEYP_CTRL_SCAN_COLS_SHIFT;
0386 
0387     /* Find row bits */
0388     if (kp->num_rows < KEYP_CTRL_SCAN_ROWS_MIN)
0389         bits = 0;
0390     else
0391         bits = row_bits[kp->num_rows - KEYP_CTRL_SCAN_ROWS_MIN];
0392 
0393     ctrl_val |= (bits << KEYP_CTRL_SCAN_ROWS_SHIFT);
0394 
0395     rc = regmap_write(kp->regmap, KEYP_CTRL, ctrl_val);
0396     if (rc < 0) {
0397         dev_err(kp->dev, "Error writing KEYP_CTRL reg, rc=%d\n", rc);
0398         return rc;
0399     }
0400 
0401     if (of_property_read_u32(of_node, "scan-delay", &scan_delay_ms))
0402         scan_delay_ms = MIN_SCAN_DELAY;
0403 
0404     if (scan_delay_ms > MAX_SCAN_DELAY || scan_delay_ms < MIN_SCAN_DELAY ||
0405         !is_power_of_2(scan_delay_ms)) {
0406         dev_err(&pdev->dev, "invalid keypad scan time supplied\n");
0407         return -EINVAL;
0408     }
0409 
0410     if (of_property_read_u32(of_node, "row-hold", &row_hold_ns))
0411         row_hold_ns = MIN_ROW_HOLD_DELAY;
0412 
0413     if (row_hold_ns > MAX_ROW_HOLD_DELAY ||
0414         row_hold_ns < MIN_ROW_HOLD_DELAY ||
0415         ((row_hold_ns % MIN_ROW_HOLD_DELAY) != 0)) {
0416         dev_err(&pdev->dev, "invalid keypad row hold time supplied\n");
0417         return -EINVAL;
0418     }
0419 
0420     if (of_property_read_u32(of_node, "debounce", &debounce_ms))
0421         debounce_ms = MIN_DEBOUNCE_TIME;
0422 
0423     if (((debounce_ms % 5) != 0) ||
0424         debounce_ms > MAX_DEBOUNCE_TIME ||
0425         debounce_ms < MIN_DEBOUNCE_TIME) {
0426         dev_err(&pdev->dev, "invalid debounce time supplied\n");
0427         return -EINVAL;
0428     }
0429 
0430     bits = (debounce_ms / 5) - 1;
0431 
0432     scan_val |= (bits << KEYP_SCAN_DBOUNCE_SHIFT);
0433 
0434     bits = fls(scan_delay_ms) - 1;
0435     scan_val |= (bits << KEYP_SCAN_PAUSE_SHIFT);
0436 
0437     /* Row hold time is a multiple of 32KHz cycles. */
0438     cycles = (row_hold_ns * KEYP_CLOCK_FREQ) / NSEC_PER_SEC;
0439 
0440     scan_val |= (cycles << KEYP_SCAN_ROW_HOLD_SHIFT);
0441 
0442     rc = regmap_write(kp->regmap, KEYP_SCAN, scan_val);
0443     if (rc)
0444         dev_err(kp->dev, "Error writing KEYP_SCAN reg, rc=%d\n", rc);
0445 
0446     return rc;
0447 
0448 }
0449 
0450 static int pmic8xxx_kp_enable(struct pmic8xxx_kp *kp)
0451 {
0452     int rc;
0453 
0454     kp->ctrl_reg |= KEYP_CTRL_KEYP_EN;
0455 
0456     rc = regmap_write(kp->regmap, KEYP_CTRL, kp->ctrl_reg);
0457     if (rc < 0)
0458         dev_err(kp->dev, "Error writing KEYP_CTRL reg, rc=%d\n", rc);
0459 
0460     return rc;
0461 }
0462 
0463 static int pmic8xxx_kp_disable(struct pmic8xxx_kp *kp)
0464 {
0465     int rc;
0466 
0467     kp->ctrl_reg &= ~KEYP_CTRL_KEYP_EN;
0468 
0469     rc = regmap_write(kp->regmap, KEYP_CTRL, kp->ctrl_reg);
0470     if (rc < 0)
0471         return rc;
0472 
0473     return rc;
0474 }
0475 
0476 static int pmic8xxx_kp_open(struct input_dev *dev)
0477 {
0478     struct pmic8xxx_kp *kp = input_get_drvdata(dev);
0479 
0480     return pmic8xxx_kp_enable(kp);
0481 }
0482 
0483 static void pmic8xxx_kp_close(struct input_dev *dev)
0484 {
0485     struct pmic8xxx_kp *kp = input_get_drvdata(dev);
0486 
0487     pmic8xxx_kp_disable(kp);
0488 }
0489 
0490 /*
0491  * keypad controller should be initialized in the following sequence
0492  * only, otherwise it might get into FSM stuck state.
0493  *
0494  * - Initialize keypad control parameters, like no. of rows, columns,
0495  *   timing values etc.,
0496  * - configure rows and column gpios pull up/down.
0497  * - set irq edge type.
0498  * - enable the keypad controller.
0499  */
0500 static int pmic8xxx_kp_probe(struct platform_device *pdev)
0501 {
0502     struct device_node *np = pdev->dev.of_node;
0503     unsigned int rows, cols;
0504     bool repeat;
0505     bool wakeup;
0506     struct pmic8xxx_kp *kp;
0507     int rc;
0508     unsigned int ctrl_val;
0509 
0510     rc = matrix_keypad_parse_properties(&pdev->dev, &rows, &cols);
0511     if (rc)
0512         return rc;
0513 
0514     if (cols > PM8XXX_MAX_COLS || rows > PM8XXX_MAX_ROWS ||
0515         cols < PM8XXX_MIN_COLS) {
0516         dev_err(&pdev->dev, "invalid platform data\n");
0517         return -EINVAL;
0518     }
0519 
0520     repeat = !of_property_read_bool(np, "linux,input-no-autorepeat");
0521 
0522     wakeup = of_property_read_bool(np, "wakeup-source") ||
0523          /* legacy name */
0524          of_property_read_bool(np, "linux,keypad-wakeup");
0525 
0526     kp = devm_kzalloc(&pdev->dev, sizeof(*kp), GFP_KERNEL);
0527     if (!kp)
0528         return -ENOMEM;
0529 
0530     kp->regmap = dev_get_regmap(pdev->dev.parent, NULL);
0531     if (!kp->regmap)
0532         return -ENODEV;
0533 
0534     platform_set_drvdata(pdev, kp);
0535 
0536     kp->num_rows    = rows;
0537     kp->num_cols    = cols;
0538     kp->dev     = &pdev->dev;
0539 
0540     kp->input = devm_input_allocate_device(&pdev->dev);
0541     if (!kp->input) {
0542         dev_err(&pdev->dev, "unable to allocate input device\n");
0543         return -ENOMEM;
0544     }
0545 
0546     kp->key_sense_irq = platform_get_irq(pdev, 0);
0547     if (kp->key_sense_irq < 0)
0548         return kp->key_sense_irq;
0549 
0550     kp->key_stuck_irq = platform_get_irq(pdev, 1);
0551     if (kp->key_stuck_irq < 0)
0552         return kp->key_stuck_irq;
0553 
0554     kp->input->name = "PMIC8XXX keypad";
0555     kp->input->phys = "pmic8xxx_keypad/input0";
0556 
0557     kp->input->id.bustype   = BUS_I2C;
0558     kp->input->id.version   = 0x0001;
0559     kp->input->id.product   = 0x0001;
0560     kp->input->id.vendor    = 0x0001;
0561 
0562     kp->input->open     = pmic8xxx_kp_open;
0563     kp->input->close    = pmic8xxx_kp_close;
0564 
0565     rc = matrix_keypad_build_keymap(NULL, NULL,
0566                     PM8XXX_MAX_ROWS, PM8XXX_MAX_COLS,
0567                     kp->keycodes, kp->input);
0568     if (rc) {
0569         dev_err(&pdev->dev, "failed to build keymap\n");
0570         return rc;
0571     }
0572 
0573     if (repeat)
0574         __set_bit(EV_REP, kp->input->evbit);
0575     input_set_capability(kp->input, EV_MSC, MSC_SCAN);
0576 
0577     input_set_drvdata(kp->input, kp);
0578 
0579     /* initialize keypad state */
0580     memset(kp->keystate, 0xff, sizeof(kp->keystate));
0581     memset(kp->stuckstate, 0xff, sizeof(kp->stuckstate));
0582 
0583     rc = pmic8xxx_kpd_init(kp, pdev);
0584     if (rc < 0) {
0585         dev_err(&pdev->dev, "unable to initialize keypad controller\n");
0586         return rc;
0587     }
0588 
0589     rc = devm_request_any_context_irq(&pdev->dev, kp->key_sense_irq,
0590             pmic8xxx_kp_irq, IRQF_TRIGGER_RISING, "pmic-keypad",
0591             kp);
0592     if (rc < 0) {
0593         dev_err(&pdev->dev, "failed to request keypad sense irq\n");
0594         return rc;
0595     }
0596 
0597     rc = devm_request_any_context_irq(&pdev->dev, kp->key_stuck_irq,
0598             pmic8xxx_kp_stuck_irq, IRQF_TRIGGER_RISING,
0599             "pmic-keypad-stuck", kp);
0600     if (rc < 0) {
0601         dev_err(&pdev->dev, "failed to request keypad stuck irq\n");
0602         return rc;
0603     }
0604 
0605     rc = regmap_read(kp->regmap, KEYP_CTRL, &ctrl_val);
0606     if (rc < 0) {
0607         dev_err(&pdev->dev, "failed to read KEYP_CTRL register\n");
0608         return rc;
0609     }
0610 
0611     kp->ctrl_reg = ctrl_val;
0612 
0613     rc = input_register_device(kp->input);
0614     if (rc < 0) {
0615         dev_err(&pdev->dev, "unable to register keypad input device\n");
0616         return rc;
0617     }
0618 
0619     device_init_wakeup(&pdev->dev, wakeup);
0620 
0621     return 0;
0622 }
0623 
0624 #ifdef CONFIG_PM_SLEEP
0625 static int pmic8xxx_kp_suspend(struct device *dev)
0626 {
0627     struct platform_device *pdev = to_platform_device(dev);
0628     struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
0629     struct input_dev *input_dev = kp->input;
0630 
0631     if (device_may_wakeup(dev)) {
0632         enable_irq_wake(kp->key_sense_irq);
0633     } else {
0634         mutex_lock(&input_dev->mutex);
0635 
0636         if (input_device_enabled(input_dev))
0637             pmic8xxx_kp_disable(kp);
0638 
0639         mutex_unlock(&input_dev->mutex);
0640     }
0641 
0642     return 0;
0643 }
0644 
0645 static int pmic8xxx_kp_resume(struct device *dev)
0646 {
0647     struct platform_device *pdev = to_platform_device(dev);
0648     struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
0649     struct input_dev *input_dev = kp->input;
0650 
0651     if (device_may_wakeup(dev)) {
0652         disable_irq_wake(kp->key_sense_irq);
0653     } else {
0654         mutex_lock(&input_dev->mutex);
0655 
0656         if (input_device_enabled(input_dev))
0657             pmic8xxx_kp_enable(kp);
0658 
0659         mutex_unlock(&input_dev->mutex);
0660     }
0661 
0662     return 0;
0663 }
0664 #endif
0665 
0666 static SIMPLE_DEV_PM_OPS(pm8xxx_kp_pm_ops,
0667              pmic8xxx_kp_suspend, pmic8xxx_kp_resume);
0668 
0669 static const struct of_device_id pm8xxx_match_table[] = {
0670     { .compatible = "qcom,pm8058-keypad" },
0671     { .compatible = "qcom,pm8921-keypad" },
0672     { }
0673 };
0674 MODULE_DEVICE_TABLE(of, pm8xxx_match_table);
0675 
0676 static struct platform_driver pmic8xxx_kp_driver = {
0677     .probe      = pmic8xxx_kp_probe,
0678     .driver     = {
0679         .name = "pm8xxx-keypad",
0680         .pm = &pm8xxx_kp_pm_ops,
0681         .of_match_table = pm8xxx_match_table,
0682     },
0683 };
0684 module_platform_driver(pmic8xxx_kp_driver);
0685 
0686 MODULE_LICENSE("GPL v2");
0687 MODULE_DESCRIPTION("PMIC8XXX keypad driver");
0688 MODULE_ALIAS("platform:pmic8xxx_keypad");
0689 MODULE_AUTHOR("Trilok Soni <tsoni@codeaurora.org>");
[ 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!