input/keyboard/mtk-pmic-keys.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2017 MediaTek, Inc.
0004  *
0005  * Author: Chen Zhong <chen.zhong@mediatek.com>
0006  */
0007
0008 #include <linux/input.h>
0009 #include <linux/interrupt.h>
0010 #include <linux/kernel.h>
0011 #include <linux/mfd/mt6323/registers.h>
0012 #include <linux/mfd/mt6358/registers.h>
0013 #include <linux/mfd/mt6397/core.h>
0014 #include <linux/mfd/mt6397/registers.h>
0015 #include <linux/module.h>
0016 #include <linux/of_device.h>
0017 #include <linux/of.h>
0018 #include <linux/platform_device.h>
0019 #include <linux/regmap.h>
0020
0021 #define MTK_PMIC_RST_DU_MASK    GENMASK(9, 8)
0022 #define MTK_PMIC_PWRKEY_RST BIT(6)
0023 #define MTK_PMIC_HOMEKEY_RST    BIT(5)
0024
0025 #define MTK_PMIC_PWRKEY_INDEX   0
0026 #define MTK_PMIC_HOMEKEY_INDEX  1
0027 #define MTK_PMIC_MAX_KEY_COUNT  2
0028
0029 struct mtk_pmic_keys_regs {
0030     u32 deb_reg;
0031     u32 deb_mask;
0032     u32 intsel_reg;
0033     u32 intsel_mask;
0034     u32 rst_en_mask;
0035 };
0036
0037 #define MTK_PMIC_KEYS_REGS(_deb_reg, _deb_mask,     \
0038     _intsel_reg, _intsel_mask, _rst_mask)       \
0039 {                           \
0040     .deb_reg        = _deb_reg,     \
0041     .deb_mask       = _deb_mask,        \
0042     .intsel_reg     = _intsel_reg,      \
0043     .intsel_mask        = _intsel_mask,     \
0044     .rst_en_mask        = _rst_mask,        \
0045 }
0046
0047 struct mtk_pmic_regs {
0048     const struct mtk_pmic_keys_regs keys_regs[MTK_PMIC_MAX_KEY_COUNT];
0049     u32 pmic_rst_reg;
0050     u32 rst_lprst_mask; /* Long-press reset timeout bitmask */
0051 };
0052
0053 static const struct mtk_pmic_regs mt6397_regs = {
0054     .keys_regs[MTK_PMIC_PWRKEY_INDEX] =
0055         MTK_PMIC_KEYS_REGS(MT6397_CHRSTATUS,
0056         0x8, MT6397_INT_RSV, 0x10, MTK_PMIC_PWRKEY_RST),
0057     .keys_regs[MTK_PMIC_HOMEKEY_INDEX] =
0058         MTK_PMIC_KEYS_REGS(MT6397_OCSTATUS2,
0059         0x10, MT6397_INT_RSV, 0x8, MTK_PMIC_HOMEKEY_RST),
0060     .pmic_rst_reg = MT6397_TOP_RST_MISC,
0061     .rst_lprst_mask = MTK_PMIC_RST_DU_MASK,
0062 };
0063
0064 static const struct mtk_pmic_regs mt6323_regs = {
0065     .keys_regs[MTK_PMIC_PWRKEY_INDEX] =
0066         MTK_PMIC_KEYS_REGS(MT6323_CHRSTATUS,
0067         0x2, MT6323_INT_MISC_CON, 0x10, MTK_PMIC_PWRKEY_RST),
0068     .keys_regs[MTK_PMIC_HOMEKEY_INDEX] =
0069         MTK_PMIC_KEYS_REGS(MT6323_CHRSTATUS,
0070         0x4, MT6323_INT_MISC_CON, 0x8, MTK_PMIC_HOMEKEY_RST),
0071     .pmic_rst_reg = MT6323_TOP_RST_MISC,
0072     .rst_lprst_mask = MTK_PMIC_RST_DU_MASK,
0073 };
0074
0075 static const struct mtk_pmic_regs mt6358_regs = {
0076     .keys_regs[MTK_PMIC_PWRKEY_INDEX] =
0077         MTK_PMIC_KEYS_REGS(MT6358_TOPSTATUS,
0078                    0x2, MT6358_PSC_TOP_INT_CON0, 0x5,
0079                    MTK_PMIC_PWRKEY_RST),
0080     .keys_regs[MTK_PMIC_HOMEKEY_INDEX] =
0081         MTK_PMIC_KEYS_REGS(MT6358_TOPSTATUS,
0082                    0x8, MT6358_PSC_TOP_INT_CON0, 0xa,
0083                    MTK_PMIC_HOMEKEY_RST),
0084     .pmic_rst_reg = MT6358_TOP_RST_MISC,
0085     .rst_lprst_mask = MTK_PMIC_RST_DU_MASK,
0086 };
0087
0088 struct mtk_pmic_keys_info {
0089     struct mtk_pmic_keys *keys;
0090     const struct mtk_pmic_keys_regs *regs;
0091     unsigned int keycode;
0092     int irq;
0093     int irq_r; /* optional: release irq if different */
0094     bool wakeup:1;
0095 };
0096
0097 struct mtk_pmic_keys {
0098     struct input_dev *input_dev;
0099     struct device *dev;
0100     struct regmap *regmap;
0101     struct mtk_pmic_keys_info keys[MTK_PMIC_MAX_KEY_COUNT];
0102 };
0103
0104 enum mtk_pmic_keys_lp_mode {
0105     LP_DISABLE,
0106     LP_ONEKEY,
0107     LP_TWOKEY,
0108 };
0109
0110 static void mtk_pmic_keys_lp_reset_setup(struct mtk_pmic_keys *keys,
0111                      const struct mtk_pmic_regs *regs)
0112 {
0113     const struct mtk_pmic_keys_regs *kregs_home, *kregs_pwr;
0114     u32 long_press_mode, long_press_debounce;
0115     u32 value, mask;
0116     int error;
0117
0118     kregs_home = keys->keys[MTK_PMIC_HOMEKEY_INDEX].regs;
0119     kregs_pwr = keys->keys[MTK_PMIC_PWRKEY_INDEX].regs;
0120
0121     error = of_property_read_u32(keys->dev->of_node, "power-off-time-sec",
0122                      &long_press_debounce);
0123     if (error)
0124         long_press_debounce = 0;
0125
0126     mask = regs->rst_lprst_mask;
0127     value = long_press_debounce << (ffs(regs->rst_lprst_mask) - 1);
0128
0129     error  = of_property_read_u32(keys->dev->of_node,
0130                       "mediatek,long-press-mode",
0131                       &long_press_mode);
0132     if (error)
0133         long_press_mode = LP_DISABLE;
0134
0135     switch (long_press_mode) {
0136     case LP_TWOKEY:
0137         value |= kregs_home->rst_en_mask;
0138         fallthrough;
0139
0140     case LP_ONEKEY:
0141         value |= kregs_pwr->rst_en_mask;
0142         fallthrough;
0143
0144     case LP_DISABLE:
0145         mask |= kregs_home->rst_en_mask;
0146         mask |= kregs_pwr->rst_en_mask;
0147         break;
0148
0149     default:
0150         break;
0151     }
0152
0153     regmap_update_bits(keys->regmap, regs->pmic_rst_reg, mask, value);
0154 }
0155
0156 static irqreturn_t mtk_pmic_keys_irq_handler_thread(int irq, void *data)
0157 {
0158     struct mtk_pmic_keys_info *info = data;
0159     u32 key_deb, pressed;
0160
0161     regmap_read(info->keys->regmap, info->regs->deb_reg, &key_deb);
0162
0163     key_deb &= info->regs->deb_mask;
0164
0165     pressed = !key_deb;
0166
0167     input_report_key(info->keys->input_dev, info->keycode, pressed);
0168     input_sync(info->keys->input_dev);
0169
0170     dev_dbg(info->keys->dev, "(%s) key =%d using PMIC\n",
0171          pressed ? "pressed" : "released", info->keycode);
0172
0173     return IRQ_HANDLED;
0174 }
0175
0176 static int mtk_pmic_key_setup(struct mtk_pmic_keys *keys,
0177         struct mtk_pmic_keys_info *info)
0178 {
0179     int ret;
0180
0181     info->keys = keys;
0182
0183     ret = regmap_update_bits(keys->regmap, info->regs->intsel_reg,
0184                  info->regs->intsel_mask,
0185                  info->regs->intsel_mask);
0186     if (ret < 0)
0187         return ret;
0188
0189     ret = devm_request_threaded_irq(keys->dev, info->irq, NULL,
0190                     mtk_pmic_keys_irq_handler_thread,
0191                     IRQF_ONESHOT | IRQF_TRIGGER_HIGH,
0192                     "mtk-pmic-keys", info);
0193     if (ret) {
0194         dev_err(keys->dev, "Failed to request IRQ: %d: %d\n",
0195             info->irq, ret);
0196         return ret;
0197     }
0198
0199     if (info->irq_r > 0) {
0200         ret = devm_request_threaded_irq(keys->dev, info->irq_r, NULL,
0201                         mtk_pmic_keys_irq_handler_thread,
0202                         IRQF_ONESHOT | IRQF_TRIGGER_HIGH,
0203                         "mtk-pmic-keys", info);
0204         if (ret) {
0205             dev_err(keys->dev, "Failed to request IRQ_r: %d: %d\n",
0206                 info->irq, ret);
0207             return ret;
0208         }
0209     }
0210
0211     input_set_capability(keys->input_dev, EV_KEY, info->keycode);
0212
0213     return 0;
0214 }
0215
0216 static int __maybe_unused mtk_pmic_keys_suspend(struct device *dev)
0217 {
0218     struct mtk_pmic_keys *keys = dev_get_drvdata(dev);
0219     int index;
0220
0221     for (index = 0; index < MTK_PMIC_MAX_KEY_COUNT; index++) {
0222         if (keys->keys[index].wakeup) {
0223             enable_irq_wake(keys->keys[index].irq);
0224             if (keys->keys[index].irq_r > 0)
0225                 enable_irq_wake(keys->keys[index].irq_r);
0226         }
0227     }
0228
0229     return 0;
0230 }
0231
0232 static int __maybe_unused mtk_pmic_keys_resume(struct device *dev)
0233 {
0234     struct mtk_pmic_keys *keys = dev_get_drvdata(dev);
0235     int index;
0236
0237     for (index = 0; index < MTK_PMIC_MAX_KEY_COUNT; index++) {
0238         if (keys->keys[index].wakeup) {
0239             disable_irq_wake(keys->keys[index].irq);
0240             if (keys->keys[index].irq_r > 0)
0241                 disable_irq_wake(keys->keys[index].irq_r);
0242         }
0243     }
0244
0245     return 0;
0246 }
0247
0248 static SIMPLE_DEV_PM_OPS(mtk_pmic_keys_pm_ops, mtk_pmic_keys_suspend,
0249             mtk_pmic_keys_resume);
0250
0251 static const struct of_device_id of_mtk_pmic_keys_match_tbl[] = {
0252     {
0253         .compatible = "mediatek,mt6397-keys",
0254         .data = &mt6397_regs,
0255     }, {
0256         .compatible = "mediatek,mt6323-keys",
0257         .data = &mt6323_regs,
0258     }, {
0259         .compatible = "mediatek,mt6358-keys",
0260         .data = &mt6358_regs,
0261     }, {
0262         /* sentinel */
0263     }
0264 };
0265 MODULE_DEVICE_TABLE(of, of_mtk_pmic_keys_match_tbl);
0266
0267 static int mtk_pmic_keys_probe(struct platform_device *pdev)
0268 {
0269     int error, index = 0;
0270     unsigned int keycount;
0271     struct mt6397_chip *pmic_chip = dev_get_drvdata(pdev->dev.parent);
0272     struct device_node *node = pdev->dev.of_node, *child;
0273     static const char *const irqnames[] = { "powerkey", "homekey" };
0274     static const char *const irqnames_r[] = { "powerkey_r", "homekey_r" };
0275     struct mtk_pmic_keys *keys;
0276     const struct mtk_pmic_regs *mtk_pmic_regs;
0277     struct input_dev *input_dev;
0278     const struct of_device_id *of_id =
0279         of_match_device(of_mtk_pmic_keys_match_tbl, &pdev->dev);
0280
0281     keys = devm_kzalloc(&pdev->dev, sizeof(*keys), GFP_KERNEL);
0282     if (!keys)
0283         return -ENOMEM;
0284
0285     keys->dev = &pdev->dev;
0286     keys->regmap = pmic_chip->regmap;
0287     mtk_pmic_regs = of_id->data;
0288
0289     keys->input_dev = input_dev = devm_input_allocate_device(keys->dev);
0290     if (!input_dev) {
0291         dev_err(keys->dev, "input allocate device fail.\n");
0292         return -ENOMEM;
0293     }
0294
0295     input_dev->name = "mtk-pmic-keys";
0296     input_dev->id.bustype = BUS_HOST;
0297     input_dev->id.vendor = 0x0001;
0298     input_dev->id.product = 0x0001;
0299     input_dev->id.version = 0x0001;
0300
0301     keycount = of_get_available_child_count(node);
0302     if (keycount > MTK_PMIC_MAX_KEY_COUNT ||
0303         keycount > ARRAY_SIZE(irqnames)) {
0304         dev_err(keys->dev, "too many keys defined (%d)\n", keycount);
0305         return -EINVAL;
0306     }
0307
0308     for_each_child_of_node(node, child) {
0309         keys->keys[index].regs = &mtk_pmic_regs->keys_regs[index];
0310
0311         keys->keys[index].irq =
0312             platform_get_irq_byname(pdev, irqnames[index]);
0313         if (keys->keys[index].irq < 0) {
0314             of_node_put(child);
0315             return keys->keys[index].irq;
0316         }
0317
0318         if (of_device_is_compatible(node, "mediatek,mt6358-keys")) {
0319             keys->keys[index].irq_r = platform_get_irq_byname(pdev,
0320                                       irqnames_r[index]);
0321
0322             if (keys->keys[index].irq_r < 0) {
0323                 of_node_put(child);
0324                 return keys->keys[index].irq_r;
0325             }
0326         }
0327
0328         error = of_property_read_u32(child,
0329             "linux,keycodes", &keys->keys[index].keycode);
0330         if (error) {
0331             dev_err(keys->dev,
0332                 "failed to read key:%d linux,keycode property: %d\n",
0333                 index, error);
0334             of_node_put(child);
0335             return error;
0336         }
0337
0338         if (of_property_read_bool(child, "wakeup-source"))
0339             keys->keys[index].wakeup = true;
0340
0341         error = mtk_pmic_key_setup(keys, &keys->keys[index]);
0342         if (error) {
0343             of_node_put(child);
0344             return error;
0345         }
0346
0347         index++;
0348     }
0349
0350     error = input_register_device(input_dev);
0351     if (error) {
0352         dev_err(&pdev->dev,
0353             "register input device failed (%d)\n", error);
0354         return error;
0355     }
0356
0357     mtk_pmic_keys_lp_reset_setup(keys, mtk_pmic_regs);
0358
0359     platform_set_drvdata(pdev, keys);
0360
0361     return 0;
0362 }
0363
0364 static struct platform_driver pmic_keys_pdrv = {
0365     .probe = mtk_pmic_keys_probe,
0366     .driver = {
0367            .name = "mtk-pmic-keys",
0368            .of_match_table = of_mtk_pmic_keys_match_tbl,
0369            .pm = &mtk_pmic_keys_pm_ops,
0370     },
0371 };
0372
0373 module_platform_driver(pmic_keys_pdrv);
0374
0375 MODULE_LICENSE("GPL v2");
0376 MODULE_AUTHOR("Chen Zhong <chen.zhong@mediatek.com>");
0377 MODULE_DESCRIPTION("MTK pmic-keys driver v0.1");