LXR linux/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 */
  39struct 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 */
  51struct 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 */
  60static 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 */
  92static 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 */
 112static 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 */
 162static 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
 234err_free_irq:
 235        cancel_delayed_work_sync(&pwron->input_work);
 236        free_irq(pwron->irq, pwron);
 237err_free_input:
 238        input_free_device(input_dev);
 239err_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 */
 250static 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 */
 271static 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 */
 292static 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
 303static SIMPLE_DEV_PM_OPS(palmas_pwron_pm,
 304                         palmas_pwron_suspend, palmas_pwron_resume);
 305
 306#ifdef CONFIG_OF
 307static const struct of_device_id of_palmas_pwr_match[] = {
 308        { .compatible = "ti,palmas-pwrbutton" },
 309        { },
 310};
 311
 312MODULE_DEVICE_TABLE(of, of_palmas_pwr_match);
 313#endif
 314
 315static 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};
 324module_platform_driver(palmas_pwron_driver);
 325
 326MODULE_ALIAS("platform:palmas-pwrbutton");
 327MODULE_DESCRIPTION("Palmas Power Button");
 328MODULE_LICENSE("GPL v2");
 329MODULE_AUTHOR("Texas Instruments Inc.");
 330