[deliverable/linux.git] / net / rfkill / rfkill-gpio.c

/*
 * Copyright (c) 2011, NVIDIA Corporation.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

#include <linux/gpio.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/rfkill.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/slab.h>
#include <linux/acpi.h>
#include <linux/gpio/consumer.h>

#include <linux/rfkill-gpio.h>

struct rfkill_gpio_data {
	const char		*name;
	enum rfkill_type	type;
	struct gpio_desc	*reset_gpio;
	struct gpio_desc	*shutdown_gpio;

	struct rfkill		*rfkill_dev;
	char			*reset_name;
	char			*shutdown_name;
	struct clk		*clk;

	bool			clk_enabled;
};

static int rfkill_gpio_set_power(void *data, bool blocked)
{
	struct rfkill_gpio_data *rfkill = data;

	if (blocked) {
		gpiod_set_value(rfkill->shutdown_gpio, 0);
		gpiod_set_value(rfkill->reset_gpio, 0);
		if (!IS_ERR(rfkill->clk) && rfkill->clk_enabled)
			clk_disable(rfkill->clk);
	} else {
		if (!IS_ERR(rfkill->clk) && !rfkill->clk_enabled)
			clk_enable(rfkill->clk);
		gpiod_set_value(rfkill->reset_gpio, 1);
		gpiod_set_value(rfkill->shutdown_gpio, 1);
	}

	rfkill->clk_enabled = blocked;

	return 0;
}

static const struct rfkill_ops rfkill_gpio_ops = {
	.set_block = rfkill_gpio_set_power,
};

static int rfkill_gpio_acpi_probe(struct device *dev,
				  struct rfkill_gpio_data *rfkill)
{
	const struct acpi_device_id *id;

	id = acpi_match_device(dev->driver->acpi_match_table, dev);
	if (!id)
		return -ENODEV;

	rfkill->name = dev_name(dev);
	rfkill->type = (unsigned)id->driver_data;

	return 0;
}

static int rfkill_gpio_probe(struct platform_device *pdev)
{
	struct rfkill_gpio_platform_data *pdata = pdev->dev.platform_data;
	struct rfkill_gpio_data *rfkill;
	const char *clk_name = NULL;
	struct gpio_desc *gpio;
	int ret;
	int len;

	rfkill = devm_kzalloc(&pdev->dev, sizeof(*rfkill), GFP_KERNEL);
	if (!rfkill)
		return -ENOMEM;

	if (ACPI_HANDLE(&pdev->dev)) {
		ret = rfkill_gpio_acpi_probe(&pdev->dev, rfkill);
		if (ret)
			return ret;
	} else if (pdata) {
		clk_name = pdata->power_clk_name;
		rfkill->name = pdata->name;
		rfkill->type = pdata->type;
	} else {
		return -ENODEV;
	}

	len = strlen(rfkill->name);
	rfkill->reset_name = devm_kzalloc(&pdev->dev, len + 7, GFP_KERNEL);
	if (!rfkill->reset_name)
		return -ENOMEM;

	rfkill->shutdown_name = devm_kzalloc(&pdev->dev, len + 10, GFP_KERNEL);
	if (!rfkill->shutdown_name)
		return -ENOMEM;

	snprintf(rfkill->reset_name, len + 6 , "%s_reset", rfkill->name);
	snprintf(rfkill->shutdown_name, len + 9, "%s_shutdown", rfkill->name);

	rfkill->clk = devm_clk_get(&pdev->dev, clk_name);

	gpio = devm_gpiod_get_index(&pdev->dev, rfkill->reset_name, 0);
	if (!IS_ERR(gpio)) {
		ret = gpiod_direction_output(gpio, 0);
		if (ret)
			return ret;
		rfkill->reset_gpio = gpio;
	}

	gpio = devm_gpiod_get_index(&pdev->dev, rfkill->shutdown_name, 1);
	if (!IS_ERR(gpio)) {
		ret = gpiod_direction_output(gpio, 0);
		if (ret)
			return ret;
		rfkill->shutdown_gpio = gpio;
	}

	/* Make sure at-least one of the GPIO is defined and that
	 * a name is specified for this instance
	 */
	if ((!rfkill->reset_gpio && !rfkill->shutdown_gpio) || !rfkill->name) {
		dev_err(&pdev->dev, "invalid platform data\n");
		return -EINVAL;
	}

	if (pdata && pdata->gpio_runtime_setup) {
		ret = pdata->gpio_runtime_setup(pdev);
		if (ret) {
			dev_err(&pdev->dev, "can't set up gpio\n");
			return ret;
		}
	}

	rfkill->rfkill_dev = rfkill_alloc(rfkill->name, &pdev->dev,
					  rfkill->type, &rfkill_gpio_ops,
					  rfkill);
	if (!rfkill->rfkill_dev)
		return -ENOMEM;

	ret = rfkill_register(rfkill->rfkill_dev);
	if (ret < 0)
		return ret;

	platform_set_drvdata(pdev, rfkill);

	dev_info(&pdev->dev, "%s device registered.\n", rfkill->name);

	return 0;
}

