[linux-2.6-block.git] / drivers / bluetooth / btsdio.c

/*
 *
 *  Generic Bluetooth SDIO driver
 *
 *  Copyright (C) 2007  Cambridge Silicon Radio Ltd.
 *  Copyright (C) 2007  Marcel Holtmann <marcel@holtmann.org>
 *
 *
 *  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/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/skbuff.h>

#include <linux/mmc/host.h>
#include <linux/mmc/sdio_ids.h>
#include <linux/mmc/sdio_func.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>

#define VERSION "0.1"

static const struct sdio_device_id btsdio_table[] = {
	/* Generic Bluetooth Type-A SDIO device */
	{ SDIO_DEVICE_CLASS(SDIO_CLASS_BT_A) },

	/* Generic Bluetooth Type-B SDIO device */
	{ SDIO_DEVICE_CLASS(SDIO_CLASS_BT_B) },

	/* Generic Bluetooth AMP controller */
	{ SDIO_DEVICE_CLASS(SDIO_CLASS_BT_AMP) },

	{ }	/* Terminating entry */
};

MODULE_DEVICE_TABLE(sdio, btsdio_table);

struct btsdio_data {
	struct hci_dev   *hdev;
	struct sdio_func *func;

	struct work_struct work;

	struct sk_buff_head txq;
};

#define REG_RDAT     0x00	/* Receiver Data */
#define REG_TDAT     0x00	/* Transmitter Data */
#define REG_PC_RRT   0x10	/* Read Packet Control */
#define REG_PC_WRT   0x11	/* Write Packet Control */
#define REG_RTC_STAT 0x12	/* Retry Control Status */
#define REG_RTC_SET  0x12	/* Retry Control Set */
#define REG_INTRD    0x13	/* Interrupt Indication */
#define REG_CL_INTRD 0x13	/* Interrupt Clear */
#define REG_EN_INTRD 0x14	/* Interrupt Enable */
#define REG_MD_STAT  0x20	/* Bluetooth Mode Status */
#define REG_MD_SET   0x20	/* Bluetooth Mode Set */

static int btsdio_tx_packet(struct btsdio_data *data, struct sk_buff *skb)
{
	int err;

	BT_DBG("%s", data->hdev->name);

	/* Prepend Type-A header */
	skb_push(skb, 4);
	skb->data[0] = (skb->len & 0x0000ff);
	skb->data[1] = (skb->len & 0x00ff00) >> 8;
	skb->data[2] = (skb->len & 0xff0000) >> 16;
	skb->data[3] = hci_skb_pkt_type(skb);

	err = sdio_writesb(data->func, REG_TDAT, skb->data, skb->len);
	if (err < 0) {
		skb_pull(skb, 4);
		sdio_writeb(data->func, 0x01, REG_PC_WRT, NULL);
		return err;
	}

	data->hdev->stat.byte_tx += skb->len;

	kfree_skb(skb);

	return 0;
}

static void btsdio_work(struct work_struct *work)
{
	struct btsdio_data *data = container_of(work, struct btsdio_data, work);
	struct sk_buff *skb;
	int err;

	BT_DBG("%s", data->hdev->name);

	sdio_claim_host(data->func);

	while ((skb = skb_dequeue(&data->txq))) {
		err = btsdio_tx_packet(data, skb);
		if (err < 0) {
			data->hdev->stat.err_tx++;
			skb_queue_head(&data->txq, skb);
			break;
		}
	}

	sdio_release_host(data->func);
}

static int btsdio_rx_packet(struct btsdio_data *data)
{
	u8 hdr[4] __attribute__ ((aligned(4)));
	struct sk_buff *skb;
	int err, len;

	BT_DBG("%s", data->hdev->name);

	err = sdio_readsb(data->func, hdr, REG_RDAT, 4);
	if (err < 0)
		return err;

	len = hdr[0] | (hdr[1] << 8) | (hdr[2] << 16);
	if (len < 4 || len > 65543)
		return -EILSEQ;

	skb = bt_skb_alloc(len - 4, GFP_KERNEL);
	if (!skb) {
		/* Out of memory. Prepare a read retry and just
		 * return with the expectation that the next time
		 * we're called we'll have more memory.
		 */
		return -ENOMEM;
	}

	skb_put(skb, len - 4);

	err = sdio_readsb(data->func, skb->data, REG_RDAT, len - 4);
	if (err < 0) {
		kfree_skb(skb);
		return err;
	}

	data->hdev->stat.byte_rx += len;

	hci_skb_pkt_type(skb) = hdr[3];

	err = hci_recv_frame(data->hdev, skb);
	if (err < 0)
		return err;

	sdio_writeb(data->func, 0x00, REG_PC_RRT, NULL);

	return 0;
}

