root/drivers/input/keyboard/bcm-keypad.c

DEFINITIONS

1. bcm_kp_get_keycode
2. bcm_kp_report_keys
3. bcm_kp_isr_thread
4. bcm_kp_start
5. bcm_kp_stop
6. bcm_kp_open
7. bcm_kp_close
8. bcm_kp_matrix_key_parse_dt
9. bcm_kp_probe

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