ASR_BASE
Change-Id: Icf3719cc0afe3eeb3edc7fa80a2eb5199ca9dda1
diff --git a/marvell/linux/drivers/misc/asr_rfkill.c b/marvell/linux/drivers/misc/asr_rfkill.c
new file mode 100644
index 0000000..ed5c36f
--- /dev/null
+++ b/marvell/linux/drivers/misc/asr_rfkill.c
@@ -0,0 +1,765 @@
+/*
+ * rfkill power contorl for wlan/bt on ASR platform
+ *
+ * Copyright (C) 2018 ASR, Inc.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/debugfs.h>
+#include <linux/device.h>
+
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/mmc/host.h>
+#include <linux/platform_data/asr_sdhci.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
+#include <linux/suspend.h>
+#include <linux/clk.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#include <linux/of_platform.h>
+#include <linux/edge_wakeup_mmp.h>
+#include <linux/regulator/consumer.h>
+#include <linux/asr_rfkill.h>
+
+#include "../mmc/host/sdhci.h"
+
+#define ASR_DEV_NAME "asr-rfkill"
+
+/*
+ * Define optimum max current to 200mA while min current to 0.
+ * They will be handled in regulator_set_optimum_mode and
+ * enable or disable the regulator sleep mode accordingly.
+ */
+#define OPTIMUM_MAX_CURRENT 200000
+#define OPTIMUM_MIN_CURRENT 0
+
+#define ASR_MAX_SDIO_HOST 2
+static int sdio_rfkill_id;
+struct asr_rfkill_platform_data *rfkill_plat[ASR_MAX_SDIO_HOST];
+static DEFINE_MUTEX(asr_pwr_mutex);
+
+static void wlan_edge_wakeup(int irq, void *p_rsv)
+{
+ pr_debug("wlan_edge_wakeup event +++++\n");
+}
+
+static void asr_rfkill_platform_data_init(
+ struct asr_rfkill_platform_data *pdata)
+{
+ /* all intems are invalid just after alloc */
+ pdata->gpio_power_down = -1;
+ pdata->gpio_reset = -1;
+ pdata->gpio_edge_wakeup = -1;
+ pdata->gpio_3v3_en = -1;
+ pdata->gpio_1v8_en = -1;
+ pdata->gpio_wakeup_device = -1;
+
+ pdata->wib_3v3 = NULL;
+ pdata->wib_1v8 = NULL;
+ pdata->wib_sdio_1v8 = NULL;
+
+ /*for issue mmc card_detection interrupt */
+ pdata->mmc = NULL;
+
+ /* power status, unknown status at first */
+ pdata->is_on = -1;
+}
+
+static struct asr_rfkill_platform_data
+ *asr_rfkill_platform_data_alloc(struct platform_device *pdev)
+{
+ struct asr_rfkill_platform_data *pdata;
+
+ /* create a new one and init it */
+ pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+ if (pdata) {
+ asr_rfkill_platform_data_init(pdata);
+ return pdata;
+ }
+
+ return NULL;
+}
+
+/*
+ * For asr_wlan device, there are two power: supply 1v8 and 3v3
+ *
+ * If 18v and 3v3 can't be both disabled during power off stage,
+ * it is recommand to keep them both on and disable pd-gpio only
+ * TODO: add flags to check gpio active level
+ */
+static int asr_1v8_3v3_control(struct asr_rfkill_platform_data *pdata, int on)
+{
+ int gpio_3v3_en = pdata->gpio_3v3_en;
+ int gpio_1v8_en = pdata->gpio_1v8_en;
+
+ if (gpio_3v3_en >= 0) {
+ if (gpio_request(gpio_3v3_en, "asr_wlan 3v3 on")) {
+ pr_info("gpio %d request failed\n", gpio_3v3_en);
+ return -1;
+ }
+ }
+
+ if (gpio_1v8_en >= 0) {
+ if (gpio_request(gpio_1v8_en, "asr_wlan 1v8 on")) {
+ pr_info("gpio %d request failed\n", gpio_1v8_en);
+ if (gpio_3v3_en >= 0)
+ gpio_free(gpio_3v3_en);
+ return -1;
+ }
+ }
+
+ if (on) {
+ if (gpio_1v8_en >= 0)
+ gpio_direction_output(gpio_1v8_en, 1);
+ if (gpio_3v3_en >= 0)
+ gpio_direction_output(gpio_3v3_en, 1);
+ if (pdata->wib_3v3) {
+ if (regulator_set_voltage(pdata->wib_3v3, 3300000, 3300000))
+ pr_err("fail to set regulator wib_3v3 to 3.3v\n");
+
+ if (!regulator_is_enabled(pdata->wib_3v3) &&
+ regulator_enable(pdata->wib_3v3))
+ pr_err("fail to enable regulator wib_3v3\n");
+ }
+ if (pdata->wib_1v8) {
+ if (regulator_set_voltage(pdata->wib_1v8, 1800000, 1800000))
+ pr_err("fail to set regulator wib_1v8 to 1.8v\n");
+
+ if (!regulator_is_enabled(pdata->wib_1v8) &&
+ regulator_enable(pdata->wib_1v8))
+ pr_err("fail to enable regulator wib_1v8\n");
+ }
+ if (pdata->wib_sdio_1v8) {
+ if (regulator_set_voltage(pdata->wib_sdio_1v8, 1800000, 1800000))
+ pr_err("fail to set regulator wib_sdio_1v8 to 1.8v\n");
+
+ if (!regulator_is_enabled(pdata->wib_sdio_1v8) &&
+ regulator_enable(pdata->wib_sdio_1v8))
+ pr_err("fail to enable regulator wib_sdio_1v8\n");
+ }
+ } else {
+ if (gpio_1v8_en >= 0)
+ gpio_direction_output(gpio_1v8_en, 0);
+
+ if (gpio_3v3_en >= 0)
+ gpio_direction_output(gpio_3v3_en, 0);
+
+ if (pdata->wib_3v3) {
+ if (regulator_is_enabled(pdata->wib_3v3) &&
+ regulator_disable(pdata->wib_3v3))
+ pr_err("fail to disable regulator wib_3v3\n");
+
+ }
+ if (pdata->wib_1v8) {
+ if (regulator_is_enabled(pdata->wib_1v8) &&
+ regulator_disable(pdata->wib_1v8))
+ pr_err("fail to disable regulator wib_1v8\n");
+ }
+ if (pdata->wib_sdio_1v8) {
+ if (regulator_is_enabled(pdata->wib_sdio_1v8) &&
+ regulator_disable(pdata->wib_sdio_1v8))
+ pr_err("fail to disable regulator wib_sdio_1v8\n");
+ }
+ }
+
+ if (gpio_3v3_en >= 0)
+ gpio_free(gpio_3v3_en);
+ if (gpio_1v8_en >= 0)
+ gpio_free(gpio_1v8_en);
+
+ return 0;
+}
+/*
+ * Power on/off asr_wlan by control GPIO or regulator
+ * TODO: fine tune the function if need, like adding regulator
+ * support
+ *
+ */
+static int asr_pwr_ctrl(struct asr_rfkill_platform_data *pdata, int on)
+{
+ int gpio_power_down = pdata->gpio_power_down;
+ int gpio_reset = pdata->gpio_reset;
+ int host_wakeup_wlan_gpio = pdata->gpio_wakeup_device;
+ int ret = 0;
+
+ pr_info("%s(%s): on=%d\n", __func__, mmc_hostname(pdata->mmc), on);
+
+ if (gpio_power_down >= 0) {
+ if (gpio_request(gpio_power_down, "asr_wlan power down")) {
+ pr_info("gpio %d request failed\n", gpio_power_down);
+ return -1;
+ }
+ }
+
+ if (gpio_reset >= 0) {
+ if (gpio_request(gpio_reset, "asr_wlan reset")) {
+ pr_info("gpio %d request failed\n", gpio_reset);
+ ret = -1;
+ goto err_reset;
+ }
+ }
+
+ if (host_wakeup_wlan_gpio >= 0) {
+ if (gpio_request(host_wakeup_wlan_gpio, "asr_wlan host wakeup")) {
+ pr_info("gpio %d request failed\n", host_wakeup_wlan_gpio);
+ ret = -1;
+ goto err_wakeup;
+ }
+ }
+
+ if (on) {
+ if (host_wakeup_wlan_gpio >= 0) {
+ msleep(1);
+ gpio_direction_output(host_wakeup_wlan_gpio, 0);
+ msleep(1);
+ }
+
+ asr_1v8_3v3_control(pdata, 1);
+ if (gpio_reset >= 0) {
+ gpio_direction_output(gpio_reset, 0);
+ msleep(1);
+ gpio_direction_output(gpio_reset, 1);
+ }
+ if (gpio_power_down >= 0) {
+ msleep(1);
+ gpio_direction_output(gpio_power_down, 1);
+ }
+
+ msleep(10);
+ } else {
+ if (gpio_power_down >= 0)
+ gpio_direction_output(gpio_power_down, 0);
+
+ if (gpio_reset >= 0)
+ gpio_direction_output(gpio_reset, 0);
+
+ asr_1v8_3v3_control(pdata, 0);
+ }
+
+ if (host_wakeup_wlan_gpio >= 0)
+ gpio_free(host_wakeup_wlan_gpio);
+ err_wakeup:
+ if (gpio_reset >= 0)
+ gpio_free(gpio_reset);
+ err_reset:
+ if (gpio_power_down >= 0)
+ gpio_free(gpio_power_down);
+
+ return 0;
+}
+
+static int asr_trigger_mmc_detect(struct mmc_host *host)
+{
+ unsigned long timeout = msecs_to_jiffies(10 * 1000); //HoopoeL need more than 5seconds cost by rf calibration
+ unsigned long ret = 0;
+ unsigned long flags;
+ int retry = 2;
+
+ BUG_ON(!host);
+
+ while (retry--) {
+ spin_lock_irqsave(&host->lock, flags);
+ host->rescan_entered = 0;
+ spin_unlock_irqrestore(&host->lock, flags);
+
+ ret = mmc_detect_change_sync(host, msecs_to_jiffies(10),
+ timeout);
+ if (!ret)
+ pr_warn("mmc detect has taken %u ms,something wrong\n",
+ jiffies_to_msecs(timeout));
+
+ if (host->card)
+ return 0;
+
+ pr_info("Retry mmc detection\n");
+ }
+
+ return -EBUSY;
+}
+
+static int asr_pwr_on(struct asr_rfkill_platform_data *pdata)
+{
+ int ret = 0;
+ struct platform_device *pdev;
+ struct asr_sdhci_platdata *sdhci_pdata;
+ struct sdhci_host *host;
+
+ if (pdata->is_on)
+ return 0;
+
+ if (!pdata->mmc)
+ return -EINVAL;
+
+ pr_info("asr_wlan(%s) set_power on start\n", mmc_hostname(pdata->mmc));
+
+ pdev = to_platform_device(mmc_dev(pdata->mmc));
+ sdhci_pdata = pdev->dev.platform_data;
+
+ host = mmc_priv(pdata->mmc);
+
+ if (pdata->set_power)
+ pdata->set_power(1);
+
+ /*
+ * As we known, if we want to support Card Interrupt well, SDIO Host's
+ * Main Source CLK should be free running.
+ *
+ * But if PM Runtime is enabled, the host's RPM callback may dynamic
+ * on/off the SDIO Host's SRC CLK
+ *
+ * Here we call clk_prepare_enable to make sure Source Clock will not
+ * be disabled untill is called again
+ *
+ */
+
+ /* First: power up asr_wlan device */
+ asr_pwr_ctrl(pdata, 1);
+
+ /* Second: check whether sdio device can be detected */
+ if (pdata->mmc) {
+ ret = asr_trigger_mmc_detect(pdata->mmc);
+ if (ret)
+ pr_err("%s: fail to detect SDIO device\n",
+ mmc_hostname(pdata->mmc));
+ else
+ pr_info("%s: succeed to detect SDIO device\n",
+ mmc_hostname(pdata->mmc));
+ }
+
+ /* Last: save power on status after detection */
+ if (!ret) {
+ pdata->is_on = 1;
+
+ if (pdata->gpio_edge_wakeup >= 0) {
+ request_mfp_edge_wakeup(pdata->gpio_edge_wakeup,
+ wlan_edge_wakeup, NULL, pdata->mmc->parent);
+ }
+
+ if (pdata->pinctrl && pdata->pin_on)
+ pinctrl_select_state(pdata->pinctrl, pdata->pin_on);
+ } else {
+ pdata->is_on = 0;
+
+ /* roll back if fail */
+ asr_pwr_ctrl(pdata, 0);
+
+ if (pdata->set_power)
+ pdata->set_power(0);
+
+ if (pdata->pinctrl && pdata->pin_off)
+ pinctrl_select_state(pdata->pinctrl, pdata->pin_off);
+ }
+
+ pr_info("asr_wlan(%s) set_power on end\n", mmc_hostname(pdata->mmc));
+ return ret;
+}
+
+static int asr_pwr_off(struct asr_rfkill_platform_data *pdata)
+{
+ int ret = 0;
+ struct sdhci_host *host;
+ struct platform_device *pdev;
+ struct asr_sdhci_platdata *sdhci_pdata;
+
+ if (!pdata->is_on)
+ return 0;
+
+ if (!pdata->mmc)
+ return -EINVAL;
+
+ pr_info("asr_wlan(%s) set_power off start\n", mmc_hostname(pdata->mmc));
+
+ host = mmc_priv(pdata->mmc);
+
+ pdev = to_platform_device(mmc_dev(pdata->mmc));
+ sdhci_pdata = pdev->dev.platform_data;
+
+ /* First: tell SDIO bus the device will be power off */
+ if (host->mmc && host->mmc->card)
+ mmc_disable_sdio(host->mmc);
+
+ /* Second: power off asr_wlan device */
+ asr_pwr_ctrl(pdata, 0);
+
+ if (pdata->pinctrl && pdata->pin_off)
+ pinctrl_select_state(pdata->pinctrl, pdata->pin_off);
+
+ /* TODO: check sdio device can't be detected indeed */
+
+ /*
+ * Last: update the status
+ */
+
+ if (pdata->gpio_edge_wakeup >= 0)
+ remove_mfp_edge_wakeup(pdata->gpio_edge_wakeup);
+
+ if (pdata->set_power)
+ pdata->set_power(0);
+ pdata->is_on = 0;
+
+ pr_info("asr_wlan(%s) set_power off end\n", mmc_hostname(pdata->mmc));
+ return ret;
+}
+
+int asr_sdio_card_enable(int pwr_ctrl)
+{
+ struct asr_rfkill_platform_data *pdata;
+ int i;
+
+ mutex_lock(&asr_pwr_mutex);
+ for (i = 0; i < ASR_MAX_SDIO_HOST; i++) {
+ pdata = rfkill_plat[i];
+ if (pdata) {
+ if (pwr_ctrl)
+ asr_pwr_on(pdata);
+ else
+ asr_pwr_off(pdata);
+ }
+ }
+ mutex_unlock(&asr_pwr_mutex);
+
+ return 0;
+}
+EXPORT_SYMBOL(asr_sdio_card_enable);
+
+static ssize_t asr_pwr_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ int len = 0;
+ struct asr_rfkill_platform_data *pdata = dev->platform_data;
+
+ mutex_lock(&asr_pwr_mutex);
+
+ len = sprintf(buf, "asr_wlan(%s) Device is power %s\n",
+ mmc_hostname(pdata->mmc), pdata->is_on ? "on" : "off");
+
+ mutex_unlock(&asr_pwr_mutex);
+
+ return (ssize_t)len;
+}
+
+static ssize_t asr_pwr_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t size)
+{
+ int pwr_ctrl;
+ int valid_ctrl = 0;
+ struct asr_rfkill_platform_data *pdata = dev->platform_data;
+
+ mutex_lock(&asr_pwr_mutex);
+
+ if (sscanf(buf, "%d", &pwr_ctrl) == 1) {
+ if ((pwr_ctrl == 1) || (pwr_ctrl == 0))
+ valid_ctrl = 1;
+ }
+
+ if (valid_ctrl != 1) {
+ pr_err("Please input valid ctrl: 0: Close, 1: Open\n");
+ mutex_unlock(&asr_pwr_mutex);
+ return size;
+ }
+
+ if (pwr_ctrl)
+ asr_pwr_on(pdata);
+ else
+ asr_pwr_off(pdata);
+
+ pr_info("Now asr_wlan(%s) Device is power %s\n",
+ mmc_hostname(pdata->mmc), pdata->is_on ? "on" : "off");
+
+ mutex_unlock(&asr_pwr_mutex);
+
+ return size;
+}
+
+static DEVICE_ATTR(pwr_ctrl, S_IRUGO | S_IWUSR, asr_pwr_show, asr_pwr_store);
+
+#ifdef CONFIG_OF
+static const struct of_device_id asr_rfkill_of_match[] = {
+ {
+ .compatible = "asr,asr-rfkill",
+ },
+ {},
+};
+
+MODULE_DEVICE_TABLE(of, asr_rfkill_of_match);
+
+static int asr_rfkill_probe_dt(struct platform_device *pdev)
+{
+ struct device_node *np = pdev->dev.of_node, *sdh_np;
+ struct asr_rfkill_platform_data *pdata = pdev->dev.platform_data;
+ struct platform_device *sdh_pdev;
+ struct sdhci_host *host;
+ int sdh_phandle, gpio;
+ struct regulator *wib_3v3, *wib_1v8, *wib_sdio_1v8;
+
+ /* Get PD/RST pins status */
+ pdata->pinctrl = devm_pinctrl_get(&pdev->dev);
+ if (IS_ERR(pdata->pinctrl)) {
+ pdata->pinctrl = NULL;
+ dev_warn(&pdev->dev, "could not get PD/RST pinctrl.\n");
+ } else {
+ pdata->pin_off = pinctrl_lookup_state(pdata->pinctrl, "off");
+ if (IS_ERR(pdata->pin_off)) {
+ pdata->pin_off = NULL;
+ dev_err(&pdev->dev, "could not get off pinstate.\n");
+ }
+
+ pdata->pin_on = pinctrl_lookup_state(pdata->pinctrl, "on");
+ if (IS_ERR(pdata->pin_on)) {
+ pdata->pin_on = NULL;
+ dev_err(&pdev->dev, "could not get on pinstate.\n");
+ }
+ }
+
+ if (pdata->pinctrl && pdata->pin_off)
+ pinctrl_select_state(pdata->pinctrl, pdata->pin_off);
+
+ if (of_property_read_u32(np, "sd-host", &sdh_phandle)) {
+ dev_err(&pdev->dev, "failed to find sd-host in dt\n");
+ return -1;
+ }
+
+ /* we've got the phandle for sdh */
+ sdh_np = of_find_node_by_phandle(sdh_phandle);
+ if (unlikely(IS_ERR(sdh_np))) {
+ dev_err(&pdev->dev, "failed to find device_node for sdh\n");
+ return -1;
+ }
+
+ sdh_pdev = of_find_device_by_node(sdh_np);
+ if (unlikely(IS_ERR(sdh_pdev))) {
+ dev_err(&pdev->dev, "failed to find platform_device for sdh\n");
+ return -1;
+ }
+
+ /* sdh_pdev->dev->driver_data was set as sdhci_host in sdhci driver */
+ host = platform_get_drvdata(sdh_pdev);
+
+ /*
+ * If we cannot find host, it's because sdh device is not registered
+ * yet. Probe again later.
+ */
+ if (!host)
+ return -EPROBE_DEFER;
+
+ pdata->mmc = host->mmc;
+ if (sdio_rfkill_id >= ASR_MAX_SDIO_HOST)
+ dev_warn(&pdev->dev, "exceed max sdio host number\n");
+ else
+ rfkill_plat[sdio_rfkill_id++] = pdata;
+
+ /* get gpios from dt */
+ gpio = of_get_named_gpio(np, "edge-wakeup-gpio", 0);
+ if (unlikely(gpio < 0)) {
+ dev_warn(&pdev->dev, "edge-wakeup-gpio undefined\n");
+ pdata->gpio_edge_wakeup = -1;
+ } else {
+ pdata->gpio_edge_wakeup = gpio;
+ }
+
+ gpio = of_get_named_gpio(np, "pd-gpio", 0);
+ if (unlikely(gpio < 0)) {
+ dev_err(&pdev->dev, "pd-gpio undefined\n");
+ pdata->gpio_power_down = -1;
+ } else {
+ pdata->gpio_power_down = gpio;
+ }
+
+ gpio = of_get_named_gpio(np, "rst-gpio", 0);
+ if (unlikely(gpio < 0)) {
+ printk(KERN_DEBUG "rst-gpio undefined\n");
+ pdata->gpio_reset = -1;
+ } else {
+ pdata->gpio_reset = gpio;
+ }
+
+ gpio = of_get_named_gpio(np, "3v3-ldo-gpio", 0);
+ if (unlikely(gpio < 0)) {
+ printk(KERN_DEBUG "3v3-ldo-gpio undefined\n");
+ pdata->gpio_3v3_en = -1;
+ } else {
+ pdata->gpio_3v3_en = gpio;
+ }
+
+ gpio = of_get_named_gpio(np, "1v8-ldo-gpio", 0);
+ if (unlikely(gpio < 0)) {
+ printk(KERN_DEBUG "1v8-ldo-gpio undefined\n");
+ pdata->gpio_1v8_en = -1;
+ } else {
+ pdata->gpio_1v8_en = gpio;
+ }
+
+ wib_3v3 = regulator_get_optional(&pdev->dev, "wib_3v3");
+ if (IS_ERR_OR_NULL(wib_3v3))
+ printk(KERN_DEBUG "%s: regulator wib_3v3 not found\n", __func__);
+ else
+ pdata->wib_3v3 = wib_3v3;
+
+ wib_1v8 = regulator_get_optional(&pdev->dev, "wib_1v8");
+ if (IS_ERR_OR_NULL(wib_1v8))
+ printk(KERN_DEBUG "%s: regulator wib_1v8 not found\n", __func__);
+ else
+ pdata->wib_1v8 = wib_1v8;
+
+ wib_sdio_1v8 = regulator_get_optional(&pdev->dev, "wib_sdio_1v8");
+ if (IS_ERR_OR_NULL(wib_sdio_1v8))
+ printk(KERN_DEBUG "%s: regulator wib_sdio_1v8 not found\n", __func__);
+ else
+ pdata->wib_sdio_1v8 = wib_sdio_1v8;
+
+ gpio = of_get_named_gpio(np, "host-wakeup-wlan-gpio", 0);
+ if (unlikely(gpio < 0)) {
+ pdata->gpio_wakeup_device = -1;
+ dev_err(&pdev->dev, "host-wakeup-wlan-gpio undefined\n");
+ } else {
+ pdata->gpio_wakeup_device = gpio;
+ printk(KERN_DEBUG "%s: host_wakeup_wlan_gpio %d\n", __func__, gpio);
+ }
+ return 0;
+}
+#else
+static int asr_rfkill_probe_dt(struct platform_device *pdev)
+{
+ return 0;
+}
+#endif
+
+static int asr_rfkill_probe(struct platform_device *pdev)
+{
+ struct asr_rfkill_platform_data *pdata = NULL;
+ struct device *dev = &pdev->dev;
+ /* flag: whether pdata is passed from platfrom_data */
+ int pdata_passed = 1;
+ const struct of_device_id *match = NULL;
+ int ret = -1;
+
+ /* make sure asr_rfkill_platform_data is valid */
+ pdata = pdev->dev.platform_data;
+ if (!pdata) {
+ /* if platfrom data do not pass the struct to us */
+ pdata_passed = 0;
+
+ pdata = asr_rfkill_platform_data_alloc(pdev);
+ if (!pdata) {
+ pr_err("can't get asr_rfkill_platform_data struct during probe\n");
+ goto err_pdata;
+ }
+
+ pdev->dev.platform_data = pdata;
+ }
+
+ pdata->clk_26m_out = devm_clk_get(dev, "wifi_26m");
+ if (!IS_ERR(pdata->clk_26m_out)) {
+ dev_info(dev, "enable 26M output for wifi\n");
+ clk_prepare_enable(pdata->clk_26m_out);
+ }
+
+ /* set value to asr_rfkill_platform_data if DT pass them to us */
+#ifdef CONFIG_OF
+ match = of_match_device(of_match_ptr(asr_rfkill_of_match),
+ &pdev->dev);
+#endif
+ if (match) {
+ ret = asr_rfkill_probe_dt(pdev);
+ if (ret)
+ goto err_dt;
+ }
+
+ pdata->is_on = 0;
+ asr_pwr_ctrl(pdata, 0);
+
+ /*
+ * Create a proc interface, allowing user space to control
+ * asr_wlan devices' power
+ */
+ device_create_file(&pdev->dev, &dev_attr_pwr_ctrl);
+ return 0;
+
+err_dt:
+ if (!pdata_passed)
+ pdev->dev.platform_data = NULL;
+err_pdata:
+
+ return ret;
+}
+
+static int asr_rfkill_remove(struct platform_device *pdev)
+{
+ struct asr_rfkill_platform_data *pdata;
+ pdata = pdev->dev.platform_data;
+
+ if (pdata->wib_3v3)
+ regulator_put(pdata->wib_3v3);
+
+ if (pdata->wib_1v8)
+ regulator_put(pdata->wib_1v8);
+
+ if (pdata->wib_sdio_1v8)
+ regulator_put(pdata->wib_sdio_1v8);
+
+ if (!IS_ERR(pdata->clk_26m_out))
+ clk_disable_unprepare(pdata->clk_26m_out);
+ return 0;
+}
+
+static int asr_rfkill_suspend(struct platform_device *pdev,
+ pm_message_t pm_state)
+{
+ return 0;
+}
+
+static int asr_rfkill_resume(struct platform_device *pdev)
+{
+ return 0;
+}
+
+static struct platform_driver asr_rfkill_platform_driver = {
+ .probe = asr_rfkill_probe,
+ .remove = asr_rfkill_remove,
+ .driver = {
+ .name = ASR_DEV_NAME,
+ .owner = THIS_MODULE,
+#ifdef CONFIG_OF
+ .of_match_table = asr_rfkill_of_match,
+#endif
+
+ },
+ .suspend = asr_rfkill_suspend,
+ .resume = asr_rfkill_resume,
+};
+
+static int __init asr_rfkill_init(void)
+{
+ return platform_driver_register(&asr_rfkill_platform_driver);
+}
+
+static void __exit asr_rfkill_exit(void)
+{
+ platform_driver_unregister(&asr_rfkill_platform_driver);
+}
+
+module_init(asr_rfkill_init);
+module_exit(asr_rfkill_exit);
+
+MODULE_ALIAS("platform:asr_rfkill");
+MODULE_DESCRIPTION("asr_rfkill");
+MODULE_AUTHOR("ASR");
+MODULE_LICENSE("GPL");