input/keyboard/omap4-keypad.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * OMAP4 Keypad Driver
0004  *
0005  * Copyright (C) 2010 Texas Instruments
0006  *
0007  * Author: Abraham Arce <x0066660@ti.com>
0008  * Initial Code: Syed Rafiuddin <rafiuddin.syed@ti.com>
0009  */
0010
0011 #include <linux/module.h>
0012 #include <linux/interrupt.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/errno.h>
0015 #include <linux/io.h>
0016 #include <linux/of.h>
0017 #include <linux/input.h>
0018 #include <linux/input/matrix_keypad.h>
0019 #include <linux/slab.h>
0020 #include <linux/pm_runtime.h>
0021 #include <linux/pm_wakeirq.h>
0022
0023 /* OMAP4 registers */
0024 #define OMAP4_KBD_REVISION      0x00
0025 #define OMAP4_KBD_SYSCONFIG     0x10
0026 #define OMAP4_KBD_SYSSTATUS     0x14
0027 #define OMAP4_KBD_IRQSTATUS     0x18
0028 #define OMAP4_KBD_IRQENABLE     0x1C
0029 #define OMAP4_KBD_WAKEUPENABLE      0x20
0030 #define OMAP4_KBD_PENDING       0x24
0031 #define OMAP4_KBD_CTRL          0x28
0032 #define OMAP4_KBD_DEBOUNCINGTIME    0x2C
0033 #define OMAP4_KBD_LONGKEYTIME       0x30
0034 #define OMAP4_KBD_TIMEOUT       0x34
0035 #define OMAP4_KBD_STATEMACHINE      0x38
0036 #define OMAP4_KBD_ROWINPUTS     0x3C
0037 #define OMAP4_KBD_COLUMNOUTPUTS     0x40
0038 #define OMAP4_KBD_FULLCODE31_0      0x44
0039 #define OMAP4_KBD_FULLCODE63_32     0x48
0040
0041 /* OMAP4 bit definitions */
0042 #define OMAP4_DEF_IRQENABLE_EVENTEN BIT(0)
0043 #define OMAP4_DEF_IRQENABLE_LONGKEY BIT(1)
0044 #define OMAP4_DEF_WUP_EVENT_ENA     BIT(0)
0045 #define OMAP4_DEF_WUP_LONG_KEY_ENA  BIT(1)
0046 #define OMAP4_DEF_CTRL_NOSOFTMODE   BIT(1)
0047 #define OMAP4_DEF_CTRL_PTV_SHIFT    2
0048
0049 /* OMAP4 values */
0050 #define OMAP4_VAL_IRQDISABLE        0x0
0051
0052 /*
0053  * Errata i689: If a key is released for a time shorter than debounce time,
0054  * the keyboard will idle and never detect the key release. The workaround
0055  * is to use at least a 12ms debounce time. See omap5432 TRM chapter
0056  * "26.4.6.2 Keyboard Controller Timer" for more information.
0057  */
0058 #define OMAP4_KEYPAD_PTV_DIV_128        0x6
0059 #define OMAP4_KEYPAD_DEBOUNCINGTIME_MS(dbms, ptv)     \
0060     ((((dbms) * 1000) / ((1 << ((ptv) + 1)) * (1000000 / 32768))) - 1)
0061 #define OMAP4_VAL_DEBOUNCINGTIME_16MS                   \
0062     OMAP4_KEYPAD_DEBOUNCINGTIME_MS(16, OMAP4_KEYPAD_PTV_DIV_128)
0063 #define OMAP4_KEYPAD_AUTOIDLE_MS    50  /* Approximate measured time */
0064 #define OMAP4_KEYPAD_IDLE_CHECK_MS  (OMAP4_KEYPAD_AUTOIDLE_MS / 2)
0065
0066 enum {
0067     KBD_REVISION_OMAP4 = 0,
0068     KBD_REVISION_OMAP5,
0069 };
0070
0071 struct omap4_keypad {
0072     struct input_dev *input;
0073
0074     void __iomem *base;
0075     unsigned int irq;
0076     struct mutex lock;      /* for key scan */
0077
0078     unsigned int rows;
0079     unsigned int cols;
0080     u32 reg_offset;
0081     u32 irqreg_offset;
0082     unsigned int row_shift;
0083     bool no_autorepeat;
0084     u64 keys;
0085     unsigned short *keymap;
0086 };
0087
0088 static int kbd_readl(struct omap4_keypad *keypad_data, u32 offset)
0089 {
0090     return __raw_readl(keypad_data->base +
0091                 keypad_data->reg_offset + offset);
0092 }
0093
0094 static void kbd_writel(struct omap4_keypad *keypad_data, u32 offset, u32 value)
0095 {
0096     __raw_writel(value,
0097              keypad_data->base + keypad_data->reg_offset + offset);
0098 }
0099
0100 static int kbd_read_irqreg(struct omap4_keypad *keypad_data, u32 offset)
0101 {
0102     return __raw_readl(keypad_data->base +
0103                 keypad_data->irqreg_offset + offset);
0104 }
0105
0106 static void kbd_write_irqreg(struct omap4_keypad *keypad_data,
0107                  u32 offset, u32 value)
0108 {
0109     __raw_writel(value,
0110              keypad_data->base + keypad_data->irqreg_offset + offset);
0111 }
0112
0113 static int omap4_keypad_report_keys(struct omap4_keypad *keypad_data,
0114                     u64 keys, bool down)
0115 {
0116     struct input_dev *input_dev = keypad_data->input;
0117     unsigned int col, row, code;
0118     DECLARE_BITMAP(mask, 64);
0119     unsigned long bit;
0120     int events = 0;
0121
0122     bitmap_from_u64(mask, keys);
0123
0124     for_each_set_bit(bit, mask, keypad_data->rows * BITS_PER_BYTE) {
0125         row = bit / BITS_PER_BYTE;
0126         col = bit % BITS_PER_BYTE;
0127         code = MATRIX_SCAN_CODE(row, col, keypad_data->row_shift);
0128
0129         input_event(input_dev, EV_MSC, MSC_SCAN, code);
0130         input_report_key(input_dev, keypad_data->keymap[code], down);
0131
0132         events++;
0133     }
0134
0135     if (events)
0136         input_sync(input_dev);
0137
0138     return events;
0139 }
0140
0141 static void omap4_keypad_scan_keys(struct omap4_keypad *keypad_data, u64 keys)
0142 {
0143     u64 changed;
0144
0145     mutex_lock(&keypad_data->lock);
0146
0147     changed = keys ^ keypad_data->keys;
0148
0149     /*
0150      * Report key up events separately and first. This matters in case we
0151      * lost key-up interrupt and just now catching up.
0152      */
0153     omap4_keypad_report_keys(keypad_data, changed & ~keys, false);
0154
0155     /* Report key down events */
0156     omap4_keypad_report_keys(keypad_data, changed & keys, true);
0157
0158     keypad_data->keys = keys;
0159
0160     mutex_unlock(&keypad_data->lock);
0161 }
0162
0163 /* Interrupt handlers */
0164 static irqreturn_t omap4_keypad_irq_handler(int irq, void *dev_id)
0165 {
0166     struct omap4_keypad *keypad_data = dev_id;
0167
0168     if (kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS))
0169         return IRQ_WAKE_THREAD;
0170
0171     return IRQ_NONE;
0172 }
0173
0174 static irqreturn_t omap4_keypad_irq_thread_fn(int irq, void *dev_id)
0175 {
0176     struct omap4_keypad *keypad_data = dev_id;
0177     struct device *dev = keypad_data->input->dev.parent;
0178     u32 low, high;
0179     int error;
0180     u64 keys;
0181
0182     error = pm_runtime_resume_and_get(dev);
0183     if (error)
0184         return IRQ_NONE;
0185
0186     low = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE31_0);
0187     high = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE63_32);
0188     keys = low | (u64)high << 32;
0189
0190     omap4_keypad_scan_keys(keypad_data, keys);
0191
0192     /* clear pending interrupts */
0193     kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS,
0194              kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS));
0195
0196     pm_runtime_mark_last_busy(dev);
0197     pm_runtime_put_autosuspend(dev);
0198
0199     return IRQ_HANDLED;
0200 }
0201
0202 static int omap4_keypad_open(struct input_dev *input)
0203 {
0204     struct omap4_keypad *keypad_data = input_get_drvdata(input);
0205     struct device *dev = input->dev.parent;
0206     int error;
0207
0208     error = pm_runtime_resume_and_get(dev);
0209     if (error)
0210         return error;
0211
0212     disable_irq(keypad_data->irq);
0213
0214     kbd_writel(keypad_data, OMAP4_KBD_CTRL,
0215             OMAP4_DEF_CTRL_NOSOFTMODE |
0216             (OMAP4_KEYPAD_PTV_DIV_128 << OMAP4_DEF_CTRL_PTV_SHIFT));
0217     kbd_writel(keypad_data, OMAP4_KBD_DEBOUNCINGTIME,
0218             OMAP4_VAL_DEBOUNCINGTIME_16MS);
0219     /* clear pending interrupts */
0220     kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS,
0221              kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS));
0222     kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQENABLE,
0223             OMAP4_DEF_IRQENABLE_EVENTEN);
0224     kbd_writel(keypad_data, OMAP4_KBD_WAKEUPENABLE,
0225             OMAP4_DEF_WUP_EVENT_ENA);
0226
0227     enable_irq(keypad_data->irq);
0228
0229     pm_runtime_mark_last_busy(dev);
0230     pm_runtime_put_autosuspend(dev);
0231
0232     return 0;
0233 }
0234
0235 static void omap4_keypad_stop(struct omap4_keypad *keypad_data)
0236 {
0237     /* Disable interrupts and wake-up events */
0238     kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQENABLE,
0239              OMAP4_VAL_IRQDISABLE);
0240     kbd_writel(keypad_data, OMAP4_KBD_WAKEUPENABLE, 0);
0241
0242     /* clear pending interrupts */
0243     kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS,
0244              kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS));
0245 }
0246
0247 static void omap4_keypad_close(struct input_dev *input)
0248 {
0249     struct omap4_keypad *keypad_data = input_get_drvdata(input);
0250     struct device *dev = input->dev.parent;
0251     int error;
0252
0253     error = pm_runtime_resume_and_get(dev);
0254     if (error)
0255         dev_err(dev, "%s: pm_runtime_resume_and_get() failed: %d\n",
0256             __func__, error);
0257
0258     disable_irq(keypad_data->irq);
0259     omap4_keypad_stop(keypad_data);
0260     enable_irq(keypad_data->irq);
0261
0262     pm_runtime_mark_last_busy(dev);
0263     pm_runtime_put_autosuspend(dev);
0264 }
0265
0266 static int omap4_keypad_parse_dt(struct device *dev,
0267                  struct omap4_keypad *keypad_data)
0268 {
0269     struct device_node *np = dev->of_node;
0270     int err;
0271
0272     err = matrix_keypad_parse_properties(dev, &keypad_data->rows,
0273                          &keypad_data->cols);
0274     if (err)
0275         return err;
0276
0277     if (of_get_property(np, "linux,input-no-autorepeat", NULL))
0278         keypad_data->no_autorepeat = true;
0279
0280     return 0;
0281 }
0282
0283 static int omap4_keypad_check_revision(struct device *dev,
0284                        struct omap4_keypad *keypad_data)
0285 {
0286     unsigned int rev;
0287
0288     rev = __raw_readl(keypad_data->base + OMAP4_KBD_REVISION);
0289     rev &= 0x03 << 30;
0290     rev >>= 30;
0291     switch (rev) {
0292     case KBD_REVISION_OMAP4:
0293         keypad_data->reg_offset = 0x00;
0294         keypad_data->irqreg_offset = 0x00;
0295         break;
0296     case KBD_REVISION_OMAP5:
0297         keypad_data->reg_offset = 0x10;
0298         keypad_data->irqreg_offset = 0x0c;
0299         break;
0300     default:
0301         dev_err(dev, "Keypad reports unsupported revision %d", rev);
0302         return -EINVAL;
0303     }
0304
0305     return 0;
0306 }
0307
0308 /*
0309  * Errata ID i689 "1.32 Keyboard Key Up Event Can Be Missed".
0310  * Interrupt may not happen for key-up events. We must clear stuck
0311  * key-up events after the keyboard hardware has auto-idled.
0312  */
0313 static int __maybe_unused omap4_keypad_runtime_suspend(struct device *dev)
0314 {
0315     struct platform_device *pdev = to_platform_device(dev);
0316     struct omap4_keypad *keypad_data = platform_get_drvdata(pdev);
0317     u32 active;
0318
0319     active = kbd_readl(keypad_data, OMAP4_KBD_STATEMACHINE);
0320     if (active) {
0321         pm_runtime_mark_last_busy(dev);
0322         return -EBUSY;
0323     }
0324
0325     omap4_keypad_scan_keys(keypad_data, 0);
0326
0327     return 0;
0328 }
0329
0330 static const struct dev_pm_ops omap4_keypad_pm_ops = {
0331     SET_RUNTIME_PM_OPS(omap4_keypad_runtime_suspend, NULL, NULL)
0332 };
0333
0334 static void omap4_disable_pm(void *d)
0335 {
0336     pm_runtime_dont_use_autosuspend(d);
0337     pm_runtime_disable(d);
0338 }
0339
0340 static int omap4_keypad_probe(struct platform_device *pdev)
0341 {
0342     struct device *dev = &pdev->dev;
0343     struct omap4_keypad *keypad_data;
0344     struct input_dev *input_dev;
0345     struct resource *res;
0346     unsigned int max_keys;
0347     int irq;
0348     int error;
0349
0350     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0351     if (!res) {
0352         dev_err(&pdev->dev, "no base address specified\n");
0353         return -EINVAL;
0354     }
0355
0356     irq = platform_get_irq(pdev, 0);
0357     if (irq < 0)
0358         return irq;
0359
0360     keypad_data = devm_kzalloc(dev, sizeof(*keypad_data), GFP_KERNEL);
0361     if (!keypad_data) {
0362         dev_err(dev, "keypad_data memory allocation failed\n");
0363         return -ENOMEM;
0364     }
0365
0366     keypad_data->irq = irq;
0367     mutex_init(&keypad_data->lock);
0368     platform_set_drvdata(pdev, keypad_data);
0369
0370     error = omap4_keypad_parse_dt(dev, keypad_data);
0371     if (error)
0372         return error;
0373
0374     keypad_data->base = devm_ioremap_resource(dev, res);
0375     if (IS_ERR(keypad_data->base))
0376         return PTR_ERR(keypad_data->base);
0377
0378     pm_runtime_use_autosuspend(dev);
0379     pm_runtime_set_autosuspend_delay(dev, OMAP4_KEYPAD_IDLE_CHECK_MS);
0380     pm_runtime_enable(dev);
0381
0382     error = devm_add_action_or_reset(dev, omap4_disable_pm, dev);
0383     if (error) {
0384         dev_err(dev, "unable to register cleanup action\n");
0385         return error;
0386     }
0387
0388     /*
0389      * Enable clocks for the keypad module so that we can read
0390      * revision register.
0391      */
0392     error = pm_runtime_resume_and_get(dev);
0393     if (error) {
0394         dev_err(dev, "pm_runtime_resume_and_get() failed\n");
0395         return error;
0396     }
0397
0398     error = omap4_keypad_check_revision(dev, keypad_data);
0399     if (!error) {
0400         /* Ensure device does not raise interrupts */
0401         omap4_keypad_stop(keypad_data);
0402     }
0403
0404     pm_runtime_mark_last_busy(dev);
0405     pm_runtime_put_autosuspend(dev);
0406     if (error)
0407         return error;
0408
0409     /* input device allocation */
0410     keypad_data->input = input_dev = devm_input_allocate_device(dev);
0411     if (!input_dev)
0412         return -ENOMEM;
0413
0414     input_dev->name = pdev->name;
0415     input_dev->id.bustype = BUS_HOST;
0416     input_dev->id.vendor = 0x0001;
0417     input_dev->id.product = 0x0001;
0418     input_dev->id.version = 0x0001;
0419
0420     input_dev->open = omap4_keypad_open;
0421     input_dev->close = omap4_keypad_close;
0422
0423     input_set_capability(input_dev, EV_MSC, MSC_SCAN);
0424     if (!keypad_data->no_autorepeat)
0425         __set_bit(EV_REP, input_dev->evbit);
0426
0427     input_set_drvdata(input_dev, keypad_data);
0428
0429     keypad_data->row_shift = get_count_order(keypad_data->cols);
0430     max_keys = keypad_data->rows << keypad_data->row_shift;
0431     keypad_data->keymap = devm_kcalloc(dev,
0432                        max_keys,
0433                        sizeof(keypad_data->keymap[0]),
0434                        GFP_KERNEL);
0435     if (!keypad_data->keymap) {
0436         dev_err(dev, "Not enough memory for keymap\n");
0437         return -ENOMEM;
0438     }
0439
0440     error = matrix_keypad_build_keymap(NULL, NULL,
0441                        keypad_data->rows, keypad_data->cols,
0442                        keypad_data->keymap, input_dev);
0443     if (error) {
0444         dev_err(dev, "failed to build keymap\n");
0445         return error;
0446     }
0447
0448     error = devm_request_threaded_irq(dev, keypad_data->irq,
0449                       omap4_keypad_irq_handler,
0450                       omap4_keypad_irq_thread_fn,
0451                       IRQF_ONESHOT,
0452                       "omap4-keypad", keypad_data);
0453     if (error) {
0454         dev_err(dev, "failed to register interrupt\n");
0455         return error;
0456     }
0457
0458     error = input_register_device(keypad_data->input);
0459     if (error) {
0460         dev_err(dev, "failed to register input device\n");
0461         return error;
0462     }
0463
0464     device_init_wakeup(dev, true);
0465     error = dev_pm_set_wake_irq(dev, keypad_data->irq);
0466     if (error)
0467         dev_warn(dev, "failed to set up wakeup irq: %d\n", error);
0468
0469     return 0;
0470 }
0471
0472 static int omap4_keypad_remove(struct platform_device *pdev)
0473 {
0474     dev_pm_clear_wake_irq(&pdev->dev);
0475
0476     return 0;
0477 }
0478
0479 static const struct of_device_id omap_keypad_dt_match[] = {
0480     { .compatible = "ti,omap4-keypad" },
0481     {},
0482 };
0483 MODULE_DEVICE_TABLE(of, omap_keypad_dt_match);
0484
0485 static struct platform_driver omap4_keypad_driver = {
0486     .probe      = omap4_keypad_probe,
0487     .remove     = omap4_keypad_remove,
0488     .driver     = {
0489         .name   = "omap4-keypad",
0490         .of_match_table = omap_keypad_dt_match,
0491         .pm = &omap4_keypad_pm_ops,
0492     },
0493 };
0494 module_platform_driver(omap4_keypad_driver);
0495
0496 MODULE_AUTHOR("Texas Instruments");
0497 MODULE_DESCRIPTION("OMAP4 Keypad Driver");
0498 MODULE_LICENSE("GPL");
0499 MODULE_ALIAS("platform:omap4-keypad");