static int rfkill_gpio_remove(struct platform_device *pdev)
{
	struct rfkill_gpio_data *rfkill = platform_get_drvdata(pdev);
	struct rfkill_gpio_platform_data *pdata = pdev->dev.platform_data;

	if (pdata && pdata->gpio_runtime_close)
		pdata->gpio_runtime_close(pdev);
	rfkill_unregister(rfkill->rfkill_dev);
	rfkill_destroy(rfkill->rfkill_dev);

	return 0;
}

static const struct acpi_device_id rfkill_acpi_match[] = {
	{ "BCM4752", RFKILL_TYPE_GPS },
	{ },
};

static struct platform_driver rfkill_gpio_driver = {
	.probe = rfkill_gpio_probe,
	.remove = rfkill_gpio_remove,
	.driver = {
		.name = "rfkill_gpio",
		.owner = THIS_MODULE,
		.acpi_match_table = ACPI_PTR(rfkill_acpi_match),
	},
};

module_platform_driver(rfkill_gpio_driver);

MODULE_DESCRIPTION("gpio rfkill");
MODULE_AUTHOR("NVIDIA");
MODULE_LICENSE("GPL");
Commit	Line	Data
7176ba23 RK	1	/*
	2	* Copyright (c) 2011, NVIDIA Corporation.
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along
	15	* with this program; if not, write to the Free Software Foundation, Inc.,
	16	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17	*/
	18
	19	#include <linux/gpio.h>
	20	#include <linux/init.h>
	21	#include <linux/kernel.h>
	22	#include <linux/module.h>
	23	#include <linux/rfkill.h>
	24	#include <linux/platform_device.h>
	25	#include <linux/clk.h>
	26	#include <linux/slab.h>
ef91ffaa	27	#include <linux/acpi.h>
2111cad6	28	#include <linux/gpio/consumer.h>
7176ba23 RK	29
	30	#include <linux/rfkill-gpio.h>
	31
