drivers/input/misc/palmas-pwrbutton.c

   1 /*
   2  * Texas Instruments' Palmas Power Button Input Driver
   3  *
   4  * Copyright (C) 2012-2014 Texas Instruments Incorporated - http://www.ti.com/
   5  *      Girish S Ghongdemath
   6  *      Nishanth Menon
   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  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  13  * kind, whether express or implied; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17
  18 #include <linux/init.h>
  19 #include <linux/input.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/kernel.h>
  22 #include <linux/mfd/palmas.h>
  23 #include <linux/module.h>
  24 #include <linux/of.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/slab.h>
  27
  28 #define PALMAS_LPK_TIME_MASK            0x0c
  29 #define PALMAS_PWRON_DEBOUNCE_MASK      0x03
  30 #define PALMAS_PWR_KEY_Q_TIME_MS        20
  31
  32 /**
  33  * struct palmas_pwron - Palmas power on data
  34  * @palmas:             pointer to palmas device
  35  * @input_dev:          pointer to input device
  36  * @input_work:         work for detecting release of key
  37  * @irq:                irq that we are hooked on to
  38  */
  39 struct palmas_pwron {
  40         struct palmas *palmas;
  41         struct input_dev *input_dev;
  42         struct delayed_work input_work;
  43         int irq;
  44 };
  45
  46 /**
  47  * struct palmas_pwron_config - configuration of palmas power on
  48  * @long_press_time_val:        value for long press h/w shutdown event
  49  * @pwron_debounce_val:         value for debounce of power button
  50  */
  51 struct palmas_pwron_config {
  52         u8 long_press_time_val;
  53         u8 pwron_debounce_val;
  54 };
  55
  56 /**
  57  * palmas_power_button_work() - Detects the button release event
  58  * @work:       work item to detect button release
  59  */
  60 static void palmas_power_button_work(struct work_struct *work)
  61 {
  62         struct palmas_pwron *pwron = container_of(work,
  63                                                   struct palmas_pwron,
  64                                                   input_work.work);
  65         struct input_dev *input_dev = pwron->input_dev;
  66         unsigned int reg;
  67         int error;
  68
  69         error = palmas_read(pwron->palmas, PALMAS_INTERRUPT_BASE,
  70                             PALMAS_INT1_LINE_STATE, &reg);
  71         if (error) {
  72                 dev_err(input_dev->dev.parent,
  73                         "Cannot read palmas PWRON status: %d\n", error);
  74         } else if (reg & BIT(1)) {
  75                 /* The button is released, report event. */
  76                 input_report_key(input_dev, KEY_POWER, 0);
  77                 input_sync(input_dev);
  78         } else {
  79                 /* The button is still depressed, keep checking. */
  80                 schedule_delayed_work(&pwron->input_work,
  81                                 msecs_to_jiffies(PALMAS_PWR_KEY_Q_TIME_MS));
  82         }
  83 }
  84
  85 /**
  86  * pwron_irq() - button press isr
  87  * @irq:                irq
  88  * @palmas_pwron:       pwron struct
  89  *
  90  * Return: IRQ_HANDLED
  91  */
  92 static irqreturn_t pwron_irq(int irq, void *palmas_pwron)
  93 {
  94         struct palmas_pwron *pwron = palmas_pwron;
  95         struct input_dev *input_dev = pwron->input_dev;
  96
  97         input_report_key(input_dev, KEY_POWER, 1);
  98         pm_wakeup_event(input_dev->dev.parent, 0);
  99         input_sync(input_dev);
 100
 101         mod_delayed_work(system_wq, &pwron->input_work,
 102                          msecs_to_jiffies(PALMAS_PWR_KEY_Q_TIME_MS));
 103
 104         return IRQ_HANDLED;
 105 }
 106
 107 /**
 108  * palmas_pwron_params_ofinit() - device tree parameter parser
 109  * @dev:        palmas button device
 110  * @config:     configuration params that this fills up
 111  */
 112 static void palmas_pwron_params_ofinit(struct device *dev,
 113                                        struct palmas_pwron_config *config)
 114 {
 115         struct device_node *np;
 116         u32 val;
 117         int i, error;
 118         u8 lpk_times[] = { 6, 8, 10, 12 };
 119         int pwr_on_deb_ms[] = { 15, 100, 500, 1000 };
 120
 121         memset(config, 0, sizeof(*config));
 122
 123         /* Default config parameters */
 124         config->long_press_time_val = ARRAY_SIZE(lpk_times) - 1;
 125
 126         np = dev->of_node;
 127         if (!np)
 128                 return;
 129
 130         error = of_property_read_u32(np, "ti,palmas-long-press-seconds", &val);
 131         if (!error) {
 132                 for (i = 0; i < ARRAY_SIZE(lpk_times); i++) {
 133                         if (val <= lpk_times[i]) {
 134                                 config->long_press_time_val = i;
 135                                 break;
 136                         }
 137                 }
 138         }
 139
 140         error = of_property_read_u32(np,
 141                                      "ti,palmas-pwron-debounce-milli-seconds",
 142                                      &val);
 143         if (!error) {
 144                 for (i = 0; i < ARRAY_SIZE(pwr_on_deb_ms); i++) {
 145                         if (val <= pwr_on_deb_ms[i]) {
 146                                 config->pwron_debounce_val = i;
 147                                 break;
 148                         }
 149                 }
 150         }
 151
 152         dev_info(dev, "h/w controlled shutdown duration=%d seconds\n",
 153                  lpk_times[config->long_press_time_val]);
 154 }
 155
 156 /**
 157  * palmas_pwron_probe() - probe
 158  * @pdev:       platform device for the button
 159  *
 160  * Return: 0 for successful probe else appropriate error
 161  */
 162 static int palmas_pwron_probe(struct platform_device *pdev)
 163 {
 164         struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
 165         struct device *dev = &pdev->dev;
 166         struct input_dev *input_dev;
 167         struct palmas_pwron *pwron;
 168         struct palmas_pwron_config config;
 169         int val;
 170         int error;
 171
 172         palmas_pwron_params_ofinit(dev, &config);
 173
 174         pwron = kzalloc(sizeof(*pwron), GFP_KERNEL);
 175         if (!pwron)
 176                 return -ENOMEM;
 177
 178         input_dev = input_allocate_device();
 179         if (!input_dev) {
 180                 dev_err(dev, "Can't allocate power button\n");
 181                 error = -ENOMEM;
 182                 goto err_free_mem;
 183         }
 184
 185         input_dev->name = "palmas_pwron";
 186         input_dev->phys = "palmas_pwron/input0";
 187         input_dev->dev.parent = dev;
 188
 189         input_set_capability(input_dev, EV_KEY, KEY_POWER);
 190
 191         /*
 192          * Setup default hardware shutdown option (long key press)
 193          * and debounce.
 194          */
 195         val = config.long_press_time_val << __ffs(PALMAS_LPK_TIME_MASK);
 196         val |= config.pwron_debounce_val << __ffs(PALMAS_PWRON_DEBOUNCE_MASK);
 197         error = palmas_update_bits(palmas, PALMAS_PMU_CONTROL_BASE,
 198                                    PALMAS_LONG_PRESS_KEY,
 199                                    PALMAS_LPK_TIME_MASK |
 200                                         PALMAS_PWRON_DEBOUNCE_MASK,
 201                                    val);
 202         if (error) {
 203                 dev_err(dev, "LONG_PRESS_KEY_UPDATE failed: %d\n", error);
 204                 goto err_free_input;
 205         }
 206
 207         pwron->palmas = palmas;
 208         pwron->input_dev = input_dev;
 209
 210         INIT_DELAYED_WORK(&pwron->input_work, palmas_power_button_work);
 211
 212         pwron->irq = platform_get_irq(pdev, 0);
 213         error = request_threaded_irq(pwron->irq, NULL, pwron_irq,
 214                                      IRQF_TRIGGER_HIGH |
 215                                         IRQF_TRIGGER_LOW |
 216                                         IRQF_ONESHOT,
 217                                      dev_name(dev), pwron);
 218         if (error) {
 219                 dev_err(dev, "Can't get IRQ for pwron: %d\n", error);
 220                 goto err_free_input;
 221         }
 222
 223         error = input_register_device(input_dev);
 224         if (error) {
 225                 dev_err(dev, "Can't register power button: %d\n", error);
 226                 goto err_free_irq;
 227         }
 228
 229         platform_set_drvdata(pdev, pwron);
 230         device_init_wakeup(dev, true);
 231
 232         return 0;
 233
 234 err_free_irq:
 235         cancel_delayed_work_sync(&pwron->input_work);
 236         free_irq(pwron->irq, pwron);
 237 err_free_input:
 238         input_free_device(input_dev);
 239 err_free_mem:
 240         kfree(pwron);
 241         return error;
 242 }
 243
 244 /**
 245  * palmas_pwron_remove() - Cleanup on removal
 246  * @pdev:       platform device for the button
 247  *
 248  * Return: 0
 249  */
 250 static int palmas_pwron_remove(struct platform_device *pdev)
 251 {
 252         struct palmas_pwron *pwron = platform_get_drvdata(pdev);
 253
 254         free_irq(pwron->irq, pwron);
 255         cancel_delayed_work_sync(&pwron->input_work);
 256
 257         input_unregister_device(pwron->input_dev);
 258         kfree(pwron);
 259
 260         return 0;
 261 }
 262
 263 /**
 264  * palmas_pwron_suspend() - suspend handler
 265  * @dev:        power button device
 266  *
 267  * Cancel all pending work items for the power button, setup irq for wakeup
 268  *
 269  * Return: 0
 270  */
 271 static int __maybe_unused palmas_pwron_suspend(struct device *dev)
 272 {
 273         struct platform_device *pdev = to_platform_device(dev);
 274         struct palmas_pwron *pwron = platform_get_drvdata(pdev);
 275
 276         cancel_delayed_work_sync(&pwron->input_work);
 277
 278         if (device_may_wakeup(dev))
 279                 enable_irq_wake(pwron->irq);
 280
 281         return 0;
 282 }
 283
 284 /**
 285  * palmas_pwron_resume() - resume handler
 286  * @dev:        power button device
 287  *
 288  * Just disable the wakeup capability of irq here.
 289  *
 290  * Return: 0
 291  */
 292 static int __maybe_unused palmas_pwron_resume(struct device *dev)
 293 {
 294         struct platform_device *pdev = to_platform_device(dev);
 295         struct palmas_pwron *pwron = platform_get_drvdata(pdev);
 296
 297         if (device_may_wakeup(dev))
 298                 disable_irq_wake(pwron->irq);
 299
 300         return 0;
 301 }
 302
 303 static SIMPLE_DEV_PM_OPS(palmas_pwron_pm,
 304                          palmas_pwron_suspend, palmas_pwron_resume);
 305
 306 #ifdef CONFIG_OF
 307 static const struct of_device_id of_palmas_pwr_match[] = {
 308         { .compatible = "ti,palmas-pwrbutton" },
 309         { },
 310 };
 311
 312 MODULE_DEVICE_TABLE(of, of_palmas_pwr_match);
 313 #endif
 314
 315 static struct platform_driver palmas_pwron_driver = {
 316         .probe  = palmas_pwron_probe,
 317         .remove = palmas_pwron_remove,
 318         .driver = {
 319                 .name   = "palmas_pwrbutton",
 320                 .of_match_table = of_match_ptr(of_palmas_pwr_match),
 321                 .pm     = &palmas_pwron_pm,
 322         },
 323 };
 324 module_platform_driver(palmas_pwron_driver);
 325
 326 MODULE_ALIAS("platform:palmas-pwrbutton");
 327 MODULE_DESCRIPTION("Palmas Power Button");
 328 MODULE_LICENSE("GPL v2");
 329 MODULE_AUTHOR("Texas Instruments Inc.");