static void btsdio_interrupt(struct sdio_func *func)
{
	struct btsdio_data *data = sdio_get_drvdata(func);
	int intrd;

	BT_DBG("%s", data->hdev->name);

	intrd = sdio_readb(func, REG_INTRD, NULL);
	if (intrd & 0x01) {
		sdio_writeb(func, 0x01, REG_CL_INTRD, NULL);

		if (btsdio_rx_packet(data) < 0) {
			data->hdev->stat.err_rx++;
			sdio_writeb(data->func, 0x01, REG_PC_RRT, NULL);
		}
	}
}

static int btsdio_open(struct hci_dev *hdev)
{
	struct btsdio_data *data = hci_get_drvdata(hdev);
	int err;

	BT_DBG("%s", hdev->name);

	sdio_claim_host(data->func);

	err = sdio_enable_func(data->func);
	if (err < 0)
		goto release;

	err = sdio_claim_irq(data->func, btsdio_interrupt);
	if (err < 0) {
		sdio_disable_func(data->func);
		goto release;
	}

	if (data->func->class == SDIO_CLASS_BT_B)
		sdio_writeb(data->func, 0x00, REG_MD_SET, NULL);

	sdio_writeb(data->func, 0x01, REG_EN_INTRD, NULL);

release:
	sdio_release_host(data->func);

	return err;
}

static int btsdio_close(struct hci_dev *hdev)
{
	struct btsdio_data *data = hci_get_drvdata(hdev);

	BT_DBG("%s", hdev->name);

	sdio_claim_host(data->func);

	sdio_writeb(data->func, 0x00, REG_EN_INTRD, NULL);

	sdio_release_irq(data->func);
	sdio_disable_func(data->func);

	sdio_release_host(data->func);

	return 0;
}

static int btsdio_flush(struct hci_dev *hdev)
{
	struct btsdio_data *data = hci_get_drvdata(hdev);

	BT_DBG("%s", hdev->name);

	skb_queue_purge(&data->txq);

	return 0;
}

static int btsdio_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct btsdio_data *data = hci_get_drvdata(hdev);

	BT_DBG("%s", hdev->name);

	switch (hci_skb_pkt_type(skb)) {
	case HCI_COMMAND_PKT:
		hdev->stat.cmd_tx++;
		break;

	case HCI_ACLDATA_PKT:
		hdev->stat.acl_tx++;
		break;

	case HCI_SCODATA_PKT:
		hdev->stat.sco_tx++;
		break;

	default:
		return -EILSEQ;
	}

	skb_queue_tail(&data->txq, skb);

	schedule_work(&data->work);

	return 0;
}

