diff options
author | Scott Wood <scottwood@freescale.com> | 2014-04-07 23:49:35 (GMT) |
---|---|---|
committer | Scott Wood <scottwood@freescale.com> | 2014-04-07 23:49:35 (GMT) |
commit | 62b8c978ee6b8d135d9e7953221de58000dba986 (patch) | |
tree | 683b04b2e627f6710c22c151b23c8cc9a165315e /net/rfkill | |
parent | 78fd82238d0e5716578c326404184a27ba67fd6e (diff) | |
download | linux-fsl-qoriq-62b8c978ee6b8d135d9e7953221de58000dba986.tar.xz |
Rewind v3.13-rc3+ (78fd82238d0e5716) to v3.12
Diffstat (limited to 'net/rfkill')
-rw-r--r-- | net/rfkill/Kconfig | 2 | ||||
-rw-r--r-- | net/rfkill/rfkill-gpio.c | 211 |
2 files changed, 114 insertions, 99 deletions
diff --git a/net/rfkill/Kconfig b/net/rfkill/Kconfig index 4c10e7e..78efe89 100644 --- a/net/rfkill/Kconfig +++ b/net/rfkill/Kconfig @@ -36,7 +36,7 @@ config RFKILL_REGULATOR config RFKILL_GPIO tristate "GPIO RFKILL driver" - depends on RFKILL && GPIOLIB + depends on RFKILL && GPIOLIB && HAVE_CLK default n help If you say yes here you get support of a generic gpio RFKILL diff --git a/net/rfkill/rfkill-gpio.c b/net/rfkill/rfkill-gpio.c index 5620d3c..fb076cd 100644 --- a/net/rfkill/rfkill-gpio.c +++ b/net/rfkill/rfkill-gpio.c @@ -24,23 +24,27 @@ #include <linux/platform_device.h> #include <linux/clk.h> #include <linux/slab.h> -#include <linux/acpi.h> -#include <linux/acpi_gpio.h> #include <linux/rfkill-gpio.h> -struct rfkill_gpio_data { - const char *name; - enum rfkill_type type; - int reset_gpio; - int shutdown_gpio; +enum rfkill_gpio_clk_state { + UNSPECIFIED = 0, + PWR_ENABLED, + PWR_DISABLED +}; - struct rfkill *rfkill_dev; - char *reset_name; - char *shutdown_name; - struct clk *clk; +#define PWR_CLK_SET(_RF, _EN) \ + ((_RF)->pwr_clk_enabled = (!(_EN) ? PWR_ENABLED : PWR_DISABLED)) +#define PWR_CLK_ENABLED(_RF) ((_RF)->pwr_clk_enabled == PWR_ENABLED) +#define PWR_CLK_DISABLED(_RF) ((_RF)->pwr_clk_enabled != PWR_ENABLED) - bool clk_enabled; +struct rfkill_gpio_data { + struct rfkill_gpio_platform_data *pdata; + struct rfkill *rfkill_dev; + char *reset_name; + char *shutdown_name; + enum rfkill_gpio_clk_state pwr_clk_enabled; + struct clk *pwr_clk; }; static int rfkill_gpio_set_power(void *data, bool blocked) @@ -48,22 +52,23 @@ static int rfkill_gpio_set_power(void *data, bool blocked) struct rfkill_gpio_data *rfkill = data; if (blocked) { - if (gpio_is_valid(rfkill->shutdown_gpio)) - gpio_set_value(rfkill->shutdown_gpio, 0); - if (gpio_is_valid(rfkill->reset_gpio)) - gpio_set_value(rfkill->reset_gpio, 0); - if (!IS_ERR(rfkill->clk) && rfkill->clk_enabled) - clk_disable(rfkill->clk); + if (gpio_is_valid(rfkill->pdata->shutdown_gpio)) + gpio_direction_output(rfkill->pdata->shutdown_gpio, 0); + if (gpio_is_valid(rfkill->pdata->reset_gpio)) + gpio_direction_output(rfkill->pdata->reset_gpio, 0); + if (rfkill->pwr_clk && PWR_CLK_ENABLED(rfkill)) + clk_disable(rfkill->pwr_clk); } else { - if (!IS_ERR(rfkill->clk) && !rfkill->clk_enabled) - clk_enable(rfkill->clk); - if (gpio_is_valid(rfkill->reset_gpio)) - gpio_set_value(rfkill->reset_gpio, 1); - if (gpio_is_valid(rfkill->shutdown_gpio)) - gpio_set_value(rfkill->shutdown_gpio, 1); + if (rfkill->pwr_clk && PWR_CLK_DISABLED(rfkill)) + clk_enable(rfkill->pwr_clk); + if (gpio_is_valid(rfkill->pdata->reset_gpio)) + gpio_direction_output(rfkill->pdata->reset_gpio, 1); + if (gpio_is_valid(rfkill->pdata->shutdown_gpio)) + gpio_direction_output(rfkill->pdata->shutdown_gpio, 1); } - rfkill->clk_enabled = blocked; + if (rfkill->pwr_clk) + PWR_CLK_SET(rfkill, blocked); return 0; } @@ -72,112 +77,117 @@ 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; - rfkill->reset_gpio = acpi_get_gpio_by_index(dev, 0, NULL); - rfkill->shutdown_gpio = acpi_get_gpio_by_index(dev, 1, NULL); - - 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 rfkill_gpio_platform_data *pdata = pdev->dev.platform_data; int ret = 0; int len = 0; - 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; - rfkill->reset_gpio = pdata->reset_gpio; - rfkill->shutdown_gpio = pdata->shutdown_gpio; - } else { - return -ENODEV; + if (!pdata) { + pr_warn("%s: No platform data specified\n", __func__); + return -EINVAL; } /* make sure at-least one of the GPIO is defined and that * a name is specified for this instance */ - if ((!gpio_is_valid(rfkill->reset_gpio) && - !gpio_is_valid(rfkill->shutdown_gpio)) || !rfkill->name) { + if (!pdata->name || (!gpio_is_valid(pdata->reset_gpio) && + !gpio_is_valid(pdata->shutdown_gpio))) { pr_warn("%s: invalid platform data\n", __func__); return -EINVAL; } - if (pdata && pdata->gpio_runtime_setup) { + rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL); + if (!rfkill) + return -ENOMEM; + + if (pdata->gpio_runtime_setup) { ret = pdata->gpio_runtime_setup(pdev); if (ret) { pr_warn("%s: can't set up gpio\n", __func__); - return ret; + goto fail_alloc; } } - len = strlen(rfkill->name); - rfkill->reset_name = devm_kzalloc(&pdev->dev, len + 7, GFP_KERNEL); - if (!rfkill->reset_name) - return -ENOMEM; + rfkill->pdata = pdata; - rfkill->shutdown_name = devm_kzalloc(&pdev->dev, len + 10, GFP_KERNEL); - if (!rfkill->shutdown_name) - return -ENOMEM; + len = strlen(pdata->name); + rfkill->reset_name = kzalloc(len + 7, GFP_KERNEL); + if (!rfkill->reset_name) { + ret = -ENOMEM; + goto fail_alloc; + } + + rfkill->shutdown_name = kzalloc(len + 10, GFP_KERNEL); + if (!rfkill->shutdown_name) { + ret = -ENOMEM; + goto fail_reset_name; + } - snprintf(rfkill->reset_name, len + 6 , "%s_reset", rfkill->name); - snprintf(rfkill->shutdown_name, len + 9, "%s_shutdown", rfkill->name); + snprintf(rfkill->reset_name, len + 6 , "%s_reset", pdata->name); + snprintf(rfkill->shutdown_name, len + 9, "%s_shutdown", pdata->name); - rfkill->clk = devm_clk_get(&pdev->dev, clk_name); + if (pdata->power_clk_name) { + rfkill->pwr_clk = clk_get(&pdev->dev, pdata->power_clk_name); + if (IS_ERR(rfkill->pwr_clk)) { + pr_warn("%s: can't find pwr_clk.\n", __func__); + ret = PTR_ERR(rfkill->pwr_clk); + goto fail_shutdown_name; + } + } - if (gpio_is_valid(rfkill->reset_gpio)) { - ret = devm_gpio_request_one(&pdev->dev, rfkill->reset_gpio, - 0, rfkill->reset_name); + if (gpio_is_valid(pdata->reset_gpio)) { + ret = gpio_request(pdata->reset_gpio, rfkill->reset_name); if (ret) { pr_warn("%s: failed to get reset gpio.\n", __func__); - return ret; + goto fail_clock; } } - if (gpio_is_valid(rfkill->shutdown_gpio)) { - ret = devm_gpio_request_one(&pdev->dev, rfkill->shutdown_gpio, - 0, rfkill->shutdown_name); + if (gpio_is_valid(pdata->shutdown_gpio)) { + ret = gpio_request(pdata->shutdown_gpio, rfkill->shutdown_name); if (ret) { pr_warn("%s: failed to get shutdown gpio.\n", __func__); - return ret; + goto fail_reset; } } - rfkill->rfkill_dev = rfkill_alloc(rfkill->name, &pdev->dev, - rfkill->type, &rfkill_gpio_ops, - rfkill); - if (!rfkill->rfkill_dev) - return -ENOMEM; + rfkill->rfkill_dev = rfkill_alloc(pdata->name, &pdev->dev, pdata->type, + &rfkill_gpio_ops, rfkill); + if (!rfkill->rfkill_dev) { + ret = -ENOMEM; + goto fail_shutdown; + } ret = rfkill_register(rfkill->rfkill_dev); if (ret < 0) - return ret; + goto fail_rfkill; platform_set_drvdata(pdev, rfkill); - dev_info(&pdev->dev, "%s device registered.\n", rfkill->name); + dev_info(&pdev->dev, "%s device registered.\n", pdata->name); return 0; + +fail_rfkill: + rfkill_destroy(rfkill->rfkill_dev); +fail_shutdown: + if (gpio_is_valid(pdata->shutdown_gpio)) + gpio_free(pdata->shutdown_gpio); +fail_reset: + if (gpio_is_valid(pdata->reset_gpio)) + gpio_free(pdata->reset_gpio); +fail_clock: + if (rfkill->pwr_clk) + clk_put(rfkill->pwr_clk); +fail_shutdown_name: + kfree(rfkill->shutdown_name); +fail_reset_name: + kfree(rfkill->reset_name); +fail_alloc: + kfree(rfkill); + + return ret; } static int rfkill_gpio_remove(struct platform_device *pdev) @@ -185,26 +195,31 @@ 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) + if (pdata->gpio_runtime_close) pdata->gpio_runtime_close(pdev); rfkill_unregister(rfkill->rfkill_dev); rfkill_destroy(rfkill->rfkill_dev); + if (gpio_is_valid(rfkill->pdata->shutdown_gpio)) + gpio_free(rfkill->pdata->shutdown_gpio); + if (gpio_is_valid(rfkill->pdata->reset_gpio)) + gpio_free(rfkill->pdata->reset_gpio); + if (rfkill->pwr_clk && PWR_CLK_ENABLED(rfkill)) + clk_disable(rfkill->pwr_clk); + if (rfkill->pwr_clk) + clk_put(rfkill->pwr_clk); + kfree(rfkill->shutdown_name); + kfree(rfkill->reset_name); + kfree(rfkill); 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), + .name = "rfkill_gpio", + .owner = THIS_MODULE, }, }; |