[linux-2.6-block.git] / drivers / power / reset / gpio-poweroff.c

/*
 * Toggles a GPIO pin to power down a device
 *
 * Jamie Lentin <jm@lentin.co.uk>
 * Andrew Lunn <andrew@lunn.ch>
 *
 * Copyright (C) 2012 Jamie Lentin
 *
 * 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.
 *
 */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <linux/of_platform.h>
#include <linux/of_gpio.h>
#include <linux/module.h>

/*
 * Hold configuration here, cannot be more than one instance of the driver
 * since pm_power_off itself is global.
 */
static int gpio_num = -1;
static int gpio_active_low;

static void gpio_poweroff_do_poweroff(void)
{
	BUG_ON(!gpio_is_valid(gpio_num));

	/* drive it active, also inactive->active edge */
	gpio_direction_output(gpio_num, !gpio_active_low);
	mdelay(100);
	/* drive inactive, also active->inactive edge */
	gpio_set_value(gpio_num, gpio_active_low);
	mdelay(100);

	/* drive it active, also inactive->active edge */
	gpio_set_value(gpio_num, !gpio_active_low);

	/* give it some time */
	mdelay(3000);

	WARN_ON(1);
}

static int gpio_poweroff_probe(struct platform_device *pdev)
{
	enum of_gpio_flags flags;
	bool input = false;
	int ret;

	/* If a pm_power_off function has already been added, leave it alone */
	if (pm_power_off != NULL) {
		pr_err("%s: pm_power_off function already registered",
		       __func__);
		return -EBUSY;
	}

	gpio_num = of_get_gpio_flags(pdev->dev.of_node, 0, &flags);
	if (!gpio_is_valid(gpio_num))
		return gpio_num;

	gpio_active_low = flags & OF_GPIO_ACTIVE_LOW;

	input = of_property_read_bool(pdev->dev.of_node, "input");

	ret = gpio_request(gpio_num, "poweroff-gpio");
	if (ret) {
		pr_err("%s: Could not get GPIO %d", __func__, gpio_num);
		return ret;
	}
	if (input) {
		if (gpio_direction_input(gpio_num)) {
			pr_err("Could not set direction of GPIO %d to input",
			       gpio_num);
			goto err;
		}
	} else {
		if (gpio_direction_output(gpio_num, gpio_active_low)) {
			pr_err("Could not set direction of GPIO %d", gpio_num);
			goto err;
		}
	}

	pm_power_off = &gpio_poweroff_do_poweroff;
	return 0;

err:
	gpio_free(gpio_num);
	return -ENODEV;
}

static int gpio_poweroff_remove(struct platform_device *pdev)
{
	gpio_free(gpio_num);
	if (pm_power_off == &gpio_poweroff_do_poweroff)
		pm_power_off = NULL;

	return 0;
}

static const struct of_device_id of_gpio_poweroff_match[] = {
	{ .compatible = "gpio-poweroff", },
	{},
};

static struct platform_driver gpio_poweroff_driver = {
	.probe = gpio_poweroff_probe,
	.remove = gpio_poweroff_remove,
	.driver = {
		.name = "poweroff-gpio",
		.owner = THIS_MODULE,
		.of_match_table = of_gpio_poweroff_match,
	},
};

module_platform_driver(gpio_poweroff_driver);

