[deliverable/linux.git] / drivers / net / wireless / ti / wl1251 / sdio.c

/*
 * wl12xx SDIO routines
 *
 * 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.
 *
 * 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 St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 * Copyright (C) 2005 Texas Instruments Incorporated
 * Copyright (C) 2008 Google Inc
 * Copyright (C) 2009 Bob Copeland (me@bobcopeland.com)
 */
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/mmc/sdio_func.h>
#include <linux/mmc/sdio_ids.h>
#include <linux/platform_device.h>
#include <linux/wl12xx.h>
#include <linux/irq.h>
#include <linux/pm_runtime.h>
#include <linux/gpio.h>

#include "wl1251.h"

#ifndef SDIO_VENDOR_ID_TI
#define SDIO_VENDOR_ID_TI		0x104c
#endif

#ifndef SDIO_DEVICE_ID_TI_WL1251
#define SDIO_DEVICE_ID_TI_WL1251	0x9066
#endif

struct wl1251_sdio {
	struct sdio_func *func;
	u32 elp_val;
};

static struct sdio_func *wl_to_func(struct wl1251 *wl)
{
	struct wl1251_sdio *wl_sdio = wl->if_priv;
	return wl_sdio->func;
}

static void wl1251_sdio_interrupt(struct sdio_func *func)
{
	struct wl1251 *wl = sdio_get_drvdata(func);

	wl1251_debug(DEBUG_IRQ, "IRQ");

	/* FIXME should be synchronous for sdio */
	ieee80211_queue_work(wl->hw, &wl->irq_work);
}

static const struct sdio_device_id wl1251_devices[] = {
	{ SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1251) },
	{}
};
MODULE_DEVICE_TABLE(sdio, wl1251_devices);


static void wl1251_sdio_read(struct wl1251 *wl, int addr,
			     void *buf, size_t len)
{
	int ret;
	struct sdio_func *func = wl_to_func(wl);

	sdio_claim_host(func);
	ret = sdio_memcpy_fromio(func, buf, addr, len);
	if (ret)
		wl1251_error("sdio read failed (%d)", ret);
	sdio_release_host(func);
}

static void wl1251_sdio_write(struct wl1251 *wl, int addr,
			      void *buf, size_t len)
{
	int ret;
	struct sdio_func *func = wl_to_func(wl);

	sdio_claim_host(func);
	ret = sdio_memcpy_toio(func, addr, buf, len);
	if (ret)
		wl1251_error("sdio write failed (%d)", ret);
	sdio_release_host(func);
}

static void wl1251_sdio_read_elp(struct wl1251 *wl, int addr, u32 *val)
{
	int ret = 0;
	struct wl1251_sdio *wl_sdio = wl->if_priv;
	struct sdio_func *func = wl_sdio->func;

	/*
	 * The hardware only supports RAW (read after write) access for
	 * reading, regular sdio_readb won't work here (it interprets
	 * the unused bits of CMD52 as write data even if we send read
	 * request).
	 */
	sdio_claim_host(func);
	*val = sdio_writeb_readb(func, wl_sdio->elp_val, addr, &ret);
	sdio_release_host(func);

	if (ret)
		wl1251_error("sdio_readb failed (%d)", ret);
}

static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val)
{
	int ret = 0;
	struct wl1251_sdio *wl_sdio = wl->if_priv;
	struct sdio_func *func = wl_sdio->func;

	sdio_claim_host(func);
	sdio_writeb(func, val, addr, &ret);
	sdio_release_host(func);

	if (ret)
		wl1251_error("sdio_writeb failed (%d)", ret);
	else
		wl_sdio->elp_val = val;
}

static void wl1251_sdio_reset(struct wl1251 *wl)
{
}

static void wl1251_sdio_enable_irq(struct wl1251 *wl)
{
	struct sdio_func *func = wl_to_func(wl);

	sdio_claim_host(func);
	sdio_claim_irq(func, wl1251_sdio_interrupt);
	sdio_release_host(func);
}

static void wl1251_sdio_disable_irq(struct wl1251 *wl)
{
	struct sdio_func *func = wl_to_func(wl);

	sdio_claim_host(func);
	sdio_release_irq(func);
	sdio_release_host(func);
}

/* Interrupts when using dedicated WLAN_IRQ pin */
static irqreturn_t wl1251_line_irq(int irq, void *cookie)
{
	struct wl1251 *wl = cookie;

	ieee80211_queue_work(wl->hw, &wl->irq_work);

	return IRQ_HANDLED;
}

