drivers/input/keyboard/mtk-pmic-keys.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2017 MediaTek, Inc.
   4  *
   5  * Author: Chen Zhong <chen.zhong@mediatek.com>
   6  */
   7
   8 #include <linux/input.h>
   9 #include <linux/interrupt.h>
  10 #include <linux/kernel.h>
  11 #include <linux/mfd/mt6323/registers.h>
  12 #include <linux/mfd/mt6358/registers.h>
  13 #include <linux/mfd/mt6397/core.h>
  14 #include <linux/mfd/mt6397/registers.h>
  15 #include <linux/module.h>
  16 #include <linux/of_device.h>
  17 #include <linux/of.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/regmap.h>
  20
  21 #define MTK_PMIC_PWRKEY_RST_EN_MASK     0x1
  22 #define MTK_PMIC_PWRKEY_RST_EN_SHIFT    6
  23 #define MTK_PMIC_HOMEKEY_RST_EN_MASK    0x1
  24 #define MTK_PMIC_HOMEKEY_RST_EN_SHIFT   5
  25 #define MTK_PMIC_RST_DU_MASK            0x3
  26 #define MTK_PMIC_RST_DU_SHIFT           8
  27
  28 #define MTK_PMIC_PWRKEY_RST             \
  29         (MTK_PMIC_PWRKEY_RST_EN_MASK << MTK_PMIC_PWRKEY_RST_EN_SHIFT)
  30 #define MTK_PMIC_HOMEKEY_RST            \
  31         (MTK_PMIC_HOMEKEY_RST_EN_MASK << MTK_PMIC_HOMEKEY_RST_EN_SHIFT)
  32
  33 #define MTK_PMIC_PWRKEY_INDEX   0
  34 #define MTK_PMIC_HOMEKEY_INDEX  1
  35 #define MTK_PMIC_MAX_KEY_COUNT  2
  36
  37 struct mtk_pmic_keys_regs {
  38         u32 deb_reg;
  39         u32 deb_mask;
  40         u32 intsel_reg;
  41         u32 intsel_mask;
  42 };
  43
  44 #define MTK_PMIC_KEYS_REGS(_deb_reg, _deb_mask,         \
  45         _intsel_reg, _intsel_mask)                      \
  46 {                                                       \
  47         .deb_reg                = _deb_reg,             \
  48         .deb_mask               = _deb_mask,            \
  49         .intsel_reg             = _intsel_reg,          \
  50         .intsel_mask            = _intsel_mask,         \
  51 }
  52
  53 struct mtk_pmic_regs {
  54         const struct mtk_pmic_keys_regs keys_regs[MTK_PMIC_MAX_KEY_COUNT];
  55         u32 pmic_rst_reg;
  56 };
  57
  58 static const struct mtk_pmic_regs mt6397_regs = {
  59         .keys_regs[MTK_PMIC_PWRKEY_INDEX] =
  60                 MTK_PMIC_KEYS_REGS(MT6397_CHRSTATUS,
  61                 0x8, MT6397_INT_RSV, 0x10),
  62         .keys_regs[MTK_PMIC_HOMEKEY_INDEX] =
  63                 MTK_PMIC_KEYS_REGS(MT6397_OCSTATUS2,
  64                 0x10, MT6397_INT_RSV, 0x8),
  65         .pmic_rst_reg = MT6397_TOP_RST_MISC,
  66 };
  67
  68 static const struct mtk_pmic_regs mt6323_regs = {
  69         .keys_regs[MTK_PMIC_PWRKEY_INDEX] =
  70                 MTK_PMIC_KEYS_REGS(MT6323_CHRSTATUS,
  71                 0x2, MT6323_INT_MISC_CON, 0x10),
  72         .keys_regs[MTK_PMIC_HOMEKEY_INDEX] =
  73                 MTK_PMIC_KEYS_REGS(MT6323_CHRSTATUS,
  74                 0x4, MT6323_INT_MISC_CON, 0x8),
  75         .pmic_rst_reg = MT6323_TOP_RST_MISC,
  76 };
  77
  78 static const struct mtk_pmic_regs mt6358_regs = {
  79         .keys_regs[MTK_PMIC_PWRKEY_INDEX] =
  80                 MTK_PMIC_KEYS_REGS(MT6358_TOPSTATUS,
  81                                    0x2, MT6358_PSC_TOP_INT_CON0, 0x5),
  82         .keys_regs[MTK_PMIC_HOMEKEY_INDEX] =
  83                 MTK_PMIC_KEYS_REGS(MT6358_TOPSTATUS,
  84                                    0x8, MT6358_PSC_TOP_INT_CON0, 0xa),
  85         .pmic_rst_reg = MT6358_TOP_RST_MISC,
  86 };
  87
  88 struct mtk_pmic_keys_info {
  89         struct mtk_pmic_keys *keys;
  90         const struct mtk_pmic_keys_regs *regs;
  91         unsigned int keycode;
  92         int irq;
  93         int irq_r; /* optional: release irq if different */
  94         bool wakeup:1;
  95 };
  96
  97 struct mtk_pmic_keys {
  98         struct input_dev *input_dev;
  99         struct device *dev;
 100         struct regmap *regmap;
 101         struct mtk_pmic_keys_info keys[MTK_PMIC_MAX_KEY_COUNT];
 102 };
 103
 104 enum mtk_pmic_keys_lp_mode {
 105         LP_DISABLE,
 106         LP_ONEKEY,
 107         LP_TWOKEY,
 108 };
 109
 110 static void mtk_pmic_keys_lp_reset_setup(struct mtk_pmic_keys *keys,
 111                 u32 pmic_rst_reg)
 112 {
 113         int ret;
 114         u32 long_press_mode, long_press_debounce;
 115
 116         ret = of_property_read_u32(keys->dev->of_node,
 117                 "power-off-time-sec", &long_press_debounce);
 118         if (ret)
 119                 long_press_debounce = 0;
 120
 121         regmap_update_bits(keys->regmap, pmic_rst_reg,
 122                            MTK_PMIC_RST_DU_MASK << MTK_PMIC_RST_DU_SHIFT,
 123                            long_press_debounce << MTK_PMIC_RST_DU_SHIFT);
 124
 125         ret = of_property_read_u32(keys->dev->of_node,
 126                 "mediatek,long-press-mode", &long_press_mode);
 127         if (ret)
 128                 long_press_mode = LP_DISABLE;
 129
 130         switch (long_press_mode) {
 131         case LP_ONEKEY:
 132                 regmap_update_bits(keys->regmap, pmic_rst_reg,
 133                                    MTK_PMIC_PWRKEY_RST,
 134                                    MTK_PMIC_PWRKEY_RST);
 135                 regmap_update_bits(keys->regmap, pmic_rst_reg,
 136                                    MTK_PMIC_HOMEKEY_RST,
 137                                    0);
 138                 break;
 139         case LP_TWOKEY:
 140                 regmap_update_bits(keys->regmap, pmic_rst_reg,
 141                                    MTK_PMIC_PWRKEY_RST,
 142                                    MTK_PMIC_PWRKEY_RST);
 143                 regmap_update_bits(keys->regmap, pmic_rst_reg,
 144                                    MTK_PMIC_HOMEKEY_RST,
 145                                    MTK_PMIC_HOMEKEY_RST);
 146                 break;
 147         case LP_DISABLE:
 148                 regmap_update_bits(keys->regmap, pmic_rst_reg,
 149                                    MTK_PMIC_PWRKEY_RST,
 150                                    0);
 151                 regmap_update_bits(keys->regmap, pmic_rst_reg,
 152                                    MTK_PMIC_HOMEKEY_RST,
 153                                    0);
 154                 break;
 155         default:
 156                 break;
 157         }
 158 }
 159
 160 static irqreturn_t mtk_pmic_keys_irq_handler_thread(int irq, void *data)
 161 {
 162         struct mtk_pmic_keys_info *info = data;
 163         u32 key_deb, pressed;
 164
 165         regmap_read(info->keys->regmap, info->regs->deb_reg, &key_deb);
 166
 167         key_deb &= info->regs->deb_mask;
 168
 169         pressed = !key_deb;
 170
 171         input_report_key(info->keys->input_dev, info->keycode, pressed);
 172         input_sync(info->keys->input_dev);
 173
 174         dev_dbg(info->keys->dev, "(%s) key =%d using PMIC\n",
 175                  pressed ? "pressed" : "released", info->keycode);
 176
 177         return IRQ_HANDLED;
 178 }
 179
 180 static int mtk_pmic_key_setup(struct mtk_pmic_keys *keys,
 181                 struct mtk_pmic_keys_info *info)
 182 {
 183         int ret;
 184
 185         info->keys = keys;
 186
 187         ret = regmap_update_bits(keys->regmap, info->regs->intsel_reg,
 188                                  info->regs->intsel_mask,
 189                                  info->regs->intsel_mask);
 190         if (ret < 0)
 191                 return ret;
 192
 193         ret = devm_request_threaded_irq(keys->dev, info->irq, NULL,
 194                                         mtk_pmic_keys_irq_handler_thread,
 195                                         IRQF_ONESHOT | IRQF_TRIGGER_HIGH,
 196                                         "mtk-pmic-keys", info);
 197         if (ret) {
 198                 dev_err(keys->dev, "Failed to request IRQ: %d: %d\n",
 199                         info->irq, ret);
 200                 return ret;
 201         }
 202
 203         if (info->irq_r > 0) {
 204                 ret = devm_request_threaded_irq(keys->dev, info->irq_r, NULL,
 205                                                 mtk_pmic_keys_irq_handler_thread,
 206                                                 IRQF_ONESHOT | IRQF_TRIGGER_HIGH,
 207                                                 "mtk-pmic-keys", info);
 208                 if (ret) {
 209                         dev_err(keys->dev, "Failed to request IRQ_r: %d: %d\n",
 210                                 info->irq, ret);
 211                         return ret;
 212                 }
 213         }
 214
 215         input_set_capability(keys->input_dev, EV_KEY, info->keycode);
 216
 217         return 0;
 218 }
 219
 220 static int __maybe_unused mtk_pmic_keys_suspend(struct device *dev)
 221 {
 222         struct mtk_pmic_keys *keys = dev_get_drvdata(dev);
 223         int index;
 224
 225         for (index = 0; index < MTK_PMIC_MAX_KEY_COUNT; index++) {
 226                 if (keys->keys[index].wakeup) {
 227                         enable_irq_wake(keys->keys[index].irq);
 228                         if (keys->keys[index].irq_r > 0)
 229                                 enable_irq_wake(keys->keys[index].irq_r);
 230                 }
 231         }
 232
 233         return 0;
 234 }
 235
 236 static int __maybe_unused mtk_pmic_keys_resume(struct device *dev)
 237 {
 238         struct mtk_pmic_keys *keys = dev_get_drvdata(dev);
 239         int index;
 240
 241         for (index = 0; index < MTK_PMIC_MAX_KEY_COUNT; index++) {
 242                 if (keys->keys[index].wakeup) {
 243                         disable_irq_wake(keys->keys[index].irq);
 244                         if (keys->keys[index].irq_r > 0)
 245                                 disable_irq_wake(keys->keys[index].irq_r);
 246                 }
 247         }
 248
 249         return 0;
 250 }
 251
 252 static SIMPLE_DEV_PM_OPS(mtk_pmic_keys_pm_ops, mtk_pmic_keys_suspend,
 253                         mtk_pmic_keys_resume);
 254
 255 static const struct of_device_id of_mtk_pmic_keys_match_tbl[] = {
 256         {
 257                 .compatible = "mediatek,mt6397-keys",
 258                 .data = &mt6397_regs,
 259         }, {
 260                 .compatible = "mediatek,mt6323-keys",
 261                 .data = &mt6323_regs,
 262         }, {
 263                 .compatible = "mediatek,mt6358-keys",
 264                 .data = &mt6358_regs,
 265         }, {
 266                 /* sentinel */
 267         }
 268 };
 269 MODULE_DEVICE_TABLE(of, of_mtk_pmic_keys_match_tbl);
 270
 271 static int mtk_pmic_keys_probe(struct platform_device *pdev)
 272 {
 273         int error, index = 0;
 274         unsigned int keycount;
 275         struct mt6397_chip *pmic_chip = dev_get_drvdata(pdev->dev.parent);
 276         struct device_node *node = pdev->dev.of_node, *child;
 277         static const char *const irqnames[] = { "powerkey", "homekey" };
 278         static const char *const irqnames_r[] = { "powerkey_r", "homekey_r" };
 279         struct mtk_pmic_keys *keys;
 280         const struct mtk_pmic_regs *mtk_pmic_regs;
 281         struct input_dev *input_dev;
 282         const struct of_device_id *of_id =
 283                 of_match_device(of_mtk_pmic_keys_match_tbl, &pdev->dev);
 284
 285         keys = devm_kzalloc(&pdev->dev, sizeof(*keys), GFP_KERNEL);
 286         if (!keys)
 287                 return -ENOMEM;
 288
 289         keys->dev = &pdev->dev;
 290         keys->regmap = pmic_chip->regmap;
 291         mtk_pmic_regs = of_id->data;
 292
 293         keys->input_dev = input_dev = devm_input_allocate_device(keys->dev);
 294         if (!input_dev) {
 295                 dev_err(keys->dev, "input allocate device fail.\n");
 296                 return -ENOMEM;
 297         }
 298
 299         input_dev->name = "mtk-pmic-keys";
 300         input_dev->id.bustype = BUS_HOST;
 301         input_dev->id.vendor = 0x0001;
 302         input_dev->id.product = 0x0001;
 303         input_dev->id.version = 0x0001;
 304
 305         keycount = of_get_available_child_count(node);
 306         if (keycount > MTK_PMIC_MAX_KEY_COUNT ||
 307             keycount > ARRAY_SIZE(irqnames)) {
 308                 dev_err(keys->dev, "too many keys defined (%d)\n", keycount);
 309                 return -EINVAL;
 310         }
 311
 312         for_each_child_of_node(node, child) {
 313                 keys->keys[index].regs = &mtk_pmic_regs->keys_regs[index];
 314
 315                 keys->keys[index].irq =
 316                         platform_get_irq_byname(pdev, irqnames[index]);
 317                 if (keys->keys[index].irq < 0) {
 318                         of_node_put(child);
 319                         return keys->keys[index].irq;
 320                 }
 321
 322                 if (of_device_is_compatible(node, "mediatek,mt6358-keys")) {
 323                         keys->keys[index].irq_r = platform_get_irq_byname(pdev,
 324                                                                           irqnames_r[index]);
 325
 326                         if (keys->keys[index].irq_r < 0) {
 327                                 of_node_put(child);
 328                                 return keys->keys[index].irq_r;
 329                         }
 330                 }
 331
 332                 error = of_property_read_u32(child,
 333                         "linux,keycodes", &keys->keys[index].keycode);
 334                 if (error) {
 335                         dev_err(keys->dev,
 336                                 "failed to read key:%d linux,keycode property: %d\n",
 337                                 index, error);
 338                         of_node_put(child);
 339                         return error;
 340                 }
 341
 342                 if (of_property_read_bool(child, "wakeup-source"))
 343                         keys->keys[index].wakeup = true;
 344
 345                 error = mtk_pmic_key_setup(keys, &keys->keys[index]);
 346                 if (error) {
 347                         of_node_put(child);
 348                         return error;
 349                 }
 350
 351                 index++;
 352         }
 353
 354         error = input_register_device(input_dev);
 355         if (error) {
 356                 dev_err(&pdev->dev,
 357                         "register input device failed (%d)\n", error);
 358                 return error;
 359         }
 360
 361         mtk_pmic_keys_lp_reset_setup(keys, mtk_pmic_regs->pmic_rst_reg);
 362
 363         platform_set_drvdata(pdev, keys);
 364
 365         return 0;
 366 }
 367
 368 static struct platform_driver pmic_keys_pdrv = {
 369         .probe = mtk_pmic_keys_probe,
 370         .driver = {
 371                    .name = "mtk-pmic-keys",
 372                    .of_match_table = of_mtk_pmic_keys_match_tbl,
 373                    .pm = &mtk_pmic_keys_pm_ops,
 374         },
 375 };
 376
 377 module_platform_driver(pmic_keys_pdrv);
 378
 379 MODULE_LICENSE("GPL v2");
 380 MODULE_AUTHOR("Chen Zhong <chen.zhong@mediatek.com>");
 381 MODULE_DESCRIPTION("MTK pmic-keys driver v0.1");