7176ba23	32	struct rfkill_gpio_data {
262c91ee HK	33	const char *name;
262c91ee HK	34	enum rfkill_type type;
2111cad6 HK	35	struct gpio_desc *reset_gpio;
2111cad6 HK	36	struct gpio_desc *shutdown_gpio;
262c91ee HK	37
	38	struct rfkill *rfkill_dev;
	39	char *reset_name;
	40	char *shutdown_name;
	41	struct clk *clk;
	42
	43	bool clk_enabled;
7176ba23 RK	44	};
	45
	46	static int rfkill_gpio_set_power(void *data, bool blocked)
	47	{
	48	struct rfkill_gpio_data *rfkill = data;
	49
	50	if (blocked) {
2111cad6 HK	51	gpiod_set_value(rfkill->shutdown_gpio, 0);
2111cad6 HK	52	gpiod_set_value(rfkill->reset_gpio, 0);
f02ae59b HK	53	if (!IS_ERR(rfkill->clk) && rfkill->clk_enabled)
f02ae59b HK	54	clk_disable(rfkill->clk);
7176ba23	55	} else {
f02ae59b HK	56	if (!IS_ERR(rfkill->clk) && !rfkill->clk_enabled)
f02ae59b HK	57	clk_enable(rfkill->clk);
2111cad6 HK	58	gpiod_set_value(rfkill->reset_gpio, 1);
2111cad6 HK	59	gpiod_set_value(rfkill->shutdown_gpio, 1);
7176ba23 RK	60	}
7176ba23 RK	61
f02ae59b	62	rfkill->clk_enabled = blocked;
7176ba23 RK	63
	64	return 0;
	65	}
	66
	67	static const struct rfkill_ops rfkill_gpio_ops = {
	68	.set_block = rfkill_gpio_set_power,
	69	};
	70
ef91ffaa HK	71	static int rfkill_gpio_acpi_probe(struct device *dev,
	72	struct rfkill_gpio_data *rfkill)
	73	{
	74	const struct acpi_device_id *id;
	75
	76	id = acpi_match_device(dev->driver->acpi_match_table, dev);
	77	if (!id)
	78	return -ENODEV;
	79
	80	rfkill->name = dev_name(dev);
	81	rfkill->type = (unsigned)id->driver_data;
ef91ffaa HK	82
	83	return 0;
	84	}
	85