static void wl1251_enable_line_irq(struct wl1251 *wl)
{
	return enable_irq(wl->irq);
}

static void wl1251_disable_line_irq(struct wl1251 *wl)
{
	return disable_irq(wl->irq);
}

static int wl1251_sdio_set_power(struct wl1251 *wl, bool enable)
{
	struct sdio_func *func = wl_to_func(wl);
	int ret;

	if (enable) {
		/*
		 * Power is controlled by runtime PM, but we still call board
		 * callback in case it wants to do any additional setup,
		 * for example enabling clock buffer for the module.
		 */
		if (gpio_is_valid(wl->power_gpio))
			gpio_set_value(wl->power_gpio, true);


		ret = pm_runtime_get_sync(&func->dev);
		if (ret < 0) {
			pm_runtime_put_sync(&func->dev);
			goto out;
		}

		sdio_claim_host(func);
		sdio_enable_func(func);
		sdio_release_host(func);
	} else {
		sdio_claim_host(func);
		sdio_disable_func(func);
		sdio_release_host(func);

		ret = pm_runtime_put_sync(&func->dev);
		if (ret < 0)
			goto out;

		if (gpio_is_valid(wl->power_gpio))
			gpio_set_value(wl->power_gpio, false);
	}

out:
	return ret;
}

static struct wl1251_if_operations wl1251_sdio_ops = {
	.read = wl1251_sdio_read,
	.write = wl1251_sdio_write,
	.write_elp = wl1251_sdio_write_elp,
	.read_elp = wl1251_sdio_read_elp,
	.reset = wl1251_sdio_reset,
	.power = wl1251_sdio_set_power,
};

static int wl1251_sdio_probe(struct sdio_func *func,
			     const struct sdio_device_id *id)
{
	int ret;
	struct wl1251 *wl;
	struct ieee80211_hw *hw;
	struct wl1251_sdio *wl_sdio;
	const struct wl1251_platform_data *wl1251_board_data;

	hw = wl1251_alloc_hw();
	if (IS_ERR(hw))
		return PTR_ERR(hw);

	wl = hw->priv;

	wl_sdio = kzalloc(sizeof(*wl_sdio), GFP_KERNEL);
	if (wl_sdio == NULL) {
		ret = -ENOMEM;
		goto out_free_hw;
	}

	sdio_claim_host(func);
	ret = sdio_enable_func(func);
	if (ret)
		goto release;

	sdio_set_block_size(func, 512);
	sdio_release_host(func);

	SET_IEEE80211_DEV(hw, &func->dev);
	wl_sdio->func = func;
	wl->if_priv = wl_sdio;
	wl->if_ops = &wl1251_sdio_ops;

	wl1251_board_data = wl1251_get_platform_data();
	if (!IS_ERR(wl1251_board_data)) {
		wl->power_gpio = wl1251_board_data->power_gpio;
		wl->irq = wl1251_board_data->irq;
		wl->use_eeprom = wl1251_board_data->use_eeprom;
	}

	if (gpio_is_valid(wl->power_gpio)) {
		ret = devm_gpio_request(&func->dev, wl->power_gpio,
								"wl1251 power");
		if (ret) {
			wl1251_error("Failed to request gpio: %d\n", ret);
			goto disable;
		}
	}

	if (wl->irq) {
		irq_set_status_flags(wl->irq, IRQ_NOAUTOEN);
		ret = request_irq(wl->irq, wl1251_line_irq, 0, "wl1251", wl);
		if (ret < 0) {
			wl1251_error("request_irq() failed: %d", ret);
			goto disable;
		}

		irq_set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);

		wl1251_sdio_ops.enable_irq = wl1251_enable_line_irq;
		wl1251_sdio_ops.disable_irq = wl1251_disable_line_irq;

		wl1251_info("using dedicated interrupt line");
	} else {
		wl1251_sdio_ops.enable_irq = wl1251_sdio_enable_irq;
		wl1251_sdio_ops.disable_irq = wl1251_sdio_disable_irq;

		wl1251_info("using SDIO interrupt");
	}

	ret = wl1251_init_ieee80211(wl);
	if (ret)
		goto out_free_irq;

	sdio_set_drvdata(func, wl);

	/* Tell PM core that we don't need the card to be powered now */
	pm_runtime_put_noidle(&func->dev);

	return ret;

out_free_irq:
	if (wl->irq)
		free_irq(wl->irq, wl);
disable:
	sdio_claim_host(func);
	sdio_disable_func(func);