static int btsdio_probe(struct sdio_func *func,
				const struct sdio_device_id *id)
{
	struct btsdio_data *data;
	struct hci_dev *hdev;
	struct sdio_func_tuple *tuple = func->tuples;
	int err;

	BT_DBG("func %p id %p class 0x%04x", func, id, func->class);

	while (tuple) {
		BT_DBG("code 0x%x size %d", tuple->code, tuple->size);
		tuple = tuple->next;
	}

	/* Broadcom devices soldered onto the PCB (non-removable) use an
	 * UART connection for Bluetooth, ignore the BT SDIO interface.
	 */
	if (func->vendor == SDIO_VENDOR_ID_BROADCOM &&
	    !mmc_card_is_removable(func->card->host)) {
		switch (func->device) {
		case SDIO_DEVICE_ID_BROADCOM_43341:
		case SDIO_DEVICE_ID_BROADCOM_43430:
			return -ENODEV;
		}
	}

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

	data->func = func;

	INIT_WORK(&data->work, btsdio_work);

	skb_queue_head_init(&data->txq);

	hdev = hci_alloc_dev();
	if (!hdev)
		return -ENOMEM;

	hdev->bus = HCI_SDIO;
	hci_set_drvdata(hdev, data);

	if (id->class == SDIO_CLASS_BT_AMP)
		hdev->dev_type = HCI_AMP;
	else
		hdev->dev_type = HCI_PRIMARY;

	data->hdev = hdev;

	SET_HCIDEV_DEV(hdev, &func->dev);

	hdev->open     = btsdio_open;
	hdev->close    = btsdio_close;
	hdev->flush    = btsdio_flush;
	hdev->send     = btsdio_send_frame;

	if (func->vendor == 0x0104 && func->device == 0x00c5)
		set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);

	err = hci_register_dev(hdev);
	if (err < 0) {
		hci_free_dev(hdev);
		return err;
	}

	sdio_set_drvdata(func, data);

	return 0;
}

static void btsdio_remove(struct sdio_func *func)
{
	struct btsdio_data *data = sdio_get_drvdata(func);
	struct hci_dev *hdev;

	BT_DBG("func %p", func);

	if (!data)
		return;

	hdev = data->hdev;

	sdio_set_drvdata(func, NULL);

	hci_unregister_dev(hdev);

	hci_free_dev(hdev);
}

static struct sdio_driver btsdio_driver = {
	.name		= "btsdio",
	.probe		= btsdio_probe,
	.remove		= btsdio_remove,
	.id_table	= btsdio_table,
};

static int __init btsdio_init(void)
{
	BT_INFO("Generic Bluetooth SDIO driver ver %s", VERSION);

	return sdio_register_driver(&btsdio_driver);
}

static void __exit btsdio_exit(void)
{
	sdio_unregister_driver(&btsdio_driver);
}

module_init(btsdio_init);
module_exit(btsdio_exit);

MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Generic Bluetooth SDIO driver ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
Commit	Line	Data
ddbaf13e MH	1	/*
	2	*
	3	* Generic Bluetooth SDIO driver
	4	*
	5	* Copyright (C) 2007 Cambridge Silicon Radio Ltd.
	6	* Copyright (C) 2007 Marcel Holtmann <marcel@holtmann.org>
	7	*
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	22	*
	23	*/
	24
	25	#include <linux/kernel.h>
	26	#include <linux/module.h>
	27	#include <linux/init.h>
	28	#include <linux/slab.h>
	29	#include <linux/types.h>
	30	#include <linux/sched.h>
	31	#include <linux/errno.h>
	32	#include <linux/skbuff.h>
	33
b4cdaba2	34	#include <linux/mmc/host.h>
ddbaf13e MH	35	#include <linux/mmc/sdio_ids.h>
	36	#include <linux/mmc/sdio_func.h>
	37
	38	#include <net/bluetooth/bluetooth.h>
	39	#include <net/bluetooth/hci_core.h>
	40
ddbaf13e MH	41	#define VERSION "0.1"
	42
	43	static const struct sdio_device_id btsdio_table[] = {
	44	/* Generic Bluetooth Type-A SDIO device */
	45	{ SDIO_DEVICE_CLASS(SDIO_CLASS_BT_A) },
	46
	47	/* Generic Bluetooth Type-B SDIO device */
	48	{ SDIO_DEVICE_CLASS(SDIO_CLASS_BT_B) },
	49
fb3d8eb4 DV	50	/* Generic Bluetooth AMP controller */
	51	{ SDIO_DEVICE_CLASS(SDIO_CLASS_BT_AMP) },
	52
ddbaf13e MH	53	{ } /* Terminating entry */
	54	};
	55
	56	MODULE_DEVICE_TABLE(sdio, btsdio_table);
	57
	58	struct btsdio_data {
	59	struct hci_dev *hdev;
	60	struct sdio_func *func;
	61
	62	struct work_struct work;
	63
	64	struct sk_buff_head txq;
	65	};
	66
	67	#define REG_RDAT 0x00 /* Receiver Data */
	68	#define REG_TDAT 0x00 /* Transmitter Data */
	69	#define REG_PC_RRT 0x10 /* Read Packet Control */
	70	#define REG_PC_WRT 0x11 /* Write Packet Control */
	71	#define REG_RTC_STAT 0x12 /* Retry Control Status */
	72	#define REG_RTC_SET 0x12 /* Retry Control Set */
	73	#define REG_INTRD 0x13 /* Interrupt Indication */
	74	#define REG_CL_INTRD 0x13 /* Interrupt Clear */
	75	#define REG_EN_INTRD 0x14 /* Interrupt Enable */
	76	#define REG_MD_STAT 0x20 /* Bluetooth Mode Status */
