drivers/input/misc/palmas-pwrbutton.c - linux - Git at Google

 /*
  * Texas Instruments' Palmas Power Button Input Driver
  *
  * Copyright (C) 2012-2014 Texas Instruments Incorporated - http://www.ti.com/
  *	Girish S Ghongdemath
  *	Nishanth Menon
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  * kind, whether express or implied; without even the implied warranty
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */

 #include <linux/bitfield.h>
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
 #include <linux/mfd/palmas.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>

 #define PALMAS_LPK_TIME_MASK		0x0c
 #define PALMAS_PWRON_DEBOUNCE_MASK	0x03
 #define PALMAS_PWR_KEY_Q_TIME_MS	20

 /**
  * struct palmas_pwron - Palmas power on data
  * @palmas:		pointer to palmas device
  * @input_dev:		pointer to input device
  * @input_work:		work for detecting release of key
  * @irq:		irq that we are hooked on to
  */
 struct palmas_pwron {
 	struct palmas *palmas;
 	struct input_dev *input_dev;
 	struct delayed_work input_work;
 	int irq;
 };

 /**
  * struct palmas_pwron_config - configuration of palmas power on
  * @long_press_time_val:	value for long press h/w shutdown event
  * @pwron_debounce_val:		value for debounce of power button
  */
 struct palmas_pwron_config {
 	u8 long_press_time_val;
 	u8 pwron_debounce_val;
 };

 /**
  * palmas_power_button_work() - Detects the button release event
  * @work:	work item to detect button release
  */
 static void palmas_power_button_work(struct work_struct *work)
 {
 	struct palmas_pwron *pwron = container_of(work,
 						  struct palmas_pwron,
 						  input_work.work);
 	struct input_dev *input_dev = pwron->input_dev;
 	unsigned int reg;
 	int error;

 	error = palmas_read(pwron->palmas, PALMAS_INTERRUPT_BASE,
 			    PALMAS_INT1_LINE_STATE, &reg);
 	if (error) {
 		dev_err(input_dev->dev.parent,
 			"Cannot read palmas PWRON status: %d\n", error);
 	} else if (reg & BIT(1)) {
 		/* The button is released, report event. */
 		input_report_key(input_dev, KEY_POWER, 0);
 		input_sync(input_dev);
 	} else {
 		/* The button is still depressed, keep checking. */
 		schedule_delayed_work(&pwron->input_work,
 				msecs_to_jiffies(PALMAS_PWR_KEY_Q_TIME_MS));
 	}
 }

 /**
  * pwron_irq() - button press isr
  * @irq:		irq
  * @palmas_pwron:	pwron struct
  *
  * Return: IRQ_HANDLED
  */
 static irqreturn_t pwron_irq(int irq, void *palmas_pwron)
 {
 	struct palmas_pwron *pwron = palmas_pwron;
 	struct input_dev *input_dev = pwron->input_dev;

 	input_report_key(input_dev, KEY_POWER, 1);
 	pm_wakeup_event(input_dev->dev.parent, 0);
 	input_sync(input_dev);

 	mod_delayed_work(system_wq, &pwron->input_work,
 			 msecs_to_jiffies(PALMAS_PWR_KEY_Q_TIME_MS));

 	return IRQ_HANDLED;
 }

 /**
  * palmas_pwron_params_ofinit() - device tree parameter parser
  * @dev:	palmas button device
  * @config:	configuration params that this fills up
  */
 static void palmas_pwron_params_ofinit(struct device *dev,
 				       struct palmas_pwron_config *config)
 {
 	struct device_node *np;
 	u32 val;
 	int i, error;
 	static const u8 lpk_times[] = { 6, 8, 10, 12 };
 	static const int pwr_on_deb_ms[] = { 15, 100, 500, 1000 };

 	memset(config, 0, sizeof(*config));

 	/* Default config parameters */
 	config->long_press_time_val = ARRAY_SIZE(lpk_times) - 1;

 	np = dev->of_node;
 	if (!np)
 		return;

 	error = of_property_read_u32(np, "ti,palmas-long-press-seconds", &val);
 	if (!error) {
 		for (i = 0; i < ARRAY_SIZE(lpk_times); i++) {
 			if (val <= lpk_times[i]) {
 				config->long_press_time_val = i;
 				break;
 			}
 		}
 	}

 	error = of_property_read_u32(np,
 				     "ti,palmas-pwron-debounce-milli-seconds",
 				     &val);
 	if (!error) {
 		for (i = 0; i < ARRAY_SIZE(pwr_on_deb_ms); i++) {
 			if (val <= pwr_on_deb_ms[i]) {
 				config->pwron_debounce_val = i;
 				break;
 			}
 		}
 	}

 	dev_info(dev, "h/w controlled shutdown duration=%d seconds\n",
 		 lpk_times[config->long_press_time_val]);
 }

 /**
  * palmas_pwron_probe() - probe
  * @pdev:	platform device for the button
  *
  * Return: 0 for successful probe else appropriate error
  */
 static int palmas_pwron_probe(struct platform_device *pdev)
 {
 	struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
 	struct device *dev = &pdev->dev;
 	struct input_dev *input_dev;
 	struct palmas_pwron *pwron;
 	struct palmas_pwron_config config;
 	int val;
 	int error;

 	palmas_pwron_params_ofinit(dev, &config);

 	pwron = kzalloc(sizeof(*pwron), GFP_KERNEL);
 	if (!pwron)
 		return -ENOMEM;

 	input_dev = input_allocate_device();
 	if (!input_dev) {
 		dev_err(dev, "Can't allocate power button\n");
 		error = -ENOMEM;
 		goto err_free_mem;
 	}

 	input_dev->name = "palmas_pwron";
 	input_dev->phys = "palmas_pwron/input0";
 	input_dev->dev.parent = dev;

 	input_set_capability(input_dev, EV_KEY, KEY_POWER);

 	/*
 	 * Setup default hardware shutdown option (long key press)
 	 * and debounce.
 	 */
 	val = FIELD_PREP(PALMAS_LPK_TIME_MASK, config.long_press_time_val) |
 	      FIELD_PREP(PALMAS_PWRON_DEBOUNCE_MASK, config.pwron_debounce_val);
 	error = palmas_update_bits(palmas, PALMAS_PMU_CONTROL_BASE,
 				   PALMAS_LONG_PRESS_KEY,
 				   PALMAS_LPK_TIME_MASK |
 					PALMAS_PWRON_DEBOUNCE_MASK,
 				   val);
 	if (error) {
 		dev_err(dev, "LONG_PRESS_KEY_UPDATE failed: %d\n", error);
 		goto err_free_input;
 	}

 	pwron->palmas = palmas;
 	pwron->input_dev = input_dev;

 	INIT_DELAYED_WORK(&pwron->input_work, palmas_power_button_work);

 	pwron->irq = platform_get_irq(pdev, 0);
 	if (pwron->irq < 0) {
 		error = pwron->irq;
 		goto err_free_input;
 	}

 	error = request_threaded_irq(pwron->irq, NULL, pwron_irq,
 				     IRQF_TRIGGER_HIGH |
 					IRQF_TRIGGER_LOW |
 					IRQF_ONESHOT,
 				     dev_name(dev), pwron);
 	if (error) {
 		dev_err(dev, "Can't get IRQ for pwron: %d\n", error);
 		goto err_free_input;
 	}

 	error = input_register_device(input_dev);
 	if (error) {
 		dev_err(dev, "Can't register power button: %d\n", error);
 		goto err_free_irq;
 	}

 	platform_set_drvdata(pdev, pwron);
 	device_init_wakeup(dev, true);

 	return 0;

 err_free_irq:
 	cancel_delayed_work_sync(&pwron->input_work);
 	free_irq(pwron->irq, pwron);
 err_free_input:
 	input_free_device(input_dev);
 err_free_mem:
 	kfree(pwron);
 	return error;
 }

 /**
  * palmas_pwron_remove() - Cleanup on removal
  * @pdev:	platform device for the button
  *
  * Return: 0
  */
 static int palmas_pwron_remove(struct platform_device *pdev)
 {
 	struct palmas_pwron *pwron = platform_get_drvdata(pdev);

 	free_irq(pwron->irq, pwron);
 	cancel_delayed_work_sync(&pwron->input_work);

 	input_unregister_device(pwron->input_dev);
 	kfree(pwron);

 	return 0;
 }

 /**
  * palmas_pwron_suspend() - suspend handler
  * @dev:	power button device
  *
  * Cancel all pending work items for the power button, setup irq for wakeup
  *
  * Return: 0
  */
 static int __maybe_unused palmas_pwron_suspend(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	struct palmas_pwron *pwron = platform_get_drvdata(pdev);

 	cancel_delayed_work_sync(&pwron->input_work);

 	if (device_may_wakeup(dev))
 		enable_irq_wake(pwron->irq);

 	return 0;
 }

 /**
  * palmas_pwron_resume() - resume handler
  * @dev:	power button device
  *
  * Just disable the wakeup capability of irq here.
  *
  * Return: 0
  */
 static int __maybe_unused palmas_pwron_resume(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	struct palmas_pwron *pwron = platform_get_drvdata(pdev);

 	if (device_may_wakeup(dev))
 		disable_irq_wake(pwron->irq);

 	return 0;
 }

 static SIMPLE_DEV_PM_OPS(palmas_pwron_pm,
 			 palmas_pwron_suspend, palmas_pwron_resume);

 #ifdef CONFIG_OF
 static const struct of_device_id of_palmas_pwr_match[] = {
 	{ .compatible = "ti,palmas-pwrbutton" },
 	{ },
 };

 MODULE_DEVICE_TABLE(of, of_palmas_pwr_match);
 #endif

 static struct platform_driver palmas_pwron_driver = {
 	.probe	= palmas_pwron_probe,
 	.remove	= palmas_pwron_remove,
 	.driver	= {
 		.name	= "palmas_pwrbutton",
 		.of_match_table = of_match_ptr(of_palmas_pwr_match),
 		.pm	= &palmas_pwron_pm,
 	},
 };
 module_platform_driver(palmas_pwron_driver);

 MODULE_ALIAS("platform:palmas-pwrbutton");
 MODULE_DESCRIPTION("Palmas Power Button");
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Texas Instruments Inc.");
	/*
	* Texas Instruments' Palmas Power Button Input Driver
	*
	* Copyright (C) 2012-2014 Texas Instruments Incorporated - http://www.ti.com/
	* Girish S Ghongdemath
	* Nishanth Menon
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*
	* This program is distributed "as is" WITHOUT ANY WARRANTY of any
	* kind, whether express or implied; without even the implied warranty
	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/

	#include <linux/bitfield.h>
	#include <linux/init.h>
	#include <linux/input.h>
	#include <linux/interrupt.h>
	#include <linux/kernel.h>
	#include <linux/mfd/palmas.h>
	#include <linux/module.h>
	#include <linux/of.h>
	#include <linux/platform_device.h>
	#include <linux/slab.h>

	#define PALMAS_LPK_TIME_MASK 0x0c
	#define PALMAS_PWRON_DEBOUNCE_MASK 0x03
	#define PALMAS_PWR_KEY_Q_TIME_MS 20

	/**
	* struct palmas_pwron - Palmas power on data
	* @palmas: pointer to palmas device
	* @input_dev: pointer to input device
	* @input_work: work for detecting release of key
	* @irq: irq that we are hooked on to
	*/
	struct palmas_pwron {
	struct palmas *palmas;
	struct input_dev *input_dev;
	struct delayed_work input_work;
	int irq;
	};

	/**
	* struct palmas_pwron_config - configuration of palmas power on
	* @long_press_time_val: value for long press h/w shutdown event
	* @pwron_debounce_val: value for debounce of power button
	*/
	struct palmas_pwron_config {
	u8 long_press_time_val;
	u8 pwron_debounce_val;
	};

	/**
	* palmas_power_button_work() - Detects the button release event
	* @work: work item to detect button release
	*/
	static void palmas_power_button_work(struct work_struct *work)
	{
	struct palmas_pwron *pwron = container_of(work,
	struct palmas_pwron,
	input_work.work);
	struct input_dev *input_dev = pwron->input_dev;
	unsigned int reg;
	int error;

	error = palmas_read(pwron->palmas, PALMAS_INTERRUPT_BASE,
	PALMAS_INT1_LINE_STATE, &reg);
	if (error) {
	dev_err(input_dev->dev.parent,
	"Cannot read palmas PWRON status: %d\n", error);
	} else if (reg & BIT(1)) {
	/* The button is released, report event. */
	input_report_key(input_dev, KEY_POWER, 0);
	input_sync(input_dev);
	} else {
	/* The button is still depressed, keep checking. */
	schedule_delayed_work(&pwron->input_work,
	msecs_to_jiffies(PALMAS_PWR_KEY_Q_TIME_MS));
	}
	}

	/**
	* pwron_irq() - button press isr
	* @irq: irq
	* @palmas_pwron: pwron struct
	*
	* Return: IRQ_HANDLED
	*/
	static irqreturn_t pwron_irq(int irq, void *palmas_pwron)
	{
	struct palmas_pwron *pwron = palmas_pwron;
	struct input_dev *input_dev = pwron->input_dev;

	input_report_key(input_dev, KEY_POWER, 1);
	pm_wakeup_event(input_dev->dev.parent, 0);
	input_sync(input_dev);

	mod_delayed_work(system_wq, &pwron->input_work,
	msecs_to_jiffies(PALMAS_PWR_KEY_Q_TIME_MS));

	return IRQ_HANDLED;
	}

	/**
	* palmas_pwron_params_ofinit() - device tree parameter parser
	* @dev: palmas button device
	* @config: configuration params that this fills up
	*/
	static void palmas_pwron_params_ofinit(struct device *dev,
	struct palmas_pwron_config *config)
	{
	struct device_node *np;
	u32 val;
	int i, error;
	static const u8 lpk_times[] = { 6, 8, 10, 12 };
	static const int pwr_on_deb_ms[] = { 15, 100, 500, 1000 };

	memset(config, 0, sizeof(*config));

	/* Default config parameters */
	config->long_press_time_val = ARRAY_SIZE(lpk_times) - 1;

	np = dev->of_node;
	if (!np)
	return;

	error = of_property_read_u32(np, "ti,palmas-long-press-seconds", &val);
	if (!error) {
	for (i = 0; i < ARRAY_SIZE(lpk_times); i++) {
	if (val <= lpk_times[i]) {
	config->long_press_time_val = i;
	break;
	}
	}
	}

	error = of_property_read_u32(np,
	"ti,palmas-pwron-debounce-milli-seconds",
	&val);
	if (!error) {
	for (i = 0; i < ARRAY_SIZE(pwr_on_deb_ms); i++) {
	if (val <= pwr_on_deb_ms[i]) {
	config->pwron_debounce_val = i;
	break;
	}
	}
	}

	dev_info(dev, "h/w controlled shutdown duration=%d seconds\n",
	lpk_times[config->long_press_time_val]);
	}

	/**
	* palmas_pwron_probe() - probe
	* @pdev: platform device for the button
	*
	* Return: 0 for successful probe else appropriate error
	*/
	static int palmas_pwron_probe(struct platform_device *pdev)
	{
	struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
	struct device *dev = &pdev->dev;
	struct input_dev *input_dev;
	struct palmas_pwron *pwron;
	struct palmas_pwron_config config;
	int val;
	int error;

	palmas_pwron_params_ofinit(dev, &config);

	pwron = kzalloc(sizeof(*pwron), GFP_KERNEL);
	if (!pwron)
	return -ENOMEM;

	input_dev = input_allocate_device();
	if (!input_dev) {
	dev_err(dev, "Can't allocate power button\n");
	error = -ENOMEM;
	goto err_free_mem;
	}

	input_dev->name = "palmas_pwron";
	input_dev->phys = "palmas_pwron/input0";
	input_dev->dev.parent = dev;

	input_set_capability(input_dev, EV_KEY, KEY_POWER);

	/*
	* Setup default hardware shutdown option (long key press)
	* and debounce.
	*/
	val = FIELD_PREP(PALMAS_LPK_TIME_MASK, config.long_press_time_val) \|
	FIELD_PREP(PALMAS_PWRON_DEBOUNCE_MASK, config.pwron_debounce_val);
	error = palmas_update_bits(palmas, PALMAS_PMU_CONTROL_BASE,
	PALMAS_LONG_PRESS_KEY,
	PALMAS_LPK_TIME_MASK \|
	PALMAS_PWRON_DEBOUNCE_MASK,
	val);
	if (error) {
	dev_err(dev, "LONG_PRESS_KEY_UPDATE failed: %d\n", error);
	goto err_free_input;
	}

	pwron->palmas = palmas;
	pwron->input_dev = input_dev;

	INIT_DELAYED_WORK(&pwron->input_work, palmas_power_button_work);

	pwron->irq = platform_get_irq(pdev, 0);
	if (pwron->irq < 0) {
	error = pwron->irq;
	goto err_free_input;
	}

	error = request_threaded_irq(pwron->irq, NULL, pwron_irq,
	IRQF_TRIGGER_HIGH \|
	IRQF_TRIGGER_LOW \|
	IRQF_ONESHOT,
	dev_name(dev), pwron);
	if (error) {
	dev_err(dev, "Can't get IRQ for pwron: %d\n", error);
	goto err_free_input;
	}

	error = input_register_device(input_dev);
	if (error) {
	dev_err(dev, "Can't register power button: %d\n", error);
	goto err_free_irq;
	}

	platform_set_drvdata(pdev, pwron);
	device_init_wakeup(dev, true);

	return 0;

	err_free_irq:
	cancel_delayed_work_sync(&pwron->input_work);
	free_irq(pwron->irq, pwron);
	err_free_input:
	input_free_device(input_dev);
	err_free_mem:
	kfree(pwron);
	return error;
	}

	/**
	* palmas_pwron_remove() - Cleanup on removal
	* @pdev: platform device for the button
	*
	* Return: 0
	*/
	static int palmas_pwron_remove(struct platform_device *pdev)
	{
	struct palmas_pwron *pwron = platform_get_drvdata(pdev);

	free_irq(pwron->irq, pwron);
	cancel_delayed_work_sync(&pwron->input_work);

	input_unregister_device(pwron->input_dev);
	kfree(pwron);

	return 0;
	}

	/**
	* palmas_pwron_suspend() - suspend handler
	* @dev: power button device
	*
	* Cancel all pending work items for the power button, setup irq for wakeup
	*
	* Return: 0
	*/
	static int __maybe_unused palmas_pwron_suspend(struct device *dev)
	{
	struct platform_device *pdev = to_platform_device(dev);
	struct palmas_pwron *pwron = platform_get_drvdata(pdev);

	cancel_delayed_work_sync(&pwron->input_work);

	if (device_may_wakeup(dev))
	enable_irq_wake(pwron->irq);

	return 0;
	}

	/**
	* palmas_pwron_resume() - resume handler
	* @dev: power button device
	*
	* Just disable the wakeup capability of irq here.
	*
	* Return: 0
	*/
	static int __maybe_unused palmas_pwron_resume(struct device *dev)
	{
	struct platform_device *pdev = to_platform_device(dev);
	struct palmas_pwron *pwron = platform_get_drvdata(pdev);

	if (device_may_wakeup(dev))
	disable_irq_wake(pwron->irq);

	return 0;
	}

	static SIMPLE_DEV_PM_OPS(palmas_pwron_pm,
	palmas_pwron_suspend, palmas_pwron_resume);

	#ifdef CONFIG_OF
	static const struct of_device_id of_palmas_pwr_match[] = {
	{ .compatible = "ti,palmas-pwrbutton" },
	{ },
	};

	MODULE_DEVICE_TABLE(of, of_palmas_pwr_match);
	#endif

	static struct platform_driver palmas_pwron_driver = {
	.probe = palmas_pwron_probe,
	.remove = palmas_pwron_remove,
	.driver = {
	.name = "palmas_pwrbutton",
	.of_match_table = of_match_ptr(of_palmas_pwr_match),
	.pm = &palmas_pwron_pm,
	},
	};
	module_platform_driver(palmas_pwron_driver);

	MODULE_ALIAS("platform:palmas-pwrbutton");
	MODULE_DESCRIPTION("Palmas Power Button");
	MODULE_LICENSE("GPL v2");
	MODULE_AUTHOR("Texas Instruments Inc.");