release:
	sdio_release_host(func);
	kfree(wl_sdio);
out_free_hw:
	wl1251_free_hw(wl);
	return ret;
}

static void wl1251_sdio_remove(struct sdio_func *func)
{
	struct wl1251 *wl = sdio_get_drvdata(func);
	struct wl1251_sdio *wl_sdio = wl->if_priv;

	/* Undo decrement done above in wl1251_probe */
	pm_runtime_get_noresume(&func->dev);

	if (wl->irq)
		free_irq(wl->irq, wl);
	wl1251_free_hw(wl);
	kfree(wl_sdio);

	sdio_claim_host(func);
	sdio_release_irq(func);
	sdio_disable_func(func);
	sdio_release_host(func);
}

static int wl1251_suspend(struct device *dev)
{
	/*
	 * Tell MMC/SDIO core it's OK to power down the card
	 * (if it isn't already), but not to remove it completely.
	 */
	return 0;
}

static int wl1251_resume(struct device *dev)
{
	return 0;
}

static const struct dev_pm_ops wl1251_sdio_pm_ops = {
	.suspend        = wl1251_suspend,
	.resume         = wl1251_resume,
};

static struct sdio_driver wl1251_sdio_driver = {
	.name		= "wl1251_sdio",
	.id_table	= wl1251_devices,
	.probe		= wl1251_sdio_probe,
	.remove		= wl1251_sdio_remove,
	.drv.pm		= &wl1251_sdio_pm_ops,
};

static int __init wl1251_sdio_init(void)
{
	int err;

	err = sdio_register_driver(&wl1251_sdio_driver);
	if (err)
		wl1251_error("failed to register sdio driver: %d", err);
	return err;
}

static void __exit wl1251_sdio_exit(void)
{
	sdio_unregister_driver(&wl1251_sdio_driver);
	wl1251_notice("unloaded");
}

module_init(wl1251_sdio_init);
module_exit(wl1251_sdio_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Kalle Valo <kvalo@adurom.com>");
Commit	Line	Data
3ec410d7 BC	1	/*
	2	* wl12xx SDIO routines
	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 version 2 as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	11	* General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this program; if not, write to the Free Software
	15	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	16	* 02110-1301 USA
	17	*
	18	* Copyright (C) 2005 Texas Instruments Incorporated
	19	* Copyright (C) 2008 Google Inc
	20	* Copyright (C) 2009 Bob Copeland (me@bobcopeland.com)
	21	*/
a6b7a407	22	#include <linux/interrupt.h>
3ec410d7	23	#include <linux/module.h>
3ec410d7	24	#include <linux/mod_devicetable.h>
3ec410d7 BC	25	#include <linux/mmc/sdio_func.h>
3ec410d7 BC	26	#include <linux/mmc/sdio_ids.h>
8c00b39f	27	#include <linux/platform_device.h>
c1f9a095	28	#include <linux/wl12xx.h>
a02a2956	29	#include <linux/irq.h>
1d4b89f2	30	#include <linux/pm_runtime.h>
1d207cd3	31	#include <linux/gpio.h>
3ec410d7 BC	32
3ec410d7 BC	33	#include "wl1251.h"
3ec410d7 BC	34
	35	#ifndef SDIO_VENDOR_ID_TI
	36	#define SDIO_VENDOR_ID_TI 0x104c
	37	#endif
	38
	39	#ifndef SDIO_DEVICE_ID_TI_WL1251
	40	#define SDIO_DEVICE_ID_TI_WL1251 0x9066
	41	#endif
	42
832c10fd GI	43	struct wl1251_sdio {
	44	struct sdio_func *func;
	45	u32 elp_val;
	46	};
	47
3ec410d7 BC	48	static struct sdio_func wl_to_func(struct wl1251 wl)
3ec410d7 BC	49	{
832c10fd GI	50	struct wl1251_sdio *wl_sdio = wl->if_priv;
832c10fd GI	51	return wl_sdio->func;
3ec410d7 BC	52	}
	53
	54	static void wl1251_sdio_interrupt(struct sdio_func *func)
	55	{
b5ed9c1b BC	56	struct wl1251 *wl = sdio_get_drvdata(func);
	57
	58	wl1251_debug(DEBUG_IRQ, "IRQ");
	59
	60	/* FIXME should be synchronous for sdio */
16e711f9	61	ieee80211_queue_work(wl->hw, &wl->irq_work);
3ec410d7 BC	62	}
	63
	64	static const struct sdio_device_id wl1251_devices[] = {
	65	{ SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1251) },
	66	{}
	67	};
	68	MODULE_DEVICE_TABLE(sdio, wl1251_devices);
	69
	70