bc721970	77	#define REG_MD_SET 0x20 /* Bluetooth Mode Set */
ddbaf13e MH	78
	79	static int btsdio_tx_packet(struct btsdio_data data, struct sk_buff skb)
	80	{
	81	int err;
	82
	83	BT_DBG("%s", data->hdev->name);
	84
	85	/* Prepend Type-A header */
	86	skb_push(skb, 4);
	87	skb->data[0] = (skb->len & 0x0000ff);
	88	skb->data[1] = (skb->len & 0x00ff00) >> 8;
	89	skb->data[2] = (skb->len & 0xff0000) >> 16;
618e8bc2	90	skb->data[3] = hci_skb_pkt_type(skb);
ddbaf13e MH	91
	92	err = sdio_writesb(data->func, REG_TDAT, skb->data, skb->len);
	93	if (err < 0) {
7644d63d	94	skb_pull(skb, 4);
ddbaf13e MH	95	sdio_writeb(data->func, 0x01, REG_PC_WRT, NULL);
	96	return err;
	97	}
	98
	99	data->hdev->stat.byte_tx += skb->len;
	100
	101	kfree_skb(skb);
	102
	103	return 0;
	104	}
	105
	106	static void btsdio_work(struct work_struct *work)
	107	{
	108	struct btsdio_data *data = container_of(work, struct btsdio_data, work);
	109	struct sk_buff *skb;
	110	int err;
	111
	112	BT_DBG("%s", data->hdev->name);
	113
	114	sdio_claim_host(data->func);
	115
	116	while ((skb = skb_dequeue(&data->txq))) {
	117	err = btsdio_tx_packet(data, skb);
	118	if (err < 0) {
	119	data->hdev->stat.err_tx++;
	120	skb_queue_head(&data->txq, skb);
	121	break;
	122	}
	123	}
	124
	125	sdio_release_host(data->func);
	126	}
	127
	128	static int btsdio_rx_packet(struct btsdio_data *data)
	129	{
	130	u8 hdr[4] __attribute__ ((aligned(4)));
	131	struct sk_buff *skb;
	132	int err, len;
	133
	134	BT_DBG("%s", data->hdev->name);
	135
	136	err = sdio_readsb(data->func, hdr, REG_RDAT, 4);
	137	if (err < 0)
	138	return err;
	139
	140	len = hdr[0] \| (hdr[1] << 8) \| (hdr[2] << 16);
	141	if (len < 4 \|\| len > 65543)
	142	return -EILSEQ;
	143
	144	skb = bt_skb_alloc(len - 4, GFP_KERNEL);
	145	if (!skb) {
	146	/* Out of memory. Prepare a read retry and just
	147	* return with the expectation that the next time
d98422cb DR	148	* we're called we'll have more memory.
d98422cb DR	149	*/
ddbaf13e MH	150	return -ENOMEM;
	151	}
	152
	153	skb_put(skb, len - 4);
	154
	155	err = sdio_readsb(data->func, skb->data, REG_RDAT, len - 4);
	156	if (err < 0) {
cbfd24a7	157	kfree_skb(skb);
ddbaf13e MH	158	return err;
	159	}
	160
	161	data->hdev->stat.byte_rx += len;
	162
618e8bc2	163	hci_skb_pkt_type(skb) = hdr[3];
ddbaf13e	164
e1a26170	165	err = hci_recv_frame(data->hdev, skb);
2fa99342	166	if (err < 0)
ddbaf13e	167	return err;
ddbaf13e MH	168
	169	sdio_writeb(data->func, 0x00, REG_PC_RRT, NULL);
	170
	171	return 0;
	172	}
	173
	174	static void btsdio_interrupt(struct sdio_func *func)
	175	{
	176	struct btsdio_data *data = sdio_get_drvdata(func);
	177	int intrd;
	178
	179	BT_DBG("%s", data->hdev->name);
	180
	181	intrd = sdio_readb(func, REG_INTRD, NULL);
	182	if (intrd & 0x01) {
	183	sdio_writeb(func, 0x01, REG_CL_INTRD, NULL);
	184
	185	if (btsdio_rx_packet(data) < 0) {
	186	data->hdev->stat.err_rx++;
	187	sdio_writeb(data->func, 0x01, REG_PC_RRT, NULL);
	188	}
	189	}
	190	}
	191
	192	static int btsdio_open(struct hci_dev *hdev)
	193	{
155961e8	194	struct btsdio_data *data = hci_get_drvdata(hdev);
ddbaf13e MH	195	int err;
	196
	197	BT_DBG("%s", hdev->name);
	198
ddbaf13e MH	199	sdio_claim_host(data->func);
	200
	201	err = sdio_enable_func(data->func);
e9ca8bf1	202	if (err < 0)
ddbaf13e	203	goto release;
ddbaf13e MH	204
	205	err = sdio_claim_irq(data->func, btsdio_interrupt);
	206	if (err < 0) {
	207	sdio_disable_func(data->func);
ddbaf13e MH	208	goto release;
	209	}
	210
	211	if (data->func->class == SDIO_CLASS_BT_B)
bc721970	212	sdio_writeb(data->func, 0x00, REG_MD_SET, NULL);
ddbaf13e MH	213
	214	sdio_writeb(data->func, 0x01, REG_EN_INTRD, NULL);
	215
	216	release:
	217	sdio_release_host(data->func);
	218
	219	return err;
	220	}
	221
	222	static int btsdio_close(struct hci_dev *hdev)
	223	{
155961e8	224	struct btsdio_data *data = hci_get_drvdata(hdev);
ddbaf13e MH	225
	226	BT_DBG("%s", hdev->name);
	227
ddbaf13e MH	228	sdio_claim_host(data->func);
	229
	230	sdio_writeb(data->func, 0x00, REG_EN_INTRD, NULL);
	231
	232	sdio_release_irq(data->func);
	233	sdio_disable_func(data->func);
	234
	235	sdio_release_host(data->func);
	236
	237	return 0;
	238	}
	239
	240	static int btsdio_flush(struct hci_dev *hdev)
	241	{
155961e8	242	struct btsdio_data *data = hci_get_drvdata(hdev);
ddbaf13e MH	243
	244	BT_DBG("%s", hdev->name);
	245
	246	skb_queue_purge(&data->txq);
	247
	248	return 0;
	249	}
	250
