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");