input/keyboard/bcm-keypad.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 // Copyright (C) 2014 Broadcom Corporation
0003
0004 #include <linux/bitops.h>
0005 #include <linux/clk.h>
0006 #include <linux/gfp.h>
0007 #include <linux/io.h>
0008 #include <linux/input.h>
0009 #include <linux/input/matrix_keypad.h>
0010 #include <linux/interrupt.h>
0011 #include <linux/module.h>
0012 #include <linux/of.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/stddef.h>
0015 #include <linux/types.h>
0016
0017 #define DEFAULT_CLK_HZ          31250
0018 #define MAX_ROWS            8
0019 #define MAX_COLS            8
0020
0021 /* Register/field definitions */
0022 #define KPCR_OFFSET         0x00000080
0023 #define KPCR_MODE           0x00000002
0024 #define KPCR_MODE_SHIFT         1
0025 #define KPCR_MODE_MASK          1
0026 #define KPCR_ENABLE         0x00000001
0027 #define KPCR_STATUSFILTERENABLE     0x00008000
0028 #define KPCR_STATUSFILTERTYPE_SHIFT 12
0029 #define KPCR_COLFILTERENABLE        0x00000800
0030 #define KPCR_COLFILTERTYPE_SHIFT    8
0031 #define KPCR_ROWWIDTH_SHIFT     20
0032 #define KPCR_COLUMNWIDTH_SHIFT      16
0033
0034 #define KPIOR_OFFSET            0x00000084
0035 #define KPIOR_ROWOCONTRL_SHIFT      24
0036 #define KPIOR_ROWOCONTRL_MASK       0xFF000000
0037 #define KPIOR_COLUMNOCONTRL_SHIFT   16
0038 #define KPIOR_COLUMNOCONTRL_MASK    0x00FF0000
0039 #define KPIOR_COLUMN_IO_DATA_SHIFT  0
0040
0041 #define KPEMR0_OFFSET           0x00000090
0042 #define KPEMR1_OFFSET           0x00000094
0043 #define KPEMR2_OFFSET           0x00000098
0044 #define KPEMR3_OFFSET           0x0000009C
0045 #define KPEMR_EDGETYPE_BOTH     3
0046
0047 #define KPSSR0_OFFSET           0x000000A0
0048 #define KPSSR1_OFFSET           0x000000A4
0049 #define KPSSRN_OFFSET(reg_n)        (KPSSR0_OFFSET + 4 * (reg_n))
0050 #define KPIMR0_OFFSET           0x000000B0
0051 #define KPIMR1_OFFSET           0x000000B4
0052 #define KPICR0_OFFSET           0x000000B8
0053 #define KPICR1_OFFSET           0x000000BC
0054 #define KPICRN_OFFSET(reg_n)        (KPICR0_OFFSET + 4 * (reg_n))
0055 #define KPISR0_OFFSET           0x000000C0
0056 #define KPISR1_OFFSET           0x000000C4
0057
0058 #define KPCR_STATUSFILTERTYPE_MAX   7
0059 #define KPCR_COLFILTERTYPE_MAX      7
0060
0061 /* Macros to determine the row/column from a bit that is set in SSR0/1. */
0062 #define BIT_TO_ROW_SSRN(bit_nr, reg_n)  (((bit_nr) >> 3) + 4 * (reg_n))
0063 #define BIT_TO_COL(bit_nr)      ((bit_nr) % 8)
0064
0065 /* Structure representing various run-time entities */
0066 struct bcm_kp {
0067     void __iomem *base;
0068     int irq;
0069     struct clk *clk;
0070     struct input_dev *input_dev;
0071     unsigned long last_state[2];
0072     unsigned int n_rows;
0073     unsigned int n_cols;
0074     u32 kpcr;
0075     u32 kpior;
0076     u32 kpemr;
0077     u32 imr0_val;
0078     u32 imr1_val;
0079 };
0080
0081 /*
0082  * Returns the keycode from the input device keymap given the row and
0083  * column.
0084  */
0085 static int bcm_kp_get_keycode(struct bcm_kp *kp, int row, int col)
0086 {
0087     unsigned int row_shift = get_count_order(kp->n_cols);
0088     unsigned short *keymap = kp->input_dev->keycode;
0089
0090     return keymap[MATRIX_SCAN_CODE(row, col, row_shift)];
0091 }
0092
0093 static void bcm_kp_report_keys(struct bcm_kp *kp, int reg_num, int pull_mode)
0094 {
0095     unsigned long state, change;
0096     int bit_nr;
0097     int key_press;
0098     int row, col;
0099     unsigned int keycode;
0100
0101     /* Clear interrupts */
0102     writel(0xFFFFFFFF, kp->base + KPICRN_OFFSET(reg_num));
0103
0104     state = readl(kp->base + KPSSRN_OFFSET(reg_num));
0105     change = kp->last_state[reg_num] ^ state;
0106     kp->last_state[reg_num] = state;
0107
0108     for_each_set_bit(bit_nr, &change, BITS_PER_LONG) {
0109         key_press = state & BIT(bit_nr);
0110         /* The meaning of SSR register depends on pull mode. */
0111         key_press = pull_mode ? !key_press : key_press;
0112         row = BIT_TO_ROW_SSRN(bit_nr, reg_num);
0113         col = BIT_TO_COL(bit_nr);
0114         keycode = bcm_kp_get_keycode(kp, row, col);
0115         input_report_key(kp->input_dev, keycode, key_press);
0116     }
0117 }
0118
0119 static irqreturn_t bcm_kp_isr_thread(int irq, void *dev_id)
0120 {
0121     struct bcm_kp *kp = dev_id;
0122     int pull_mode = (kp->kpcr >> KPCR_MODE_SHIFT) & KPCR_MODE_MASK;
0123     int reg_num;
0124
0125     for (reg_num = 0; reg_num <= 1; reg_num++)
0126         bcm_kp_report_keys(kp, reg_num, pull_mode);
0127
0128     input_sync(kp->input_dev);
0129
0130     return IRQ_HANDLED;
0131 }
0132
0133 static int bcm_kp_start(struct bcm_kp *kp)
0134 {
0135     int error;
0136
0137     if (kp->clk) {
0138         error = clk_prepare_enable(kp->clk);
0139         if (error)
0140             return error;
0141     }
0142
0143     writel(kp->kpior, kp->base + KPIOR_OFFSET);
0144
0145     writel(kp->imr0_val, kp->base + KPIMR0_OFFSET);
0146     writel(kp->imr1_val, kp->base + KPIMR1_OFFSET);
0147
0148     writel(kp->kpemr, kp->base + KPEMR0_OFFSET);
0149     writel(kp->kpemr, kp->base + KPEMR1_OFFSET);
0150     writel(kp->kpemr, kp->base + KPEMR2_OFFSET);
0151     writel(kp->kpemr, kp->base + KPEMR3_OFFSET);
0152
0153     writel(0xFFFFFFFF, kp->base + KPICR0_OFFSET);
0154     writel(0xFFFFFFFF, kp->base + KPICR1_OFFSET);
0155
0156     kp->last_state[0] = readl(kp->base + KPSSR0_OFFSET);
0157     kp->last_state[0] = readl(kp->base + KPSSR1_OFFSET);
0158
0159     writel(kp->kpcr | KPCR_ENABLE, kp->base + KPCR_OFFSET);
0160
0161     return 0;
0162 }
0163
0164 static void bcm_kp_stop(const struct bcm_kp *kp)
0165 {
0166     u32 val;
0167
0168     val = readl(kp->base + KPCR_OFFSET);
0169     val &= ~KPCR_ENABLE;
0170     writel(0, kp->base + KPCR_OFFSET);
0171     writel(0, kp->base + KPIMR0_OFFSET);
0172     writel(0, kp->base + KPIMR1_OFFSET);
0173     writel(0xFFFFFFFF, kp->base + KPICR0_OFFSET);
0174     writel(0xFFFFFFFF, kp->base + KPICR1_OFFSET);
0175
0176     clk_disable_unprepare(kp->clk);
0177 }
0178
0179 static int bcm_kp_open(struct input_dev *dev)
0180 {
0181     struct bcm_kp *kp = input_get_drvdata(dev);
0182
0183     return bcm_kp_start(kp);
0184 }
0185
0186 static void bcm_kp_close(struct input_dev *dev)
0187 {
0188     struct bcm_kp *kp = input_get_drvdata(dev);
0189
0190     bcm_kp_stop(kp);
0191 }
0192
0193 static int bcm_kp_matrix_key_parse_dt(struct bcm_kp *kp)
0194 {
0195     struct device *dev = kp->input_dev->dev.parent;
0196     struct device_node *np = dev->of_node;
0197     int error;
0198     unsigned int dt_val;
0199     unsigned int i;
0200     unsigned int num_rows, col_mask, rows_set;
0201
0202     /* Initialize the KPCR Keypad Configuration Register */
0203     kp->kpcr = KPCR_STATUSFILTERENABLE | KPCR_COLFILTERENABLE;
0204
0205     error = matrix_keypad_parse_properties(dev, &kp->n_rows, &kp->n_cols);
0206     if (error) {
0207         dev_err(dev, "failed to parse kp params\n");
0208         return error;
0209     }
0210
0211     /* Set row width for the ASIC block. */
0212     kp->kpcr |= (kp->n_rows - 1) << KPCR_ROWWIDTH_SHIFT;
0213
0214     /* Set column width for the ASIC block. */
0215     kp->kpcr |= (kp->n_cols - 1) << KPCR_COLUMNWIDTH_SHIFT;
0216
0217     /* Configure the IMR registers */
0218
0219     /*
0220      * IMR registers contain interrupt enable bits for 8x8 matrix
0221      * IMR0 register format: <row3> <row2> <row1> <row0>
0222      * IMR1 register format: <row7> <row6> <row5> <row4>
0223      */
0224     col_mask = (1 << (kp->n_cols)) - 1;
0225     num_rows = kp->n_rows;
0226
0227     /* Set column bits in rows 0 to 3 in IMR0 */
0228     kp->imr0_val = col_mask;
0229
0230     rows_set = 1;
0231     while (--num_rows && rows_set++ < 4)
0232         kp->imr0_val |= kp->imr0_val << MAX_COLS;
0233
0234     /* Set column bits in rows 4 to 7 in IMR1 */
0235     kp->imr1_val = 0;
0236     if (num_rows) {
0237         kp->imr1_val = col_mask;
0238         while (--num_rows)
0239             kp->imr1_val |= kp->imr1_val << MAX_COLS;
0240     }
0241
0242     /* Initialize the KPEMR Keypress Edge Mode Registers */
0243     /* Trigger on both edges */
0244     kp->kpemr = 0;
0245     for (i = 0; i <= 30; i += 2)
0246         kp->kpemr |= (KPEMR_EDGETYPE_BOTH << i);
0247
0248     /*
0249      * Obtain the Status filter debounce value and verify against the
0250      * possible values specified in the DT binding.
0251      */
0252     of_property_read_u32(np, "status-debounce-filter-period", &dt_val);
0253
0254     if (dt_val > KPCR_STATUSFILTERTYPE_MAX) {
0255         dev_err(dev, "Invalid Status filter debounce value %d\n",
0256             dt_val);
0257         return -EINVAL;
0258     }
0259
0260     kp->kpcr |= dt_val << KPCR_STATUSFILTERTYPE_SHIFT;
0261
0262     /*
0263      * Obtain the Column filter debounce value and verify against the
0264      * possible values specified in the DT binding.
0265      */
0266     of_property_read_u32(np, "col-debounce-filter-period", &dt_val);
0267
0268     if (dt_val > KPCR_COLFILTERTYPE_MAX) {
0269         dev_err(dev, "Invalid Column filter debounce value %d\n",
0270             dt_val);
0271         return -EINVAL;
0272     }
0273
0274     kp->kpcr |= dt_val << KPCR_COLFILTERTYPE_SHIFT;
0275
0276     /*
0277      * Determine between the row and column,
0278      * which should be configured as output.
0279      */
0280     if (of_property_read_bool(np, "row-output-enabled")) {
0281         /*
0282         * Set RowOContrl or ColumnOContrl in KPIOR
0283         * to the number of pins to drive as outputs
0284         */
0285         kp->kpior = ((1 << kp->n_rows) - 1) <<
0286                 KPIOR_ROWOCONTRL_SHIFT;
0287     } else {
0288         kp->kpior = ((1 << kp->n_cols) - 1) <<
0289                 KPIOR_COLUMNOCONTRL_SHIFT;
0290     }
0291
0292     /*
0293      * Determine if the scan pull up needs to be enabled
0294      */
0295     if (of_property_read_bool(np, "pull-up-enabled"))
0296         kp->kpcr |= KPCR_MODE;
0297
0298     dev_dbg(dev, "n_rows=%d n_col=%d kpcr=%x kpior=%x kpemr=%x\n",
0299         kp->n_rows, kp->n_cols,
0300         kp->kpcr, kp->kpior, kp->kpemr);
0301
0302     return 0;
0303 }
0304
0305
0306 static int bcm_kp_probe(struct platform_device *pdev)
0307 {
0308     struct bcm_kp *kp;
0309     struct input_dev *input_dev;
0310     struct resource *res;
0311     int error;
0312
0313     kp = devm_kzalloc(&pdev->dev, sizeof(*kp), GFP_KERNEL);
0314     if (!kp)
0315         return -ENOMEM;
0316
0317     input_dev = devm_input_allocate_device(&pdev->dev);
0318     if (!input_dev) {
0319         dev_err(&pdev->dev, "failed to allocate the input device\n");
0320         return -ENOMEM;
0321     }
0322
0323     __set_bit(EV_KEY, input_dev->evbit);
0324
0325     /* Enable auto repeat feature of Linux input subsystem */
0326     if (of_property_read_bool(pdev->dev.of_node, "autorepeat"))
0327         __set_bit(EV_REP, input_dev->evbit);
0328
0329     input_dev->name = pdev->name;
0330     input_dev->phys = "keypad/input0";
0331     input_dev->dev.parent = &pdev->dev;
0332     input_dev->open = bcm_kp_open;
0333     input_dev->close = bcm_kp_close;
0334
0335     input_dev->id.bustype = BUS_HOST;
0336     input_dev->id.vendor = 0x0001;
0337     input_dev->id.product = 0x0001;
0338     input_dev->id.version = 0x0100;
0339
0340     input_set_drvdata(input_dev, kp);
0341
0342     kp->input_dev = input_dev;
0343
0344     error = bcm_kp_matrix_key_parse_dt(kp);
0345     if (error)
0346         return error;
0347
0348     error = matrix_keypad_build_keymap(NULL, NULL,
0349                        kp->n_rows, kp->n_cols,
0350                        NULL, input_dev);
0351     if (error) {
0352         dev_err(&pdev->dev, "failed to build keymap\n");
0353         return error;
0354     }
0355
0356     /* Get the KEYPAD base address */
0357     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0358     if (!res) {
0359         dev_err(&pdev->dev, "Missing keypad base address resource\n");
0360         return -ENODEV;
0361     }
0362
0363     kp->base = devm_ioremap_resource(&pdev->dev, res);
0364     if (IS_ERR(kp->base))
0365         return PTR_ERR(kp->base);
0366
0367     /* Enable clock */
0368     kp->clk = devm_clk_get(&pdev->dev, "peri_clk");
0369     if (IS_ERR(kp->clk)) {
0370         error = PTR_ERR(kp->clk);
0371         if (error != -ENOENT) {
0372             if (error != -EPROBE_DEFER)
0373                 dev_err(&pdev->dev, "Failed to get clock\n");
0374             return error;
0375         }
0376         dev_dbg(&pdev->dev,
0377             "No clock specified. Assuming it's enabled\n");
0378         kp->clk = NULL;
0379     } else {
0380         unsigned int desired_rate;
0381         long actual_rate;
0382
0383         error = of_property_read_u32(pdev->dev.of_node,
0384                          "clock-frequency", &desired_rate);
0385         if (error < 0)
0386             desired_rate = DEFAULT_CLK_HZ;
0387
0388         actual_rate = clk_round_rate(kp->clk, desired_rate);
0389         if (actual_rate <= 0)
0390             return -EINVAL;
0391
0392         error = clk_set_rate(kp->clk, actual_rate);
0393         if (error)
0394             return error;
0395
0396         error = clk_prepare_enable(kp->clk);
0397         if (error)
0398             return error;
0399     }
0400
0401     /* Put the kp into a known sane state */
0402     bcm_kp_stop(kp);
0403
0404     kp->irq = platform_get_irq(pdev, 0);
0405     if (kp->irq < 0)
0406         return -EINVAL;
0407
0408     error = devm_request_threaded_irq(&pdev->dev, kp->irq,
0409                       NULL, bcm_kp_isr_thread,
0410                       IRQF_ONESHOT, pdev->name, kp);
0411     if (error) {
0412         dev_err(&pdev->dev, "failed to request IRQ\n");
0413         return error;
0414     }
0415
0416     error = input_register_device(input_dev);
0417     if (error) {
0418         dev_err(&pdev->dev, "failed to register input device\n");
0419         return error;
0420     }
0421
0422     return 0;
0423 }
0424
0425 static const struct of_device_id bcm_kp_of_match[] = {
0426     { .compatible = "brcm,bcm-keypad" },
0427     { },
0428 };
0429 MODULE_DEVICE_TABLE(of, bcm_kp_of_match);
0430
0431 static struct platform_driver bcm_kp_device_driver = {
0432     .probe      = bcm_kp_probe,
0433     .driver     = {
0434         .name   = "bcm-keypad",
0435         .of_match_table = of_match_ptr(bcm_kp_of_match),
0436     }
0437 };
0438
0439 module_platform_driver(bcm_kp_device_driver);
0440
0441 MODULE_AUTHOR("Broadcom Corporation");
0442 MODULE_DESCRIPTION("BCM Keypad Driver");
0443 MODULE_LICENSE("GPL v2");