7bd8f09f	251	static int btsdio_send_frame(struct hci_dev hdev, struct sk_buff skb)
ddbaf13e	252	{
155961e8	253	struct btsdio_data *data = hci_get_drvdata(hdev);
ddbaf13e MH	254
	255	BT_DBG("%s", hdev->name);
	256
618e8bc2	257	switch (hci_skb_pkt_type(skb)) {
ddbaf13e MH	258	case HCI_COMMAND_PKT:
	259	hdev->stat.cmd_tx++;
	260	break;
	261
	262	case HCI_ACLDATA_PKT:
	263	hdev->stat.acl_tx++;
	264	break;
	265
	266	case HCI_SCODATA_PKT:
	267	hdev->stat.sco_tx++;
	268	break;
	269
	270	default:
	271	return -EILSEQ;
	272	}
	273
	274	skb_queue_tail(&data->txq, skb);
	275
	276	schedule_work(&data->work);
	277
	278	return 0;
	279	}
	280
ddbaf13e MH	281	static int btsdio_probe(struct sdio_func *func,
	282	const struct sdio_device_id *id)
	283	{
	284	struct btsdio_data *data;
	285	struct hci_dev *hdev;
	286	struct sdio_func_tuple *tuple = func->tuples;
	287	int err;
	288
	289	BT_DBG("func %p id %p class 0x%04x", func, id, func->class);
	290
	291	while (tuple) {
	292	BT_DBG("code 0x%x size %d", tuple->code, tuple->size);
	293	tuple = tuple->next;
	294	}
	295
70ecdd3d CYC	296	/* Broadcom devices soldered onto the PCB (non-removable) use an
70ecdd3d CYC	297	* UART connection for Bluetooth, ignore the BT SDIO interface.
b4cdaba2 HG	298	*/
b4cdaba2 HG	299	if (func->vendor == SDIO_VENDOR_ID_BROADCOM &&
70ecdd3d CYC	300	!mmc_card_is_removable(func->card->host)) {
	301	switch (func->device) {
	302	case SDIO_DEVICE_ID_BROADCOM_43341:
	303	case SDIO_DEVICE_ID_BROADCOM_43430:
	304	return -ENODEV;
	305	}
	306	}
b4cdaba2	307
3a382772	308	data = devm_kzalloc(&func->dev, sizeof(*data), GFP_KERNEL);
ddbaf13e MH	309	if (!data)
	310	return -ENOMEM;
	311
	312	data->func = func;
	313
	314	INIT_WORK(&data->work, btsdio_work);
	315
	316	skb_queue_head_init(&data->txq);
	317
	318	hdev = hci_alloc_dev();
3a382772	319	if (!hdev)
ddbaf13e	320	return -ENOMEM;
ddbaf13e	321
c13854ce	322	hdev->bus = HCI_SDIO;
155961e8	323	hci_set_drvdata(hdev, data);
ddbaf13e	324
fb3d8eb4 DV	325	if (id->class == SDIO_CLASS_BT_AMP)
	326	hdev->dev_type = HCI_AMP;
	327	else
ca8bee5d	328	hdev->dev_type = HCI_PRIMARY;
fb3d8eb4	329
ddbaf13e MH	330	data->hdev = hdev;
	331
	332	SET_HCIDEV_DEV(hdev, &func->dev);
	333
	334	hdev->open = btsdio_open;
	335	hdev->close = btsdio_close;
	336	hdev->flush = btsdio_flush;
	337	hdev->send = btsdio_send_frame;
ddbaf13e	338
de8b5828 MH	339	if (func->vendor == 0x0104 && func->device == 0x00c5)
	340	set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
	341
ddbaf13e MH	342	err = hci_register_dev(hdev);
	343	if (err < 0) {
	344	hci_free_dev(hdev);
ddbaf13e MH	345	return err;
	346	}
	347
	348	sdio_set_drvdata(func, data);
	349
	350	return 0;
	351	}
	352
	353	static void btsdio_remove(struct sdio_func *func)
	354	{
	355	struct btsdio_data *data = sdio_get_drvdata(func);
	356	struct hci_dev *hdev;
	357
	358	BT_DBG("func %p", func);
	359
	360	if (!data)
	361	return;
	362
	363	hdev = data->hdev;
	364
	365	sdio_set_drvdata(func, NULL);
	366
	367	hci_unregister_dev(hdev);
	368
	369	hci_free_dev(hdev);
	370	}
	371
	372	static struct sdio_driver btsdio_driver = {
	373	.name = "btsdio",
	374	.probe = btsdio_probe,
	375	.remove = btsdio_remove,
	376	.id_table = btsdio_table,
	377	};
	378
	379	static int __init btsdio_init(void)
	380	{
	381	BT_INFO("Generic Bluetooth SDIO driver ver %s", VERSION);
	382
	383	return sdio_register_driver(&btsdio_driver);
	384	}
	385
	386	static void __exit btsdio_exit(void)
	387	{
	388	sdio_unregister_driver(&btsdio_driver);
	389	}
	390
	391	module_init(btsdio_init);
	392	module_exit(btsdio_exit);
	393
	394	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	395	MODULE_DESCRIPTION("Generic Bluetooth SDIO driver ver " VERSION);
	396	MODULE_VERSION(VERSION);
	397	MODULE_LICENSE("GPL");