3c9cb9c3 GI	71	static void wl1251_sdio_read(struct wl1251 *wl, int addr,
3c9cb9c3 GI	72	void *buf, size_t len)
3ec410d7 BC	73	{
	74	int ret;
	75	struct sdio_func *func = wl_to_func(wl);
	76
	77	sdio_claim_host(func);
	78	ret = sdio_memcpy_fromio(func, buf, addr, len);
	79	if (ret)
	80	wl1251_error("sdio read failed (%d)", ret);
	81	sdio_release_host(func);
	82	}
	83
3c9cb9c3 GI	84	static void wl1251_sdio_write(struct wl1251 *wl, int addr,
3c9cb9c3 GI	85	void *buf, size_t len)
3ec410d7 BC	86	{
	87	int ret;
	88	struct sdio_func *func = wl_to_func(wl);
	89
	90	sdio_claim_host(func);
	91	ret = sdio_memcpy_toio(func, addr, buf, len);
	92	if (ret)
	93	wl1251_error("sdio write failed (%d)", ret);
	94	sdio_release_host(func);
	95	}
	96
3f9e750d GI	97	static void wl1251_sdio_read_elp(struct wl1251 wl, int addr, u32 val)
	98	{
	99	int ret = 0;
832c10fd GI	100	struct wl1251_sdio *wl_sdio = wl->if_priv;
	101	struct sdio_func *func = wl_sdio->func;
	102
	103	/*
	104	* The hardware only supports RAW (read after write) access for
	105	* reading, regular sdio_readb won't work here (it interprets
	106	* the unused bits of CMD52 as write data even if we send read
	107	* request).
	108	*/
3f9e750d	109	sdio_claim_host(func);
832c10fd	110	*val = sdio_writeb_readb(func, wl_sdio->elp_val, addr, &ret);
3f9e750d GI	111	sdio_release_host(func);
	112
	113	if (ret)
	114	wl1251_error("sdio_readb failed (%d)", ret);
	115	}
	116
	117	static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val)
	118	{
	119	int ret = 0;
832c10fd GI	120	struct wl1251_sdio *wl_sdio = wl->if_priv;
832c10fd GI	121	struct sdio_func *func = wl_sdio->func;
3f9e750d GI	122
	123	sdio_claim_host(func);
	124	sdio_writeb(func, val, addr, &ret);
	125	sdio_release_host(func);
	126
	127	if (ret)
	128	wl1251_error("sdio_writeb failed (%d)", ret);
832c10fd GI	129	else
832c10fd GI	130	wl_sdio->elp_val = val;
3f9e750d GI	131	}
3f9e750d GI	132
3c9cb9c3	133	static void wl1251_sdio_reset(struct wl1251 *wl)
3ec410d7 BC	134	{
	135	}
	136
b5ed9c1b BC	137	static void wl1251_sdio_enable_irq(struct wl1251 *wl)
	138	{
	139	struct sdio_func *func = wl_to_func(wl);
	140
	141	sdio_claim_host(func);
	142	sdio_claim_irq(func, wl1251_sdio_interrupt);
	143	sdio_release_host(func);
	144	}
	145
	146	static void wl1251_sdio_disable_irq(struct wl1251 *wl)
	147	{
	148	struct sdio_func *func = wl_to_func(wl);
	149
	150	sdio_claim_host(func);
	151	sdio_release_irq(func);
	152	sdio_release_host(func);
	153	}
	154
a02a2956 GI	155	/* Interrupts when using dedicated WLAN_IRQ pin */
	156	static irqreturn_t wl1251_line_irq(int irq, void *cookie)
	157	{
	158	struct wl1251 *wl = cookie;
	159
	160	ieee80211_queue_work(wl->hw, &wl->irq_work);
	161
	162	return IRQ_HANDLED;
	163	}
	164
	165	static void wl1251_enable_line_irq(struct wl1251 *wl)
	166	{
	167	return enable_irq(wl->irq);
	168	}
	169
	170	static void wl1251_disable_line_irq(struct wl1251 *wl)
	171	{
	172	return disable_irq(wl->irq);
	173	}
	174
