13 #include <linux/module.h>
15 #include <linux/kernel.h>
17 #include <linux/slab.h>
18 #include <linux/input.h>
19 #include <linux/bitops.h>
24 #include <linux/mfd/pm8xxx/gpio.h>
27 #define PM8XXX_MAX_ROWS 18
28 #define PM8XXX_MAX_COLS 8
29 #define PM8XXX_ROW_SHIFT 3
30 #define PM8XXX_MATRIX_MAX_SIZE (PM8XXX_MAX_ROWS * PM8XXX_MAX_COLS)
32 #define PM8XXX_MIN_ROWS 5
33 #define PM8XXX_MIN_COLS 5
35 #define MAX_SCAN_DELAY 128
36 #define MIN_SCAN_DELAY 1
39 #define MAX_ROW_HOLD_DELAY 122000
40 #define MIN_ROW_HOLD_DELAY 30500
42 #define MAX_DEBOUNCE_TIME 20
43 #define MIN_DEBOUNCE_TIME 5
45 #define KEYP_CTRL 0x148
47 #define KEYP_CTRL_EVNTS BIT(0)
48 #define KEYP_CTRL_EVNTS_MASK 0x3
50 #define KEYP_CTRL_SCAN_COLS_SHIFT 5
51 #define KEYP_CTRL_SCAN_COLS_MIN 5
52 #define KEYP_CTRL_SCAN_COLS_BITS 0x3
54 #define KEYP_CTRL_SCAN_ROWS_SHIFT 2
55 #define KEYP_CTRL_SCAN_ROWS_MIN 5
56 #define KEYP_CTRL_SCAN_ROWS_BITS 0x7
58 #define KEYP_CTRL_KEYP_EN BIT(7)
60 #define KEYP_SCAN 0x149
62 #define KEYP_SCAN_READ_STATE BIT(0)
63 #define KEYP_SCAN_DBOUNCE_SHIFT 1
64 #define KEYP_SCAN_PAUSE_SHIFT 3
65 #define KEYP_SCAN_ROW_HOLD_SHIFT 6
67 #define KEYP_TEST 0x14A
69 #define KEYP_TEST_CLEAR_RECENT_SCAN BIT(6)
70 #define KEYP_TEST_CLEAR_OLD_SCAN BIT(5)
71 #define KEYP_TEST_READ_RESET BIT(4)
72 #define KEYP_TEST_DTEST_EN BIT(3)
73 #define KEYP_TEST_ABORT_READ BIT(0)
75 #define KEYP_TEST_DBG_SELECT_SHIFT 1
81 #define KEYP_RECENT_DATA 0x14B
82 #define KEYP_OLD_DATA 0x14C
84 #define KEYP_CLOCK_FREQ 32768
113 static int pmic8xxx_kp_write_u8(
struct pmic8xxx_kp *kp,
118 rc = pm8xxx_writeb(kp->
dev->parent, reg, data);
122 static int pmic8xxx_kp_read(
struct pmic8xxx_kp *kp,
127 rc = pm8xxx_read_buf(kp->
dev->parent, reg, data, num_bytes);
131 static int pmic8xxx_kp_read_u8(
struct pmic8xxx_kp *kp,
136 rc = pmic8xxx_kp_read(kp, data, reg, 1);
144 return 1 << kp->
pdata->num_cols;
146 return col & ((1 << kp->
pdata->num_cols) - 1);
161 static int pmic8xxx_chk_sync_read(
struct pmic8xxx_kp *kp)
166 rc = pmic8xxx_kp_read_u8(kp, &scan_val,
KEYP_SCAN);
168 dev_err(kp->
dev,
"Error reading KEYP_SCAN reg, rc=%d\n", rc);
174 rc = pmic8xxx_kp_write_u8(kp, scan_val,
KEYP_SCAN);
176 dev_err(kp->
dev,
"Error writing KEYP_SCAN reg, rc=%d\n", rc);
187 u16 data_reg,
int read_rows)
192 rc = pmic8xxx_kp_read(kp, new_data, data_reg, read_rows);
196 for (row = 0; row < kp->
pdata->num_rows; row++) {
199 state[row] = pmic8xxx_col_state(kp, new_data[row]);
214 read_rows = kp->
pdata->num_rows;
216 pmic8xxx_chk_sync_read(kp);
223 "Error reading KEYP_OLD_DATA, rc=%d\n", rc);
232 "Error reading KEYP_RECENT_DATA, rc=%d\n", rc);
239 rc = pmic8xxx_kp_read_u8(kp, &scan_val,
KEYP_SCAN);
241 dev_err(kp->
dev,
"Error reading KEYP_SCAN reg, rc=%d\n", rc);
246 rc = pmic8xxx_kp_write_u8(kp, scan_val,
KEYP_SCAN);
248 dev_err(kp->
dev,
"Error writing KEYP_SCAN reg, rc=%d\n", rc);
253 static void __pmic8xxx_kp_scan_matrix(
struct pmic8xxx_kp *kp,
u16 *new_state,
258 for (row = 0; row < kp->
pdata->num_rows; row++) {
259 int bits_changed = new_state[row] ^ old_state[row];
264 for (col = 0; col < kp->
pdata->num_cols; col++) {
265 if (!(bits_changed & (1 << col)))
268 dev_dbg(kp->
dev,
"key [%d:%d] %s\n", row, col,
269 !(new_state[row] & (1 << col)) ?
270 "pressed" :
"released");
275 input_report_key(kp->
input,
277 !(new_state[row] & (1 << col)));
279 input_sync(kp->
input);
284 static bool pmic8xxx_detect_ghost_keys(
struct pmic8xxx_kp *kp,
u16 *new_state)
286 int row, found_first = -1;
290 for (row = 0; row < kp->
pdata->num_rows; row++) {
291 row_state = (~new_state[row]) &
292 ((1 << kp->
pdata->num_cols) - 1);
295 if (found_first == -1)
297 if (check & row_state) {
298 dev_dbg(kp->
dev,
"detected ghost key on row[%d]"
299 " and row[%d]\n", found_first, row);
316 rc = pmic8xxx_kp_read_matrix(kp, new_state,
NULL);
321 if (pmic8xxx_detect_ghost_keys(kp, new_state))
323 __pmic8xxx_kp_scan_matrix(kp, new_state, kp->
keystate);
327 rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
331 __pmic8xxx_kp_scan_matrix(kp, old_state, kp->
keystate);
332 __pmic8xxx_kp_scan_matrix(kp, new_state, old_state);
336 dev_dbg(kp->
dev,
"Some key events were lost\n");
337 rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
340 __pmic8xxx_kp_scan_matrix(kp, old_state, kp->
keystate);
341 __pmic8xxx_kp_scan_matrix(kp, new_state, old_state);
368 rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
370 dev_err(kp->
dev,
"failed to read keypad matrix\n");
374 __pmic8xxx_kp_scan_matrix(kp, new_state, kp->
stuckstate);
379 static irqreturn_t pmic8xxx_kp_irq(
int irq,
void *data)
385 rc = pmic8xxx_kp_read(kp, &ctrl_val,
KEYP_CTRL, 1);
387 dev_err(kp->
dev,
"failed to read keyp_ctrl register\n");
393 rc = pmic8xxx_kp_scan_matrix(kp, events);
403 u8 scan_val = 0, ctrl_val = 0;
404 static const u8 row_bits[] = {
405 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 7, 7, 7,
424 rc = pmic8xxx_kp_write_u8(kp, ctrl_val,
KEYP_CTRL);
426 dev_err(kp->
dev,
"Error writing KEYP_CTRL reg, rc=%d\n", rc);
430 bits = (kp->
pdata->debounce_ms / 5) - 1;
434 bits = fls(kp->
pdata->scan_delay_ms) - 1;
442 rc = pmic8xxx_kp_write_u8(kp, scan_val,
KEYP_SCAN);
444 dev_err(kp->
dev,
"Error writing KEYP_SCAN reg, rc=%d\n", rc);
450 static int __devinit pmic8xxx_kp_config_gpio(
int gpio_start,
int num_gpios,
451 struct pmic8xxx_kp *kp,
struct pm_gpio *gpio_config)
455 if (gpio_start < 0 || num_gpios < 0)
458 for (i = 0; i < num_gpios; i++) {
459 rc = pm8xxx_gpio_config(gpio_start + i, gpio_config);
461 dev_err(kp->
dev,
"%s: FAIL pm8xxx_gpio_config():"
462 "for PM GPIO [%d] rc=%d.\n",
463 __func__, gpio_start + i, rc);
471 static int pmic8xxx_kp_enable(
struct pmic8xxx_kp *kp)
479 dev_err(kp->
dev,
"Error writing KEYP_CTRL reg, rc=%d\n", rc);
484 static int pmic8xxx_kp_disable(
struct pmic8xxx_kp *kp)
497 static int pmic8xxx_kp_open(
struct input_dev *
dev)
501 return pmic8xxx_kp_enable(kp);
504 static void pmic8xxx_kp_close(
struct input_dev *
dev)
508 pmic8xxx_kp_disable(kp);
524 dev_get_platdata(&pdev->
dev);
530 struct pm_gpio kypd_drv = {
531 .direction = PM_GPIO_DIR_OUT,
532 .output_buffer = PM_GPIO_OUT_BUF_OPEN_DRAIN,
534 .pull = PM_GPIO_PULL_NO,
535 .vin_sel = PM_GPIO_VIN_S3,
536 .out_strength = PM_GPIO_STRENGTH_LOW,
537 .function = PM_GPIO_FUNC_1,
541 struct pm_gpio kypd_sns = {
542 .direction = PM_GPIO_DIR_IN,
543 .pull = PM_GPIO_PULL_UP_31P5,
544 .vin_sel = PM_GPIO_VIN_S3,
545 .out_strength = PM_GPIO_STRENGTH_NO,
546 .function = PM_GPIO_FUNC_NORMAL,
555 dev_err(&pdev->
dev,
"invalid platform data\n");
563 dev_err(&pdev->
dev,
"invalid keypad scan time supplied\n");
571 dev_err(&pdev->
dev,
"invalid keypad row hold time supplied\n");
579 dev_err(&pdev->
dev,
"invalid debounce time supplied\n");
585 dev_err(&pdev->
dev,
"no keymap data supplied\n");
593 platform_set_drvdata(pdev, kp);
598 kp->
input = input_allocate_device();
600 dev_err(&pdev->
dev,
"unable to allocate input device\n");
602 goto err_alloc_device;
607 dev_err(&pdev->
dev,
"unable to get keypad sense irq\n");
614 dev_err(&pdev->
dev,
"unable to get keypad stuck irq\n");
625 kp->
input->id.version = 0x0001;
626 kp->
input->id.product = 0x0001;
627 kp->
input->id.vendor = 0x0001;
629 kp->
input->open = pmic8xxx_kp_open;
630 kp->
input->close = pmic8xxx_kp_close;
636 dev_err(&pdev->
dev,
"failed to build keymap\n");
644 input_set_drvdata(kp->
input, kp);
650 rc = pmic8xxx_kpd_init(kp);
652 dev_err(&pdev->
dev,
"unable to initialize keypad controller\n");
659 dev_err(&pdev->
dev,
"unable to configure keypad sense lines\n");
660 goto err_gpio_config;
666 dev_err(&pdev->
dev,
"unable to configure keypad drive lines\n");
667 goto err_gpio_config;
673 dev_err(&pdev->
dev,
"failed to request keypad sense irq\n");
680 dev_err(&pdev->
dev,
"failed to request keypad stuck irq\n");
681 goto err_req_stuck_irq;
684 rc = pmic8xxx_kp_read_u8(kp, &ctrl_val,
KEYP_CTRL);
686 dev_err(&pdev->
dev,
"failed to read KEYP_CTRL register\n");
687 goto err_pmic_reg_read;
692 rc = input_register_device(kp->
input);
694 dev_err(&pdev->
dev,
"unable to register keypad input device\n");
695 goto err_pmic_reg_read;
708 input_free_device(kp->
input);
710 platform_set_drvdata(pdev,
NULL);
717 struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
722 input_unregister_device(kp->
input);
725 platform_set_drvdata(pdev,
NULL);
729 #ifdef CONFIG_PM_SLEEP
730 static int pmic8xxx_kp_suspend(
struct device *
dev)
733 struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
734 struct input_dev *input_dev = kp->
input;
736 if (device_may_wakeup(dev)) {
741 if (input_dev->users)
742 pmic8xxx_kp_disable(kp);
750 static int pmic8xxx_kp_resume(
struct device *dev)
753 struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
754 struct input_dev *input_dev = kp->
input;
756 if (device_may_wakeup(dev)) {
761 if (input_dev->users)
762 pmic8xxx_kp_enable(kp);
772 pmic8xxx_kp_suspend, pmic8xxx_kp_resume);
775 .probe = pmic8xxx_kp_probe,
780 .pm = &pm8xxx_kp_pm_ops,