drivers/input/keyboard/bcm-keypad.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 // Copyright (C) 2014 Broadcom Corporation
   3
   4 #include <linux/bitops.h>
   5 #include <linux/clk.h>
   6 #include <linux/gfp.h>
   7 #include <linux/io.h>
   8 #include <linux/input.h>
   9 #include <linux/input/matrix_keypad.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/module.h>
  12 #include <linux/of.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/stddef.h>
  15 #include <linux/types.h>
  16
  17 #define DEFAULT_CLK_HZ                  31250
  18 #define MAX_ROWS                        8
  19 #define MAX_COLS                        8
  20
  21 /* Register/field definitions */
  22 #define KPCR_OFFSET                     0x00000080
  23 #define KPCR_MODE                       0x00000002
  24 #define KPCR_MODE_SHIFT                 1
  25 #define KPCR_MODE_MASK                  1
  26 #define KPCR_ENABLE                     0x00000001
  27 #define KPCR_STATUSFILTERENABLE         0x00008000
  28 #define KPCR_STATUSFILTERTYPE_SHIFT     12
  29 #define KPCR_COLFILTERENABLE            0x00000800
  30 #define KPCR_COLFILTERTYPE_SHIFT        8
  31 #define KPCR_ROWWIDTH_SHIFT             20
  32 #define KPCR_COLUMNWIDTH_SHIFT          16
  33
  34 #define KPIOR_OFFSET                    0x00000084
  35 #define KPIOR_ROWOCONTRL_SHIFT          24
  36 #define KPIOR_ROWOCONTRL_MASK           0xFF000000
  37 #define KPIOR_COLUMNOCONTRL_SHIFT       16
  38 #define KPIOR_COLUMNOCONTRL_MASK        0x00FF0000
  39 #define KPIOR_COLUMN_IO_DATA_SHIFT      0
  40
  41 #define KPEMR0_OFFSET                   0x00000090
  42 #define KPEMR1_OFFSET                   0x00000094
  43 #define KPEMR2_OFFSET                   0x00000098
  44 #define KPEMR3_OFFSET                   0x0000009C
  45 #define KPEMR_EDGETYPE_BOTH             3
  46
  47 #define KPSSR0_OFFSET                   0x000000A0
  48 #define KPSSR1_OFFSET                   0x000000A4
  49 #define KPSSRN_OFFSET(reg_n)            (KPSSR0_OFFSET + 4 * (reg_n))
  50 #define KPIMR0_OFFSET                   0x000000B0
  51 #define KPIMR1_OFFSET                   0x000000B4
  52 #define KPICR0_OFFSET                   0x000000B8
  53 #define KPICR1_OFFSET                   0x000000BC
  54 #define KPICRN_OFFSET(reg_n)            (KPICR0_OFFSET + 4 * (reg_n))
  55 #define KPISR0_OFFSET                   0x000000C0
  56 #define KPISR1_OFFSET                   0x000000C4
  57
  58 #define KPCR_STATUSFILTERTYPE_MAX       7
  59 #define KPCR_COLFILTERTYPE_MAX          7
  60
  61 /* Macros to determine the row/column from a bit that is set in SSR0/1. */
  62 #define BIT_TO_ROW_SSRN(bit_nr, reg_n)  (((bit_nr) >> 3) + 4 * (reg_n))
  63 #define BIT_TO_COL(bit_nr)              ((bit_nr) % 8)
  64
  65 /* Structure representing various run-time entities */
  66 struct bcm_kp {
  67         void __iomem *base;
  68         int irq;
  69         struct clk *clk;
  70         struct input_dev *input_dev;
  71         unsigned long last_state[2];
  72         unsigned int n_rows;
  73         unsigned int n_cols;
  74         u32 kpcr;
  75         u32 kpior;
  76         u32 kpemr;
  77         u32 imr0_val;
  78         u32 imr1_val;
  79 };
  80
  81 /*
  82  * Returns the keycode from the input device keymap given the row and
  83  * column.
  84  */
  85 static int bcm_kp_get_keycode(struct bcm_kp *kp, int row, int col)
  86 {
  87         unsigned int row_shift = get_count_order(kp->n_cols);
  88         unsigned short *keymap = kp->input_dev->keycode;
  89
  90         return keymap[MATRIX_SCAN_CODE(row, col, row_shift)];
  91 }
  92
  93 static void bcm_kp_report_keys(struct bcm_kp *kp, int reg_num, int pull_mode)
  94 {
  95         unsigned long state, change;
  96         int bit_nr;
  97         int key_press;
  98         int row, col;
  99         unsigned int keycode;
 100
 101         /* Clear interrupts */
 102         writel(0xFFFFFFFF, kp->base + KPICRN_OFFSET(reg_num));
 103
 104         state = readl(kp->base + KPSSRN_OFFSET(reg_num));
 105         change = kp->last_state[reg_num] ^ state;
 106         kp->last_state[reg_num] = state;
 107
 108         for_each_set_bit(bit_nr, &change, BITS_PER_LONG) {
 109                 key_press = state & BIT(bit_nr);
 110                 /* The meaning of SSR register depends on pull mode. */
 111                 key_press = pull_mode ? !key_press : key_press;
 112                 row = BIT_TO_ROW_SSRN(bit_nr, reg_num);
 113                 col = BIT_TO_COL(bit_nr);
 114                 keycode = bcm_kp_get_keycode(kp, row, col);
 115                 input_report_key(kp->input_dev, keycode, key_press);
 116         }
 117 }
 118
 119 static irqreturn_t bcm_kp_isr_thread(int irq, void *dev_id)
 120 {
 121         struct bcm_kp *kp = dev_id;
 122         int pull_mode = (kp->kpcr >> KPCR_MODE_SHIFT) & KPCR_MODE_MASK;
 123         int reg_num;
 124
 125         for (reg_num = 0; reg_num <= 1; reg_num++)
 126                 bcm_kp_report_keys(kp, reg_num, pull_mode);
 127
 128         input_sync(kp->input_dev);
 129
 130         return IRQ_HANDLED;
 131 }
 132
 133 static int bcm_kp_start(struct bcm_kp *kp)
 134 {
 135         int error;
 136
 137         if (kp->clk) {
 138                 error = clk_prepare_enable(kp->clk);
 139                 if (error)
 140                         return error;
 141         }
 142
 143         writel(kp->kpior, kp->base + KPIOR_OFFSET);
 144
 145         writel(kp->imr0_val, kp->base + KPIMR0_OFFSET);
 146         writel(kp->imr1_val, kp->base + KPIMR1_OFFSET);
 147
 148         writel(kp->kpemr, kp->base + KPEMR0_OFFSET);
 149         writel(kp->kpemr, kp->base + KPEMR1_OFFSET);
 150         writel(kp->kpemr, kp->base + KPEMR2_OFFSET);
 151         writel(kp->kpemr, kp->base + KPEMR3_OFFSET);
 152
 153         writel(0xFFFFFFFF, kp->base + KPICR0_OFFSET);
 154         writel(0xFFFFFFFF, kp->base + KPICR1_OFFSET);
 155
 156         kp->last_state[0] = readl(kp->base + KPSSR0_OFFSET);
 157         kp->last_state[0] = readl(kp->base + KPSSR1_OFFSET);
 158
 159         writel(kp->kpcr | KPCR_ENABLE, kp->base + KPCR_OFFSET);
 160
 161         return 0;
 162 }
 163
 164 static void bcm_kp_stop(const struct bcm_kp *kp)
 165 {
 166         u32 val;
 167
 168         val = readl(kp->base + KPCR_OFFSET);
 169         val &= ~KPCR_ENABLE;
 170         writel(0, kp->base + KPCR_OFFSET);
 171         writel(0, kp->base + KPIMR0_OFFSET);
 172         writel(0, kp->base + KPIMR1_OFFSET);
 173         writel(0xFFFFFFFF, kp->base + KPICR0_OFFSET);
 174         writel(0xFFFFFFFF, kp->base + KPICR1_OFFSET);
 175
 176         clk_disable_unprepare(kp->clk);
 177 }
 178
 179 static int bcm_kp_open(struct input_dev *dev)
 180 {
 181         struct bcm_kp *kp = input_get_drvdata(dev);
 182
 183         return bcm_kp_start(kp);
 184 }
 185
 186 static void bcm_kp_close(struct input_dev *dev)
 187 {
 188         struct bcm_kp *kp = input_get_drvdata(dev);
 189
 190         bcm_kp_stop(kp);
 191 }
 192
 193 static int bcm_kp_matrix_key_parse_dt(struct bcm_kp *kp)
 194 {
 195         struct device *dev = kp->input_dev->dev.parent;
 196         struct device_node *np = dev->of_node;
 197         int error;
 198         unsigned int dt_val;
 199         unsigned int i;
 200         unsigned int num_rows, col_mask, rows_set;
 201
 202         /* Initialize the KPCR Keypad Configuration Register */
 203         kp->kpcr = KPCR_STATUSFILTERENABLE | KPCR_COLFILTERENABLE;
 204
 205         error = matrix_keypad_parse_properties(dev, &kp->n_rows, &kp->n_cols);
 206         if (error) {
 207                 dev_err(dev, "failed to parse kp params\n");
 208                 return error;
 209         }
 210
 211         /* Set row width for the ASIC block. */
 212         kp->kpcr |= (kp->n_rows - 1) << KPCR_ROWWIDTH_SHIFT;
 213
 214         /* Set column width for the ASIC block. */
 215         kp->kpcr |= (kp->n_cols - 1) << KPCR_COLUMNWIDTH_SHIFT;
 216
 217         /* Configure the IMR registers */
 218
 219         /*
 220          * IMR registers contain interrupt enable bits for 8x8 matrix
 221          * IMR0 register format: <row3> <row2> <row1> <row0>
 222          * IMR1 register format: <row7> <row6> <row5> <row4>
 223          */
 224         col_mask = (1 << (kp->n_cols)) - 1;
 225         num_rows = kp->n_rows;
 226
 227         /* Set column bits in rows 0 to 3 in IMR0 */
 228         kp->imr0_val = col_mask;
 229
 230         rows_set = 1;
 231         while (--num_rows && rows_set++ < 4)
 232                 kp->imr0_val |= kp->imr0_val << MAX_COLS;
 233
 234         /* Set column bits in rows 4 to 7 in IMR1 */
 235         kp->imr1_val = 0;
 236         if (num_rows) {
 237                 kp->imr1_val = col_mask;
 238                 while (--num_rows)
 239                         kp->imr1_val |= kp->imr1_val << MAX_COLS;
 240         }
 241
 242         /* Initialize the KPEMR Keypress Edge Mode Registers */
 243         /* Trigger on both edges */
 244         kp->kpemr = 0;
 245         for (i = 0; i <= 30; i += 2)
 246                 kp->kpemr |= (KPEMR_EDGETYPE_BOTH << i);
 247
 248         /*
 249          * Obtain the Status filter debounce value and verify against the
 250          * possible values specified in the DT binding.
 251          */
 252         of_property_read_u32(np, "status-debounce-filter-period", &dt_val);
 253
 254         if (dt_val > KPCR_STATUSFILTERTYPE_MAX) {
 255                 dev_err(dev, "Invalid Status filter debounce value %d\n",
 256                         dt_val);
 257                 return -EINVAL;
 258         }
 259
 260         kp->kpcr |= dt_val << KPCR_STATUSFILTERTYPE_SHIFT;
 261
 262         /*
 263          * Obtain the Column filter debounce value and verify against the
 264          * possible values specified in the DT binding.
 265          */
 266         of_property_read_u32(np, "col-debounce-filter-period", &dt_val);
 267
 268         if (dt_val > KPCR_COLFILTERTYPE_MAX) {
 269                 dev_err(dev, "Invalid Column filter debounce value %d\n",
 270                         dt_val);
 271                 return -EINVAL;
 272         }
 273
 274         kp->kpcr |= dt_val << KPCR_COLFILTERTYPE_SHIFT;
 275
 276         /*
 277          * Determine between the row and column,
 278          * which should be configured as output.
 279          */
 280         if (of_property_read_bool(np, "row-output-enabled")) {
 281                 /*
 282                 * Set RowOContrl or ColumnOContrl in KPIOR
 283                 * to the number of pins to drive as outputs
 284                 */
 285                 kp->kpior = ((1 << kp->n_rows) - 1) <<
 286                                 KPIOR_ROWOCONTRL_SHIFT;
 287         } else {
 288                 kp->kpior = ((1 << kp->n_cols) - 1) <<
 289                                 KPIOR_COLUMNOCONTRL_SHIFT;
 290         }
 291
 292         /*
 293          * Determine if the scan pull up needs to be enabled
 294          */
 295         if (of_property_read_bool(np, "pull-up-enabled"))
 296                 kp->kpcr |= KPCR_MODE;
 297
 298         dev_dbg(dev, "n_rows=%d n_col=%d kpcr=%x kpior=%x kpemr=%x\n",
 299                 kp->n_rows, kp->n_cols,
 300                 kp->kpcr, kp->kpior, kp->kpemr);
 301
 302         return 0;
 303 }
 304
 305
 306 static int bcm_kp_probe(struct platform_device *pdev)
 307 {
 308         struct bcm_kp *kp;
 309         struct input_dev *input_dev;
 310         int error;
 311
 312         kp = devm_kzalloc(&pdev->dev, sizeof(*kp), GFP_KERNEL);
 313         if (!kp)
 314                 return -ENOMEM;
 315
 316         input_dev = devm_input_allocate_device(&pdev->dev);
 317         if (!input_dev) {
 318                 dev_err(&pdev->dev, "failed to allocate the input device\n");
 319                 return -ENOMEM;
 320         }
 321
 322         __set_bit(EV_KEY, input_dev->evbit);
 323
 324         /* Enable auto repeat feature of Linux input subsystem */
 325         if (of_property_read_bool(pdev->dev.of_node, "autorepeat"))
 326                 __set_bit(EV_REP, input_dev->evbit);
 327
 328         input_dev->name = pdev->name;
 329         input_dev->phys = "keypad/input0";
 330         input_dev->dev.parent = &pdev->dev;
 331         input_dev->open = bcm_kp_open;
 332         input_dev->close = bcm_kp_close;
 333
 334         input_dev->id.bustype = BUS_HOST;
 335         input_dev->id.vendor = 0x0001;
 336         input_dev->id.product = 0x0001;
 337         input_dev->id.version = 0x0100;
 338
 339         input_set_drvdata(input_dev, kp);
 340
 341         kp->input_dev = input_dev;
 342
 343         error = bcm_kp_matrix_key_parse_dt(kp);
 344         if (error)
 345                 return error;
 346
 347         error = matrix_keypad_build_keymap(NULL, NULL,
 348                                            kp->n_rows, kp->n_cols,
 349                                            NULL, input_dev);
 350         if (error) {
 351                 dev_err(&pdev->dev, "failed to build keymap\n");
 352                 return error;
 353         }
 354
 355         kp->base = devm_platform_ioremap_resource(pdev, 0);
 356         if (IS_ERR(kp->base))
 357                 return PTR_ERR(kp->base);
 358
 359         /* Enable clock */
 360         kp->clk = devm_clk_get_optional(&pdev->dev, "peri_clk");
 361         if (IS_ERR(kp->clk)) {
 362                 return dev_err_probe(&pdev->dev, PTR_ERR(kp->clk), "Failed to get clock\n");
 363         } else if (!kp->clk) {
 364                 dev_dbg(&pdev->dev, "No clock specified. Assuming it's enabled\n");
 365         } else {
 366                 unsigned int desired_rate;
 367                 long actual_rate;
 368
 369                 error = of_property_read_u32(pdev->dev.of_node,
 370                                              "clock-frequency", &desired_rate);
 371                 if (error < 0)
 372                         desired_rate = DEFAULT_CLK_HZ;
 373
 374                 actual_rate = clk_round_rate(kp->clk, desired_rate);
 375                 if (actual_rate <= 0)
 376                         return -EINVAL;
 377
 378                 error = clk_set_rate(kp->clk, actual_rate);
 379                 if (error)
 380                         return error;
 381
 382                 error = clk_prepare_enable(kp->clk);
 383                 if (error)
 384                         return error;
 385         }
 386
 387         /* Put the kp into a known sane state */
 388         bcm_kp_stop(kp);
 389
 390         kp->irq = platform_get_irq(pdev, 0);
 391         if (kp->irq < 0)
 392                 return -EINVAL;
 393
 394         error = devm_request_threaded_irq(&pdev->dev, kp->irq,
 395                                           NULL, bcm_kp_isr_thread,
 396                                           IRQF_ONESHOT, pdev->name, kp);
 397         if (error) {
 398                 dev_err(&pdev->dev, "failed to request IRQ\n");
 399                 return error;
 400         }
 401
 402         error = input_register_device(input_dev);
 403         if (error) {
 404                 dev_err(&pdev->dev, "failed to register input device\n");
 405                 return error;
 406         }
 407
 408         return 0;
 409 }
 410
 411 static const struct of_device_id bcm_kp_of_match[] = {
 412         { .compatible = "brcm,bcm-keypad" },
 413         { },
 414 };
 415 MODULE_DEVICE_TABLE(of, bcm_kp_of_match);
 416
 417 static struct platform_driver bcm_kp_device_driver = {
 418         .probe          = bcm_kp_probe,
 419         .driver         = {
 420                 .name   = "bcm-keypad",
 421                 .of_match_table = bcm_kp_of_match,
 422         }
 423 };
 424
 425 module_platform_driver(bcm_kp_device_driver);
 426
 427 MODULE_AUTHOR("Broadcom Corporation");
 428 MODULE_DESCRIPTION("BCM Keypad Driver");
 429 MODULE_LICENSE("GPL v2");