cb7bbc7a	175	static int wl1251_sdio_set_power(struct wl1251 *wl, bool enable)
3ec410d7	176	{
1d4b89f2 GI	177	struct sdio_func *func = wl_to_func(wl);
1d4b89f2 GI	178	int ret;
cb7bbc7a	179
1d4b89f2 GI	180	if (enable) {
	181	/*
	182	* Power is controlled by runtime PM, but we still call board
	183	* callback in case it wants to do any additional setup,
	184	* for example enabling clock buffer for the module.
	185	*/
1d207cd3 SR	186	if (gpio_is_valid(wl->power_gpio))
	187	gpio_set_value(wl->power_gpio, true);
	188
1d4b89f2 GI	189
1d4b89f2 GI	190	ret = pm_runtime_get_sync(&func->dev);
42af657f LF	191	if (ret < 0) {
42af657f LF	192	pm_runtime_put_sync(&func->dev);
1d4b89f2	193	goto out;
42af657f	194	}
1d4b89f2 GI	195
	196	sdio_claim_host(func);
	197	sdio_enable_func(func);
	198	sdio_release_host(func);
	199	} else {
	200	sdio_claim_host(func);
	201	sdio_disable_func(func);
	202	sdio_release_host(func);
	203
	204	ret = pm_runtime_put_sync(&func->dev);
	205	if (ret < 0)
	206	goto out;
	207
1d207cd3 SR	208	if (gpio_is_valid(wl->power_gpio))
1d207cd3 SR	209	gpio_set_value(wl->power_gpio, false);
1d4b89f2 GI	210	}
	211
	212	out:
	213	return ret;
3ec410d7 BC	214	}
3ec410d7 BC	215
a02a2956	216	static struct wl1251_if_operations wl1251_sdio_ops = {
3ec410d7 BC	217	.read = wl1251_sdio_read,
3ec410d7 BC	218	.write = wl1251_sdio_write,
3f9e750d GI	219	.write_elp = wl1251_sdio_write_elp,
3f9e750d GI	220	.read_elp = wl1251_sdio_read_elp,
3ec410d7	221	.reset = wl1251_sdio_reset,
cb7bbc7a	222	.power = wl1251_sdio_set_power,
3ec410d7 BC	223	};
3ec410d7 BC	224
3c9cb9c3 GI	225	static int wl1251_sdio_probe(struct sdio_func *func,
3c9cb9c3 GI	226	const struct sdio_device_id *id)
3ec410d7 BC	227	{
	228	int ret;
	229	struct wl1251 *wl;
	230	struct ieee80211_hw *hw;
832c10fd	231	struct wl1251_sdio *wl_sdio;
946651cb	232	const struct wl1251_platform_data *wl1251_board_data;
3ec410d7 BC	233
	234	hw = wl1251_alloc_hw();
	235	if (IS_ERR(hw))
	236	return PTR_ERR(hw);
	237
	238	wl = hw->priv;
	239
832c10fd GI	240	wl_sdio = kzalloc(sizeof(*wl_sdio), GFP_KERNEL);
	241	if (wl_sdio == NULL) {
	242	ret = -ENOMEM;
	243	goto out_free_hw;
	244	}
	245
3ec410d7 BC	246	sdio_claim_host(func);
	247	ret = sdio_enable_func(func);
	248	if (ret)
	249	goto release;
	250
	251	sdio_set_block_size(func, 512);
a02a2956	252	sdio_release_host(func);
3ec410d7 BC	253
3ec410d7 BC	254	SET_IEEE80211_DEV(hw, &func->dev);
832c10fd GI	255	wl_sdio->func = func;
832c10fd GI	256	wl->if_priv = wl_sdio;
3ec410d7	257	wl->if_ops = &wl1251_sdio_ops;
3ec410d7	258
946651cb LC	259	wl1251_board_data = wl1251_get_platform_data();
946651cb LC	260	if (!IS_ERR(wl1251_board_data)) {
1d207cd3	261	wl->power_gpio = wl1251_board_data->power_gpio;
946651cb LC	262	wl->irq = wl1251_board_data->irq;
946651cb LC	263	wl->use_eeprom = wl1251_board_data->use_eeprom;
8c00b39f GI	264	}
8c00b39f GI	265
1d207cd3 SR	266	if (gpio_is_valid(wl->power_gpio)) {
	267	ret = devm_gpio_request(&func->dev, wl->power_gpio,
	268	"wl1251 power");
	269	if (ret) {
	270	wl1251_error("Failed to request gpio: %d\n", ret);
	271	goto disable;
	272	}
	273	}
	274
a02a2956	275	if (wl->irq) {
f380f2c4	276	irq_set_status_flags(wl->irq, IRQ_NOAUTOEN);
a02a2956 GI	277	ret = request_irq(wl->irq, wl1251_line_irq, 0, "wl1251", wl);
	278	if (ret < 0) {
	279	wl1251_error("request_irq() failed: %d", ret);
	280	goto disable;
	281	}
	282
dced35ae	283	irq_set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
a02a2956 GI	284
	285	wl1251_sdio_ops.enable_irq = wl1251_enable_line_irq;
	286	wl1251_sdio_ops.disable_irq = wl1251_disable_line_irq;
	287
	288	wl1251_info("using dedicated interrupt line");
	289	} else {
	290	wl1251_sdio_ops.enable_irq = wl1251_sdio_enable_irq;
	291	wl1251_sdio_ops.disable_irq = wl1251_sdio_disable_irq;
	292
	293	wl1251_info("using SDIO interrupt");
	294	}
	295
3ec410d7	296	ret = wl1251_init_ieee80211(wl);
3ec410d7	297	if (ret)
a02a2956	298	goto out_free_irq;
3ec410d7	299
3ec410d7	300	sdio_set_drvdata(func, wl);
1d4b89f2 GI	301
	302	/* Tell PM core that we don't need the card to be powered now */
	303	pm_runtime_put_noidle(&func->dev);
	304
3ec410d7 BC	305	return ret;
3ec410d7 BC	306
a02a2956 GI	307	out_free_irq:
	308	if (wl->irq)
	309	free_irq(wl->irq, wl);
3ec410d7	310	disable:
b5ed9c1b	311	sdio_claim_host(func);
3ec410d7 BC	312	sdio_disable_func(func);
	313	release:
	314	sdio_release_host(func);
832c10fd GI	315	kfree(wl_sdio);
832c10fd GI	316	out_free_hw:
aa679c36	317	wl1251_free_hw(wl);
3ec410d7 BC	318	return ret;
	319	}
	320