7176ba23 RK	86	static int rfkill_gpio_probe(struct platform_device *pdev)
7176ba23 RK	87	{
7176ba23	88	struct rfkill_gpio_platform_data *pdata = pdev->dev.platform_data;
262c91ee HK	89	struct rfkill_gpio_data *rfkill;
262c91ee HK	90	const char *clk_name = NULL;
2111cad6 HK	91	struct gpio_desc *gpio;
	92	int ret;
	93	int len;
7176ba23	94
262c91ee HK	95	rfkill = devm_kzalloc(&pdev->dev, sizeof(*rfkill), GFP_KERNEL);
	96	if (!rfkill)
	97	return -ENOMEM;
	98
ef91ffaa HK	99	if (ACPI_HANDLE(&pdev->dev)) {
	100	ret = rfkill_gpio_acpi_probe(&pdev->dev, rfkill);
	101	if (ret)
	102	return ret;
	103	} else if (pdata) {
262c91ee HK	104	clk_name = pdata->power_clk_name;
	105	rfkill->name = pdata->name;
	106	rfkill->type = pdata->type;
262c91ee HK	107	} else {
262c91ee HK	108	return -ENODEV;
7176ba23 RK	109	}
7176ba23 RK	110
262c91ee	111	len = strlen(rfkill->name);
5e7ca393 HK	112	rfkill->reset_name = devm_kzalloc(&pdev->dev, len + 7, GFP_KERNEL);
	113	if (!rfkill->reset_name)
	114	return -ENOMEM;
7176ba23	115
5e7ca393 HK	116	rfkill->shutdown_name = devm_kzalloc(&pdev->dev, len + 10, GFP_KERNEL);
	117	if (!rfkill->shutdown_name)
	118	return -ENOMEM;
7176ba23	119
262c91ee HK	120	snprintf(rfkill->reset_name, len + 6 , "%s_reset", rfkill->name);
262c91ee HK	121	snprintf(rfkill->shutdown_name, len + 9, "%s_shutdown", rfkill->name);
7176ba23	122
262c91ee	123	rfkill->clk = devm_clk_get(&pdev->dev, clk_name);
7176ba23	124
2111cad6 HK	125	gpio = devm_gpiod_get_index(&pdev->dev, rfkill->reset_name, 0);
	126	if (!IS_ERR(gpio)) {
	127	ret = gpiod_direction_output(gpio, 0);
	128	if (ret)
5e7ca393	129	return ret;
2111cad6 HK	130	rfkill->reset_gpio = gpio;
	131	}
	132
	133	gpio = devm_gpiod_get_index(&pdev->dev, rfkill->shutdown_name, 1);
	134	if (!IS_ERR(gpio)) {
	135	ret = gpiod_direction_output(gpio, 0);
	136	if (ret)
	137	return ret;
	138	rfkill->shutdown_gpio = gpio;
7176ba23 RK	139	}
7176ba23 RK	140
2111cad6 HK	141	/* Make sure at-least one of the GPIO is defined and that
	142	* a name is specified for this instance
	143	*/
	144	if ((!rfkill->reset_gpio && !rfkill->shutdown_gpio) \|\| !rfkill->name) {
	145	dev_err(&pdev->dev, "invalid platform data\n");
	146	return -EINVAL;
	147	}
	148
	149	if (pdata && pdata->gpio_runtime_setup) {
	150	ret = pdata->gpio_runtime_setup(pdev);
7176ba23	151	if (ret) {
2111cad6	152	dev_err(&pdev->dev, "can't set up gpio\n");
5e7ca393	153	return ret;
7176ba23 RK	154	}
	155	}
	156
262c91ee HK	157	rfkill->rfkill_dev = rfkill_alloc(rfkill->name, &pdev->dev,
	158	rfkill->type, &rfkill_gpio_ops,
	159	rfkill);
5e7ca393 HK	160	if (!rfkill->rfkill_dev)
5e7ca393 HK	161	return -ENOMEM;
7176ba23 RK	162
	163	ret = rfkill_register(rfkill->rfkill_dev);
	164	if (ret < 0)
5e7ca393	165	return ret;
7176ba23 RK	166
	167	platform_set_drvdata(pdev, rfkill);
	168
262c91ee	169	dev_info(&pdev->dev, "%s device registered.\n", rfkill->name);
7176ba23 RK	170
7176ba23 RK	171	return 0;
7176ba23 RK	172	}
	173
	174	static int rfkill_gpio_remove(struct platform_device *pdev)
	175	{
	176	struct rfkill_gpio_data *rfkill = platform_get_drvdata(pdev);
e209c5a7	177	struct rfkill_gpio_platform_data *pdata = pdev->dev.platform_data;
7176ba23	178
262c91ee	179	if (pdata && pdata->gpio_runtime_close)
e209c5a7	180	pdata->gpio_runtime_close(pdev);
7176ba23 RK	181	rfkill_unregister(rfkill->rfkill_dev);
7176ba23 RK	182	rfkill_destroy(rfkill->rfkill_dev);
7176ba23 RK	183
	184	return 0;
	185	}
	186
ef91ffaa HK	187	static const struct acpi_device_id rfkill_acpi_match[] = {
	188	{ "BCM4752", RFKILL_TYPE_GPS },
	189	{ },
	190	};
	191
7176ba23 RK	192	static struct platform_driver rfkill_gpio_driver = {
7176ba23 RK	193	.probe = rfkill_gpio_probe,
9e2b29d0	194	.remove = rfkill_gpio_remove,
7176ba23	195	.driver = {
262c91ee HK	196	.name = "rfkill_gpio",
262c91ee HK	197	.owner = THIS_MODULE,
ef91ffaa	198	.acpi_match_table = ACPI_PTR(rfkill_acpi_match),
7176ba23 RK	199	},
	200	};
	201
98ef55f6	202	module_platform_driver(rfkill_gpio_driver);
7176ba23 RK	203
	204	MODULE_DESCRIPTION("gpio rfkill");
	205	MODULE_AUTHOR("NVIDIA");
	206	MODULE_LICENSE("GPL");