3 * Generic Bluetooth SDIO driver
5 * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
6 * Copyright (C) 2007 Marcel Holtmann <marcel@holtmann.org>
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.
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.
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
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>
34 #include <linux/mmc/sdio_ids.h>
35 #include <linux/mmc/sdio_func.h>
37 #include <net/bluetooth/bluetooth.h>
38 #include <net/bluetooth/hci_core.h>
42 static const struct sdio_device_id btsdio_table
[] = {
43 /* Generic Bluetooth Type-A SDIO device */
44 { SDIO_DEVICE_CLASS(SDIO_CLASS_BT_A
) },
46 /* Generic Bluetooth Type-B SDIO device */
47 { SDIO_DEVICE_CLASS(SDIO_CLASS_BT_B
) },
49 /* Generic Bluetooth AMP controller */
50 { SDIO_DEVICE_CLASS(SDIO_CLASS_BT_AMP
) },
52 { } /* Terminating entry */
55 MODULE_DEVICE_TABLE(sdio
, btsdio_table
);
59 struct sdio_func
*func
;
61 struct work_struct work
;
63 struct sk_buff_head txq
;
66 #define REG_RDAT 0x00 /* Receiver Data */
67 #define REG_TDAT 0x00 /* Transmitter Data */
68 #define REG_PC_RRT 0x10 /* Read Packet Control */
69 #define REG_PC_WRT 0x11 /* Write Packet Control */
70 #define REG_RTC_STAT 0x12 /* Retry Control Status */
71 #define REG_RTC_SET 0x12 /* Retry Control Set */
72 #define REG_INTRD 0x13 /* Interrupt Indication */
73 #define REG_CL_INTRD 0x13 /* Interrupt Clear */
74 #define REG_EN_INTRD 0x14 /* Interrupt Enable */
75 #define REG_MD_STAT 0x20 /* Bluetooth Mode Status */
77 static int btsdio_tx_packet(struct btsdio_data
*data
, struct sk_buff
*skb
)
81 BT_DBG("%s", data
->hdev
->name
);
83 /* Prepend Type-A header */
85 skb
->data
[0] = (skb
->len
& 0x0000ff);
86 skb
->data
[1] = (skb
->len
& 0x00ff00) >> 8;
87 skb
->data
[2] = (skb
->len
& 0xff0000) >> 16;
88 skb
->data
[3] = bt_cb(skb
)->pkt_type
;
90 err
= sdio_writesb(data
->func
, REG_TDAT
, skb
->data
, skb
->len
);
93 sdio_writeb(data
->func
, 0x01, REG_PC_WRT
, NULL
);
97 data
->hdev
->stat
.byte_tx
+= skb
->len
;
104 static void btsdio_work(struct work_struct
*work
)
106 struct btsdio_data
*data
= container_of(work
, struct btsdio_data
, work
);
110 BT_DBG("%s", data
->hdev
->name
);
112 sdio_claim_host(data
->func
);
114 while ((skb
= skb_dequeue(&data
->txq
))) {
115 err
= btsdio_tx_packet(data
, skb
);
117 data
->hdev
->stat
.err_tx
++;
118 skb_queue_head(&data
->txq
, skb
);
123 sdio_release_host(data
->func
);
126 static int btsdio_rx_packet(struct btsdio_data
*data
)
128 u8 hdr
[4] __attribute__ ((aligned(4)));
132 BT_DBG("%s", data
->hdev
->name
);
134 err
= sdio_readsb(data
->func
, hdr
, REG_RDAT
, 4);
138 len
= hdr
[0] | (hdr
[1] << 8) | (hdr
[2] << 16);
139 if (len
< 4 || len
> 65543)
142 skb
= bt_skb_alloc(len
- 4, GFP_KERNEL
);
144 /* Out of memory. Prepare a read retry and just
145 * return with the expectation that the next time
146 * we're called we'll have more memory. */
150 skb_put(skb
, len
- 4);
152 err
= sdio_readsb(data
->func
, skb
->data
, REG_RDAT
, len
- 4);
158 data
->hdev
->stat
.byte_rx
+= len
;
160 bt_cb(skb
)->pkt_type
= hdr
[3];
162 err
= hci_recv_frame(data
->hdev
, skb
);
166 sdio_writeb(data
->func
, 0x00, REG_PC_RRT
, NULL
);
171 static void btsdio_interrupt(struct sdio_func
*func
)
173 struct btsdio_data
*data
= sdio_get_drvdata(func
);
176 BT_DBG("%s", data
->hdev
->name
);
178 intrd
= sdio_readb(func
, REG_INTRD
, NULL
);
180 sdio_writeb(func
, 0x01, REG_CL_INTRD
, NULL
);
182 if (btsdio_rx_packet(data
) < 0) {
183 data
->hdev
->stat
.err_rx
++;
184 sdio_writeb(data
->func
, 0x01, REG_PC_RRT
, NULL
);
189 static int btsdio_open(struct hci_dev
*hdev
)
191 struct btsdio_data
*data
= hci_get_drvdata(hdev
);
194 BT_DBG("%s", hdev
->name
);
196 if (test_and_set_bit(HCI_RUNNING
, &hdev
->flags
))
199 sdio_claim_host(data
->func
);
201 err
= sdio_enable_func(data
->func
);
203 clear_bit(HCI_RUNNING
, &hdev
->flags
);
207 err
= sdio_claim_irq(data
->func
, btsdio_interrupt
);
209 sdio_disable_func(data
->func
);
210 clear_bit(HCI_RUNNING
, &hdev
->flags
);
214 if (data
->func
->class == SDIO_CLASS_BT_B
)
215 sdio_writeb(data
->func
, 0x00, REG_MD_STAT
, NULL
);
217 sdio_writeb(data
->func
, 0x01, REG_EN_INTRD
, NULL
);
220 sdio_release_host(data
->func
);
225 static int btsdio_close(struct hci_dev
*hdev
)
227 struct btsdio_data
*data
= hci_get_drvdata(hdev
);
229 BT_DBG("%s", hdev
->name
);
231 if (!test_and_clear_bit(HCI_RUNNING
, &hdev
->flags
))
234 sdio_claim_host(data
->func
);
236 sdio_writeb(data
->func
, 0x00, REG_EN_INTRD
, NULL
);
238 sdio_release_irq(data
->func
);
239 sdio_disable_func(data
->func
);
241 sdio_release_host(data
->func
);
246 static int btsdio_flush(struct hci_dev
*hdev
)
248 struct btsdio_data
*data
= hci_get_drvdata(hdev
);
250 BT_DBG("%s", hdev
->name
);
252 skb_queue_purge(&data
->txq
);
257 static int btsdio_send_frame(struct hci_dev
*hdev
, struct sk_buff
*skb
)
259 struct btsdio_data
*data
= hci_get_drvdata(hdev
);
261 BT_DBG("%s", hdev
->name
);
263 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
266 switch (bt_cb(skb
)->pkt_type
) {
267 case HCI_COMMAND_PKT
:
271 case HCI_ACLDATA_PKT
:
275 case HCI_SCODATA_PKT
:
283 skb_queue_tail(&data
->txq
, skb
);
285 schedule_work(&data
->work
);
290 static int btsdio_probe(struct sdio_func
*func
,
291 const struct sdio_device_id
*id
)
293 struct btsdio_data
*data
;
294 struct hci_dev
*hdev
;
295 struct sdio_func_tuple
*tuple
= func
->tuples
;
298 BT_DBG("func %p id %p class 0x%04x", func
, id
, func
->class);
301 BT_DBG("code 0x%x size %d", tuple
->code
, tuple
->size
);
305 data
= devm_kzalloc(&func
->dev
, sizeof(*data
), GFP_KERNEL
);
311 INIT_WORK(&data
->work
, btsdio_work
);
313 skb_queue_head_init(&data
->txq
);
315 hdev
= hci_alloc_dev();
319 hdev
->bus
= HCI_SDIO
;
320 hci_set_drvdata(hdev
, data
);
322 if (id
->class == SDIO_CLASS_BT_AMP
)
323 hdev
->dev_type
= HCI_AMP
;
325 hdev
->dev_type
= HCI_BREDR
;
329 SET_HCIDEV_DEV(hdev
, &func
->dev
);
331 hdev
->open
= btsdio_open
;
332 hdev
->close
= btsdio_close
;
333 hdev
->flush
= btsdio_flush
;
334 hdev
->send
= btsdio_send_frame
;
336 err
= hci_register_dev(hdev
);
342 sdio_set_drvdata(func
, data
);
347 static void btsdio_remove(struct sdio_func
*func
)
349 struct btsdio_data
*data
= sdio_get_drvdata(func
);
350 struct hci_dev
*hdev
;
352 BT_DBG("func %p", func
);
359 sdio_set_drvdata(func
, NULL
);
361 hci_unregister_dev(hdev
);
366 static struct sdio_driver btsdio_driver
= {
368 .probe
= btsdio_probe
,
369 .remove
= btsdio_remove
,
370 .id_table
= btsdio_table
,
373 static int __init
btsdio_init(void)
375 BT_INFO("Generic Bluetooth SDIO driver ver %s", VERSION
);
377 return sdio_register_driver(&btsdio_driver
);
380 static void __exit
btsdio_exit(void)
382 sdio_unregister_driver(&btsdio_driver
);
385 module_init(btsdio_init
);
386 module_exit(btsdio_exit
);
388 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
389 MODULE_DESCRIPTION("Generic Bluetooth SDIO driver ver " VERSION
);
390 MODULE_VERSION(VERSION
);
391 MODULE_LICENSE("GPL");