b74324d1	321	static void wl1251_sdio_remove(struct sdio_func *func)
3ec410d7 BC	322	{
3ec410d7 BC	323	struct wl1251 *wl = sdio_get_drvdata(func);
832c10fd	324	struct wl1251_sdio *wl_sdio = wl->if_priv;
3ec410d7	325
1d4b89f2 GI	326	/* Undo decrement done above in wl1251_probe */
	327	pm_runtime_get_noresume(&func->dev);
	328
a02a2956 GI	329	if (wl->irq)
a02a2956 GI	330	free_irq(wl->irq, wl);
3ec410d7	331	wl1251_free_hw(wl);
328c32f0	332	kfree(wl_sdio);
3ec410d7 BC	333
	334	sdio_claim_host(func);
	335	sdio_release_irq(func);
	336	sdio_disable_func(func);
	337	sdio_release_host(func);
	338	}
	339
1d4b89f2 GI	340	static int wl1251_suspend(struct device *dev)
	341	{
	342	/*
	343	* Tell MMC/SDIO core it's OK to power down the card
	344	* (if it isn't already), but not to remove it completely.
	345	*/
	346	return 0;
	347	}
	348
	349	static int wl1251_resume(struct device *dev)
	350	{
	351	return 0;
	352	}
	353
	354	static const struct dev_pm_ops wl1251_sdio_pm_ops = {
	355	.suspend = wl1251_suspend,
	356	.resume = wl1251_resume,
	357	};
	358
3ec410d7 BC	359	static struct sdio_driver wl1251_sdio_driver = {
	360	.name = "wl1251_sdio",
	361	.id_table = wl1251_devices,
	362	.probe = wl1251_sdio_probe,
b74324d1	363	.remove = wl1251_sdio_remove,
1d4b89f2	364	.drv.pm = &wl1251_sdio_pm_ops,
3ec410d7 BC	365	};
	366
	367	static int __init wl1251_sdio_init(void)
	368	{
	369	int err;
	370
	371	err = sdio_register_driver(&wl1251_sdio_driver);
	372	if (err)
	373	wl1251_error("failed to register sdio driver: %d", err);
	374	return err;
	375	}
	376
	377	static void __exit wl1251_sdio_exit(void)
	378	{
	379	sdio_unregister_driver(&wl1251_sdio_driver);
	380	wl1251_notice("unloaded");
	381	}
	382
	383	module_init(wl1251_sdio_init);
	384	module_exit(wl1251_sdio_exit);
	385
	386	MODULE_LICENSE("GPL");
31c726f0	387	MODULE_AUTHOR("Kalle Valo <kvalo@adurom.com>");