drivers/input/keyboard/matrix_keypad.c

   1 /*
   2  *  GPIO driven matrix keyboard driver
   3  *
   4  *  Copyright (c) 2008 Marek Vasut <marek.vasut@gmail.com>
   5  *
   6  *  Based on corgikbd.c
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License version 2 as
  10  *  published by the Free Software Foundation.
  11  *
  12  */
  13
  14 #include <linux/types.h>
  15 #include <linux/delay.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/init.h>
  18 #include <linux/input.h>
  19 #include <linux/irq.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/jiffies.h>
  22 #include <linux/module.h>
  23 #include <linux/gpio.h>
  24 #include <linux/input/matrix_keypad.h>
  25
  26 struct matrix_keypad {
  27         const struct matrix_keypad_platform_data *pdata;
  28         struct input_dev *input_dev;
  29         unsigned short *keycodes;
  30         unsigned int row_shift;
  31
  32         uint32_t last_key_state[MATRIX_MAX_COLS];
  33         struct delayed_work work;
  34         bool scan_pending;
  35         bool stopped;
  36         spinlock_t lock;
  37 };
  38
  39 /*
  40  * NOTE: normally the GPIO has to be put into HiZ when de-activated to cause
  41  * minmal side effect when scanning other columns, here it is configured to
  42  * be input, and it should work on most platforms.
  43  */
  44 static void __activate_col(const struct matrix_keypad_platform_data *pdata,
  45                            int col, bool on)
  46 {
  47         bool level_on = !pdata->active_low;
  48
  49         if (on) {
  50                 gpio_direction_output(pdata->col_gpios[col], level_on);
  51         } else {
  52                 gpio_set_value_cansleep(pdata->col_gpios[col], !level_on);
  53                 gpio_direction_input(pdata->col_gpios[col]);
  54         }
  55 }
  56
  57 static void activate_col(const struct matrix_keypad_platform_data *pdata,
  58                          int col, bool on)
  59 {
  60         __activate_col(pdata, col, on);
  61
  62         if (on && pdata->col_scan_delay_us)
  63                 udelay(pdata->col_scan_delay_us);
  64 }
  65
  66 static void activate_all_cols(const struct matrix_keypad_platform_data *pdata,
  67                               bool on)
  68 {
  69         int col;
  70
  71         for (col = 0; col < pdata->num_col_gpios; col++)
  72                 __activate_col(pdata, col, on);
  73 }
  74
  75 static bool row_asserted(const struct matrix_keypad_platform_data *pdata,
  76                          int row)
  77 {
  78         return gpio_get_value_cansleep(pdata->row_gpios[row]) ?
  79                         !pdata->active_low : pdata->active_low;
  80 }
  81
  82 static void enable_row_irqs(struct matrix_keypad *keypad)
  83 {
  84         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
  85         int i;
  86
  87         for (i = 0; i < pdata->num_row_gpios; i++)
  88                 enable_irq(gpio_to_irq(pdata->row_gpios[i]));
  89 }
  90
  91 static void disable_row_irqs(struct matrix_keypad *keypad)
  92 {
  93         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
  94         int i;
  95
  96         for (i = 0; i < pdata->num_row_gpios; i++)
  97                 disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i]));
  98 }
  99
 100 /*
 101  * This gets the keys from keyboard and reports it to input subsystem
 102  */
 103 static void matrix_keypad_scan(struct work_struct *work)
 104 {
 105         struct matrix_keypad *keypad =
 106                 container_of(work, struct matrix_keypad, work.work);
 107         struct input_dev *input_dev = keypad->input_dev;
 108         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
 109         uint32_t new_state[MATRIX_MAX_COLS];
 110         int row, col, code;
 111
 112         /* de-activate all columns for scanning */
 113         activate_all_cols(pdata, false);
 114
 115         memset(new_state, 0, sizeof(new_state));
 116
 117         /* assert each column and read the row status out */
 118         for (col = 0; col < pdata->num_col_gpios; col++) {
 119
 120                 activate_col(pdata, col, true);
 121
 122                 for (row = 0; row < pdata->num_row_gpios; row++)
 123                         new_state[col] |=
 124                                 row_asserted(pdata, row) ? (1 << row) : 0;
 125
 126                 activate_col(pdata, col, false);
 127         }
 128
 129         for (col = 0; col < pdata->num_col_gpios; col++) {
 130                 uint32_t bits_changed;
 131
 132                 bits_changed = keypad->last_key_state[col] ^ new_state[col];
 133                 if (bits_changed == 0)
 134                         continue;
 135
 136                 for (row = 0; row < pdata->num_row_gpios; row++) {
 137                         if ((bits_changed & (1 << row)) == 0)
 138                                 continue;
 139
 140                         code = MATRIX_SCAN_CODE(row, col, keypad->row_shift);
 141                         input_event(input_dev, EV_MSC, MSC_SCAN, code);
 142                         input_report_key(input_dev,
 143                                          keypad->keycodes[code],
 144                                          new_state[col] & (1 << row));
 145                 }
 146         }
 147         input_sync(input_dev);
 148
 149         memcpy(keypad->last_key_state, new_state, sizeof(new_state));
 150
 151         activate_all_cols(pdata, true);
 152
 153         /* Enable IRQs again */
 154         spin_lock_irq(&keypad->lock);
 155         keypad->scan_pending = false;
 156         enable_row_irqs(keypad);
 157         spin_unlock_irq(&keypad->lock);
 158 }
 159
 160 static irqreturn_t matrix_keypad_interrupt(int irq, void *id)
 161 {
 162         struct matrix_keypad *keypad = id;
 163         unsigned long flags;
 164
 165         spin_lock_irqsave(&keypad->lock, flags);
 166
 167         /*
 168          * See if another IRQ beaten us to it and scheduled the
 169          * scan already. In that case we should not try to
 170          * disable IRQs again.
 171          */
 172         if (unlikely(keypad->scan_pending || keypad->stopped))
 173                 goto out;
 174
 175         disable_row_irqs(keypad);
 176         keypad->scan_pending = true;
 177         schedule_delayed_work(&keypad->work,
 178                 msecs_to_jiffies(keypad->pdata->debounce_ms));
 179
 180 out:
 181         spin_unlock_irqrestore(&keypad->lock, flags);
 182         return IRQ_HANDLED;
 183 }
 184
 185 static int matrix_keypad_start(struct input_dev *dev)
 186 {
 187         struct matrix_keypad *keypad = input_get_drvdata(dev);
 188
 189         keypad->stopped = false;
 190         mb();
 191
 192         /*
 193          * Schedule an immediate key scan to capture current key state;
 194          * columns will be activated and IRQs be enabled after the scan.
 195          */
 196         schedule_delayed_work(&keypad->work, 0);
 197
 198         return 0;
 199 }
 200
 201 static void matrix_keypad_stop(struct input_dev *dev)
 202 {
 203         struct matrix_keypad *keypad = input_get_drvdata(dev);
 204
 205         keypad->stopped = true;
 206         mb();
 207         flush_work(&keypad->work.work);
 208         /*
 209          * matrix_keypad_scan() will leave IRQs enabled;
 210          * we should disable them now.
 211          */
 212         disable_row_irqs(keypad);
 213 }
 214
 215 #ifdef CONFIG_PM
 216 static int matrix_keypad_suspend(struct platform_device *pdev, pm_message_t state)
 217 {
 218         struct matrix_keypad *keypad = platform_get_drvdata(pdev);
 219         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
 220         int i;
 221
 222         matrix_keypad_stop(keypad->input_dev);
 223
 224         if (device_may_wakeup(&pdev->dev))
 225                 for (i = 0; i < pdata->num_row_gpios; i++)
 226                         enable_irq_wake(gpio_to_irq(pdata->row_gpios[i]));
 227
 228         return 0;
 229 }
 230
 231 static int matrix_keypad_resume(struct platform_device *pdev)
 232 {
 233         struct matrix_keypad *keypad = platform_get_drvdata(pdev);
 234         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
 235         int i;
 236
 237         if (device_may_wakeup(&pdev->dev))
 238                 for (i = 0; i < pdata->num_row_gpios; i++)
 239                         disable_irq_wake(gpio_to_irq(pdata->row_gpios[i]));
 240
 241         matrix_keypad_start(keypad->input_dev);
 242
 243         return 0;
 244 }
 245 #else
 246 #define matrix_keypad_suspend   NULL
 247 #define matrix_keypad_resume    NULL
 248 #endif
 249
 250 static int __devinit init_matrix_gpio(struct platform_device *pdev,
 251                                         struct matrix_keypad *keypad)
 252 {
 253         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
 254         int i, err = -EINVAL;
 255
 256         /* initialized strobe lines as outputs, activated */
 257         for (i = 0; i < pdata->num_col_gpios; i++) {
 258                 err = gpio_request(pdata->col_gpios[i], "matrix_kbd_col");
 259                 if (err) {
 260                         dev_err(&pdev->dev,
 261                                 "failed to request GPIO%d for COL%d\n",
 262                                 pdata->col_gpios[i], i);
 263                         goto err_free_cols;
 264                 }
 265
 266                 gpio_direction_output(pdata->col_gpios[i], !pdata->active_low);
 267         }
 268
 269         for (i = 0; i < pdata->num_row_gpios; i++) {
 270                 err = gpio_request(pdata->row_gpios[i], "matrix_kbd_row");
 271                 if (err) {
 272                         dev_err(&pdev->dev,
 273                                 "failed to request GPIO%d for ROW%d\n",
 274                                 pdata->row_gpios[i], i);
 275                         goto err_free_rows;
 276                 }
 277
 278                 gpio_direction_input(pdata->row_gpios[i]);
 279         }
 280
 281         for (i = 0; i < pdata->num_row_gpios; i++) {
 282                 err = request_irq(gpio_to_irq(pdata->row_gpios[i]),
 283                                 matrix_keypad_interrupt,
 284                                 IRQF_DISABLED |
 285                                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
 286                                 "matrix-keypad", keypad);
 287                 if (err) {
 288                         dev_err(&pdev->dev,
 289                                 "Unable to acquire interrupt for GPIO line %i\n",
 290                                 pdata->row_gpios[i]);
 291                         goto err_free_irqs;
 292                 }
 293         }
 294
 295         /* initialized as disabled - enabled by input->open */
 296         disable_row_irqs(keypad);
 297         return 0;
 298
 299 err_free_irqs:
 300         while (--i >= 0)
 301                 free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
 302         i = pdata->num_row_gpios;
 303 err_free_rows:
 304         while (--i >= 0)
 305                 gpio_free(pdata->row_gpios[i]);
 306         i = pdata->num_col_gpios;
 307 err_free_cols:
 308         while (--i >= 0)
 309                 gpio_free(pdata->col_gpios[i]);
 310
 311         return err;
 312 }
 313
 314 static int __devinit matrix_keypad_probe(struct platform_device *pdev)
 315 {
 316         const struct matrix_keypad_platform_data *pdata;
 317         const struct matrix_keymap_data *keymap_data;
 318         struct matrix_keypad *keypad;
 319         struct input_dev *input_dev;
 320         unsigned short *keycodes;
 321         unsigned int row_shift;
 322         int err;
 323
 324         pdata = pdev->dev.platform_data;
 325         if (!pdata) {
 326                 dev_err(&pdev->dev, "no platform data defined\n");
 327                 return -EINVAL;
 328         }
 329
 330         keymap_data = pdata->keymap_data;
 331         if (!keymap_data) {
 332                 dev_err(&pdev->dev, "no keymap data defined\n");
 333                 return -EINVAL;
 334         }
 335
 336         row_shift = get_count_order(pdata->num_col_gpios);
 337
 338         keypad = kzalloc(sizeof(struct matrix_keypad), GFP_KERNEL);
 339         keycodes = kzalloc((pdata->num_row_gpios << row_shift) *
 340                                 sizeof(*keycodes),
 341                            GFP_KERNEL);
 342         input_dev = input_allocate_device();
 343         if (!keypad || !keycodes || !input_dev) {
 344                 err = -ENOMEM;
 345                 goto err_free_mem;
 346         }
 347
 348         keypad->input_dev = input_dev;
 349         keypad->pdata = pdata;
 350         keypad->keycodes = keycodes;
 351         keypad->row_shift = row_shift;
 352         keypad->stopped = true;
 353         INIT_DELAYED_WORK(&keypad->work, matrix_keypad_scan);
 354         spin_lock_init(&keypad->lock);
 355
 356         input_dev->name         = pdev->name;
 357         input_dev->id.bustype   = BUS_HOST;
 358         input_dev->dev.parent   = &pdev->dev;
 359         input_dev->evbit[0]     = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
 360         input_dev->open         = matrix_keypad_start;
 361         input_dev->close        = matrix_keypad_stop;
 362
 363         input_dev->keycode      = keycodes;
 364         input_dev->keycodesize  = sizeof(*keycodes);
 365         input_dev->keycodemax   = pdata->num_row_gpios << row_shift;
 366
 367         matrix_keypad_build_keymap(keymap_data, row_shift,
 368                                    input_dev->keycode, input_dev->keybit);
 369
 370         input_set_capability(input_dev, EV_MSC, MSC_SCAN);
 371         input_set_drvdata(input_dev, keypad);
 372
 373         err = init_matrix_gpio(pdev, keypad);
 374         if (err)
 375                 goto err_free_mem;
 376
 377         err = input_register_device(keypad->input_dev);
 378         if (err)
 379                 goto err_free_mem;
 380
 381         device_init_wakeup(&pdev->dev, pdata->wakeup);
 382         platform_set_drvdata(pdev, keypad);
 383
 384         return 0;
 385
 386 err_free_mem:
 387         input_free_device(input_dev);
 388         kfree(keycodes);
 389         kfree(keypad);
 390         return err;
 391 }
 392
 393 static int __devexit matrix_keypad_remove(struct platform_device *pdev)
 394 {
 395         struct matrix_keypad *keypad = platform_get_drvdata(pdev);
 396         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
 397         int i;
 398
 399         device_init_wakeup(&pdev->dev, 0);
 400
 401         for (i = 0; i < pdata->num_row_gpios; i++) {
 402                 free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
 403                 gpio_free(pdata->row_gpios[i]);
 404         }
 405
 406         for (i = 0; i < pdata->num_col_gpios; i++)
 407                 gpio_free(pdata->col_gpios[i]);
 408
 409         input_unregister_device(keypad->input_dev);
 410         platform_set_drvdata(pdev, NULL);
 411         kfree(keypad->keycodes);
 412         kfree(keypad);
 413
 414         return 0;
 415 }
 416
 417 static struct platform_driver matrix_keypad_driver = {
 418         .probe          = matrix_keypad_probe,
 419         .remove         = __devexit_p(matrix_keypad_remove),
 420         .suspend        = matrix_keypad_suspend,
 421         .resume         = matrix_keypad_resume,
 422         .driver         = {
 423                 .name   = "matrix-keypad",
 424                 .owner  = THIS_MODULE,
 425         },
 426 };
 427
 428 static int __init matrix_keypad_init(void)
 429 {
 430         return platform_driver_register(&matrix_keypad_driver);
 431 }
 432
 433 static void __exit matrix_keypad_exit(void)
 434 {
 435         platform_driver_unregister(&matrix_keypad_driver);
 436 }
 437
 438 module_init(matrix_keypad_init);
 439 module_exit(matrix_keypad_exit);
 440
 441 MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
 442 MODULE_DESCRIPTION("GPIO Driven Matrix Keypad Driver");
 443 MODULE_LICENSE("GPL v2");
 444 MODULE_ALIAS("platform:matrix-keypad");