Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Onkey driver for Actions Semi ATC260x PMICs.
0004  *
0005  * Copyright (c) 2020 Cristian Ciocaltea <cristian.ciocaltea@gmail.com>
0006  */
0007 
0008 #include <linux/bitfield.h>
0009 #include <linux/input.h>
0010 #include <linux/interrupt.h>
0011 #include <linux/mfd/atc260x/core.h>
0012 #include <linux/module.h>
0013 #include <linux/of.h>
0014 #include <linux/platform_device.h>
0015 #include <linux/regmap.h>
0016 
0017 /* <2s for short press, >2s for long press */
0018 #define KEY_PRESS_TIME_SEC  2
0019 
0020 /* Driver internals */
0021 enum atc260x_onkey_reset_status {
0022     KEY_RESET_HW_DEFAULT,
0023     KEY_RESET_DISABLED,
0024     KEY_RESET_USER_SEL,
0025 };
0026 
0027 struct atc260x_onkey_params {
0028     u32 reg_int_ctl;
0029     u32 kdwn_state_bm;
0030     u32 long_int_pnd_bm;
0031     u32 short_int_pnd_bm;
0032     u32 kdwn_int_pnd_bm;
0033     u32 press_int_en_bm;
0034     u32 kdwn_int_en_bm;
0035     u32 press_time_bm;
0036     u32 reset_en_bm;
0037     u32 reset_time_bm;
0038 };
0039 
0040 struct atc260x_onkey {
0041     struct atc260x *atc260x;
0042     const struct atc260x_onkey_params *params;
0043     struct input_dev *input_dev;
0044     struct delayed_work work;
0045     int irq;
0046 };
0047 
0048 static const struct atc260x_onkey_params atc2603c_onkey_params = {
0049     .reg_int_ctl        = ATC2603C_PMU_SYS_CTL2,
0050     .long_int_pnd_bm    = ATC2603C_PMU_SYS_CTL2_ONOFF_LONG_PRESS,
0051     .short_int_pnd_bm   = ATC2603C_PMU_SYS_CTL2_ONOFF_SHORT_PRESS,
0052     .kdwn_int_pnd_bm    = ATC2603C_PMU_SYS_CTL2_ONOFF_PRESS_PD,
0053     .press_int_en_bm    = ATC2603C_PMU_SYS_CTL2_ONOFF_INT_EN,
0054     .kdwn_int_en_bm     = ATC2603C_PMU_SYS_CTL2_ONOFF_PRESS_INT_EN,
0055     .kdwn_state_bm      = ATC2603C_PMU_SYS_CTL2_ONOFF_PRESS,
0056     .press_time_bm      = ATC2603C_PMU_SYS_CTL2_ONOFF_PRESS_TIME,
0057     .reset_en_bm        = ATC2603C_PMU_SYS_CTL2_ONOFF_PRESS_RESET_EN,
0058     .reset_time_bm      = ATC2603C_PMU_SYS_CTL2_ONOFF_RESET_TIME_SEL,
0059 };
0060 
0061 static const struct atc260x_onkey_params atc2609a_onkey_params = {
0062     .reg_int_ctl        = ATC2609A_PMU_SYS_CTL2,
0063     .long_int_pnd_bm    = ATC2609A_PMU_SYS_CTL2_ONOFF_LONG_PRESS,
0064     .short_int_pnd_bm   = ATC2609A_PMU_SYS_CTL2_ONOFF_SHORT_PRESS,
0065     .kdwn_int_pnd_bm    = ATC2609A_PMU_SYS_CTL2_ONOFF_PRESS_PD,
0066     .press_int_en_bm    = ATC2609A_PMU_SYS_CTL2_ONOFF_LSP_INT_EN,
0067     .kdwn_int_en_bm     = ATC2609A_PMU_SYS_CTL2_ONOFF_PRESS_INT_EN,
0068     .kdwn_state_bm      = ATC2609A_PMU_SYS_CTL2_ONOFF_PRESS,
0069     .press_time_bm      = ATC2609A_PMU_SYS_CTL2_ONOFF_PRESS_TIME,
0070     .reset_en_bm        = ATC2609A_PMU_SYS_CTL2_ONOFF_RESET_EN,
0071     .reset_time_bm      = ATC2609A_PMU_SYS_CTL2_ONOFF_RESET_TIME_SEL,
0072 };
0073 
0074 static int atc2603x_onkey_hw_init(struct atc260x_onkey *onkey,
0075                   enum atc260x_onkey_reset_status reset_status,
0076                   u32 reset_time, u32 press_time)
0077 {
0078     u32 reg_bm, reg_val;
0079 
0080     reg_bm = onkey->params->long_int_pnd_bm |
0081          onkey->params->short_int_pnd_bm |
0082          onkey->params->kdwn_int_pnd_bm |
0083          onkey->params->press_int_en_bm |
0084          onkey->params->kdwn_int_en_bm;
0085 
0086     reg_val = reg_bm | press_time;
0087     reg_bm |= onkey->params->press_time_bm;
0088 
0089     if (reset_status == KEY_RESET_DISABLED) {
0090         reg_bm |= onkey->params->reset_en_bm;
0091     } else if (reset_status == KEY_RESET_USER_SEL) {
0092         reg_bm |= onkey->params->reset_en_bm |
0093               onkey->params->reset_time_bm;
0094         reg_val |= onkey->params->reset_en_bm | reset_time;
0095     }
0096 
0097     return regmap_update_bits(onkey->atc260x->regmap,
0098                   onkey->params->reg_int_ctl, reg_bm, reg_val);
0099 }
0100 
0101 static void atc260x_onkey_query(struct atc260x_onkey *onkey)
0102 {
0103     u32 reg_bits;
0104     int ret, key_down;
0105 
0106     ret = regmap_read(onkey->atc260x->regmap,
0107               onkey->params->reg_int_ctl, &key_down);
0108     if (ret) {
0109         key_down = 1;
0110         dev_err(onkey->atc260x->dev,
0111             "Failed to read onkey status: %d\n", ret);
0112     } else {
0113         key_down &= onkey->params->kdwn_state_bm;
0114     }
0115 
0116     /*
0117      * The hardware generates interrupt only when the onkey pin is
0118      * asserted. Hence, the deassertion of the pin is simulated through
0119      * work queue.
0120      */
0121     if (key_down) {
0122         schedule_delayed_work(&onkey->work, msecs_to_jiffies(200));
0123         return;
0124     }
0125 
0126     /*
0127      * The key-down status bit is cleared when the On/Off button
0128      * is released.
0129      */
0130     input_report_key(onkey->input_dev, KEY_POWER, 0);
0131     input_sync(onkey->input_dev);
0132 
0133     reg_bits = onkey->params->long_int_pnd_bm |
0134            onkey->params->short_int_pnd_bm |
0135            onkey->params->kdwn_int_pnd_bm |
0136            onkey->params->press_int_en_bm |
0137            onkey->params->kdwn_int_en_bm;
0138 
0139     /* Clear key press pending events and enable key press interrupts. */
0140     regmap_update_bits(onkey->atc260x->regmap, onkey->params->reg_int_ctl,
0141                reg_bits, reg_bits);
0142 }
0143 
0144 static void atc260x_onkey_work(struct work_struct *work)
0145 {
0146     struct atc260x_onkey *onkey = container_of(work, struct atc260x_onkey,
0147                            work.work);
0148     atc260x_onkey_query(onkey);
0149 }
0150 
0151 static irqreturn_t atc260x_onkey_irq(int irq, void *data)
0152 {
0153     struct atc260x_onkey *onkey = data;
0154     int ret;
0155 
0156     /* Disable key press interrupts. */
0157     ret = regmap_update_bits(onkey->atc260x->regmap,
0158                  onkey->params->reg_int_ctl,
0159                  onkey->params->press_int_en_bm |
0160                  onkey->params->kdwn_int_en_bm, 0);
0161     if (ret)
0162         dev_err(onkey->atc260x->dev,
0163             "Failed to disable interrupts: %d\n", ret);
0164 
0165     input_report_key(onkey->input_dev, KEY_POWER, 1);
0166     input_sync(onkey->input_dev);
0167 
0168     atc260x_onkey_query(onkey);
0169 
0170     return IRQ_HANDLED;
0171 }
0172 
0173 static int atc260x_onkey_open(struct input_dev *dev)
0174 {
0175     struct atc260x_onkey *onkey = input_get_drvdata(dev);
0176 
0177     enable_irq(onkey->irq);
0178 
0179     return 0;
0180 }
0181 
0182 static void atc260x_onkey_close(struct input_dev *dev)
0183 {
0184     struct atc260x_onkey *onkey = input_get_drvdata(dev);
0185 
0186     disable_irq(onkey->irq);
0187     cancel_delayed_work_sync(&onkey->work);
0188 }
0189 
0190 static int atc260x_onkey_probe(struct platform_device *pdev)
0191 {
0192     struct atc260x *atc260x = dev_get_drvdata(pdev->dev.parent);
0193     struct atc260x_onkey *onkey;
0194     struct input_dev *input_dev;
0195     enum atc260x_onkey_reset_status reset_status;
0196     u32 press_time = KEY_PRESS_TIME_SEC, reset_time = 0;
0197     int val, error;
0198 
0199     onkey = devm_kzalloc(&pdev->dev, sizeof(*onkey), GFP_KERNEL);
0200     if (!onkey)
0201         return -ENOMEM;
0202 
0203     error = device_property_read_u32(pdev->dev.parent,
0204                      "reset-time-sec", &val);
0205     if (error) {
0206         reset_status = KEY_RESET_HW_DEFAULT;
0207     } else if (val) {
0208         if (val < 6 || val > 12) {
0209             dev_err(&pdev->dev, "reset-time-sec out of range\n");
0210             return -EINVAL;
0211         }
0212 
0213         reset_status = KEY_RESET_USER_SEL;
0214         reset_time = (val - 6) / 2;
0215     } else {
0216         reset_status = KEY_RESET_DISABLED;
0217         dev_dbg(&pdev->dev, "Disabled reset on long-press\n");
0218     }
0219 
0220     switch (atc260x->ic_type) {
0221     case ATC2603C:
0222         onkey->params = &atc2603c_onkey_params;
0223         press_time = FIELD_PREP(ATC2603C_PMU_SYS_CTL2_ONOFF_PRESS_TIME,
0224                     press_time);
0225         reset_time = FIELD_PREP(ATC2603C_PMU_SYS_CTL2_ONOFF_RESET_TIME_SEL,
0226                     reset_time);
0227         break;
0228     case ATC2609A:
0229         onkey->params = &atc2609a_onkey_params;
0230         press_time = FIELD_PREP(ATC2609A_PMU_SYS_CTL2_ONOFF_PRESS_TIME,
0231                     press_time);
0232         reset_time = FIELD_PREP(ATC2609A_PMU_SYS_CTL2_ONOFF_RESET_TIME_SEL,
0233                     reset_time);
0234         break;
0235     default:
0236         dev_err(&pdev->dev,
0237             "OnKey not supported for ATC260x PMIC type: %u\n",
0238             atc260x->ic_type);
0239         return -EINVAL;
0240     }
0241 
0242     input_dev = devm_input_allocate_device(&pdev->dev);
0243     if (!input_dev) {
0244         dev_err(&pdev->dev, "Failed to allocate input device\n");
0245         return -ENOMEM;
0246     }
0247 
0248     onkey->input_dev = input_dev;
0249     onkey->atc260x = atc260x;
0250 
0251     input_dev->name = "atc260x-onkey";
0252     input_dev->phys = "atc260x-onkey/input0";
0253     input_dev->open = atc260x_onkey_open;
0254     input_dev->close = atc260x_onkey_close;
0255 
0256     input_set_capability(input_dev, EV_KEY, KEY_POWER);
0257     input_set_drvdata(input_dev, onkey);
0258 
0259     INIT_DELAYED_WORK(&onkey->work, atc260x_onkey_work);
0260 
0261     onkey->irq = platform_get_irq(pdev, 0);
0262     if (onkey->irq < 0)
0263         return onkey->irq;
0264 
0265     error = devm_request_threaded_irq(&pdev->dev, onkey->irq, NULL,
0266                       atc260x_onkey_irq, IRQF_ONESHOT,
0267                       dev_name(&pdev->dev), onkey);
0268     if (error) {
0269         dev_err(&pdev->dev,
0270             "Failed to register IRQ %d: %d\n", onkey->irq, error);
0271         return error;
0272     }
0273 
0274     /* Keep IRQ disabled until atc260x_onkey_open() is called. */
0275     disable_irq(onkey->irq);
0276 
0277     error = input_register_device(input_dev);
0278     if (error) {
0279         dev_err(&pdev->dev,
0280             "Failed to register input device: %d\n", error);
0281         return error;
0282     }
0283 
0284     error = atc2603x_onkey_hw_init(onkey, reset_status,
0285                        reset_time, press_time);
0286     if (error)
0287         return error;
0288 
0289     device_init_wakeup(&pdev->dev, true);
0290 
0291     return 0;
0292 }
0293 
0294 static struct platform_driver atc260x_onkey_driver = {
0295     .probe  = atc260x_onkey_probe,
0296     .driver = {
0297         .name = "atc260x-onkey",
0298     },
0299 };
0300 
0301 module_platform_driver(atc260x_onkey_driver);
0302 
0303 MODULE_DESCRIPTION("Onkey driver for ATC260x PMICs");
0304 MODULE_AUTHOR("Cristian Ciocaltea <cristian.ciocaltea@gmail.com>");
0305 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!