MODULE_AUTHOR("Jamie Lentin <jm@lentin.co.uk>");
MODULE_DESCRIPTION("GPIO poweroff driver");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:poweroff-gpio");
Commit	Line	Data
96ff0f5c JL	1	/*
	2	* Toggles a GPIO pin to power down a device
	3	*
	4	* Jamie Lentin <jm@lentin.co.uk>
	5	* Andrew Lunn <andrew@lunn.ch>
	6	*
	7	* Copyright (C) 2012 Jamie Lentin
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*
	13	*/
	14	#include <linux/kernel.h>
	15	#include <linux/init.h>
	16	#include <linux/delay.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/gpio.h>
	19	#include <linux/of_platform.h>
	20	#include <linux/of_gpio.h>
	21	#include <linux/module.h>
	22
	23	/*
	24	* Hold configuration here, cannot be more than one instance of the driver
	25	* since pm_power_off itself is global.
	26	*/
	27	static int gpio_num = -1;
	28	static int gpio_active_low;
	29
	30	static void gpio_poweroff_do_poweroff(void)
	31	{
5343527b	32	BUG_ON(!gpio_is_valid(gpio_num));
96ff0f5c	33
5343527b	34	/* drive it active, also inactive->active edge */
96ff0f5c JL	35	gpio_direction_output(gpio_num, !gpio_active_low);
96ff0f5c JL	36	mdelay(100);
5343527b	37	/* drive inactive, also active->inactive edge */
96ff0f5c JL	38	gpio_set_value(gpio_num, gpio_active_low);
96ff0f5c JL	39	mdelay(100);
5343527b AL	40
5343527b AL	41	/* drive it active, also inactive->active edge */
96ff0f5c JL	42	gpio_set_value(gpio_num, !gpio_active_low);
	43
	44	/* give it some time */
	45	mdelay(3000);
	46
	47	WARN_ON(1);
	48	}
	49
6d2cea4f	50	static int gpio_poweroff_probe(struct platform_device *pdev)
96ff0f5c JL	51	{
	52	enum of_gpio_flags flags;
	53	bool input = false;
	54	int ret;
	55
	56	/* If a pm_power_off function has already been added, leave it alone */
	57	if (pm_power_off != NULL) {
	58	pr_err("%s: pm_power_off function already registered",
	59	__func__);
	60	return -EBUSY;
	61	}
	62
	63	gpio_num = of_get_gpio_flags(pdev->dev.of_node, 0, &flags);
5343527b AL	64	if (!gpio_is_valid(gpio_num))
	65	return gpio_num;
	66
96ff0f5c JL	67	gpio_active_low = flags & OF_GPIO_ACTIVE_LOW;
96ff0f5c JL	68
5343527b	69	input = of_property_read_bool(pdev->dev.of_node, "input");
96ff0f5c JL	70
	71	ret = gpio_request(gpio_num, "poweroff-gpio");
	72	if (ret) {
	73	pr_err("%s: Could not get GPIO %d", __func__, gpio_num);
	74	return ret;
	75	}
	76	if (input) {
	77	if (gpio_direction_input(gpio_num)) {
	78	pr_err("Could not set direction of GPIO %d to input",
	79	gpio_num);
	80	goto err;
	81	}
	82	} else {
	83	if (gpio_direction_output(gpio_num, gpio_active_low)) {
	84	pr_err("Could not set direction of GPIO %d", gpio_num);
	85	goto err;
	86	}
	87	}
	88
	89	pm_power_off = &gpio_poweroff_do_poweroff;
	90	return 0;
	91
	92	err:
	93	gpio_free(gpio_num);
	94	return -ENODEV;
	95	}
	96
6d2cea4f	97	static int gpio_poweroff_remove(struct platform_device *pdev)
96ff0f5c	98	{
5343527b	99	gpio_free(gpio_num);
96ff0f5c JL	100	if (pm_power_off == &gpio_poweroff_do_poweroff)
	101	pm_power_off = NULL;
	102
	103	return 0;
	104	}
	105
	106	static const struct of_device_id of_gpio_poweroff_match[] = {
	107	{ .compatible = "gpio-poweroff", },
	108	{},
	109	};
	110
	111	static struct platform_driver gpio_poweroff_driver = {
	112	.probe = gpio_poweroff_probe,
6d2cea4f	113	.remove = gpio_poweroff_remove,
96ff0f5c	114	.driver = {
5343527b AL	115	.name = "poweroff-gpio",
	116	.owner = THIS_MODULE,
	117	.of_match_table = of_gpio_poweroff_match,
	118	},
96ff0f5c JL	119	};
	120
	121	module_platform_driver(gpio_poweroff_driver);
	122
	123	MODULE_AUTHOR("Jamie Lentin <jm@lentin.co.uk>");
	124	MODULE_DESCRIPTION("GPIO poweroff driver");
5343527b	125	MODULE_LICENSE("GPL v2");
96ff0f5c	126	MODULE_ALIAS("platform:poweroff-gpio");