1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
34#include <linux/mmc/sdio_ids.h>
35#include <linux/mmc/sdio_func.h>
36
37#include <net/bluetooth/bluetooth.h>
38#include <net/bluetooth/hci_core.h>
39
40#define VERSION "0.1"
41
42static const struct sdio_device_id btsdio_table[] = {
43
44 { SDIO_DEVICE_CLASS(SDIO_CLASS_BT_A) },
45
46
47 { SDIO_DEVICE_CLASS(SDIO_CLASS_BT_B) },
48
49
50 { SDIO_DEVICE_CLASS(SDIO_CLASS_BT_AMP) },
51
52 { }
53};
54
55MODULE_DEVICE_TABLE(sdio, btsdio_table);
56
57struct btsdio_data {
58 struct hci_dev *hdev;
59 struct sdio_func *func;
60
61 struct work_struct work;
62
63 struct sk_buff_head txq;
64};
65
66#define REG_RDAT 0x00
67#define REG_TDAT 0x00
68#define REG_PC_RRT 0x10
69#define REG_PC_WRT 0x11
70#define REG_RTC_STAT 0x12
71#define REG_RTC_SET 0x12
72#define REG_INTRD 0x13
73#define REG_CL_INTRD 0x13
74#define REG_EN_INTRD 0x14
75#define REG_MD_STAT 0x20
76#define REG_MD_SET 0x20
77
78static int btsdio_tx_packet(struct btsdio_data *data, struct sk_buff *skb)
79{
80 int err;
81
82 BT_DBG("%s", data->hdev->name);
83
84
85 skb_push(skb, 4);
86 skb->data[0] = (skb->len & 0x0000ff);
87 skb->data[1] = (skb->len & 0x00ff00) >> 8;
88 skb->data[2] = (skb->len & 0xff0000) >> 16;
89 skb->data[3] = hci_skb_pkt_type(skb);
90
91 err = sdio_writesb(data->func, REG_TDAT, skb->data, skb->len);
92 if (err < 0) {
93 skb_pull(skb, 4);
94 sdio_writeb(data->func, 0x01, REG_PC_WRT, NULL);
95 return err;
96 }
97
98 data->hdev->stat.byte_tx += skb->len;
99
100 kfree_skb(skb);
101
102 return 0;
103}
104
105static void btsdio_work(struct work_struct *work)
106{
107 struct btsdio_data *data = container_of(work, struct btsdio_data, work);
108 struct sk_buff *skb;
109 int err;
110
111 BT_DBG("%s", data->hdev->name);
112
113 sdio_claim_host(data->func);
114
115 while ((skb = skb_dequeue(&data->txq))) {
116 err = btsdio_tx_packet(data, skb);
117 if (err < 0) {
118 data->hdev->stat.err_tx++;
119 skb_queue_head(&data->txq, skb);
120 break;
121 }
122 }
123
124 sdio_release_host(data->func);
125}
126
127static int btsdio_rx_packet(struct btsdio_data *data)
128{
129 u8 hdr[4] __attribute__ ((aligned(4)));
130 struct sk_buff *skb;
131 int err, len;
132
133 BT_DBG("%s", data->hdev->name);
134
135 err = sdio_readsb(data->func, hdr, REG_RDAT, 4);
136 if (err < 0)
137 return err;
138
139 len = hdr[0] | (hdr[1] << 8) | (hdr[2] << 16);
140 if (len < 4 || len > 65543)
141 return -EILSEQ;
142
143 skb = bt_skb_alloc(len - 4, GFP_KERNEL);
144 if (!skb) {
145
146
147
148
149 return -ENOMEM;
150 }
151
152 skb_put(skb, len - 4);
153
154 err = sdio_readsb(data->func, skb->data, REG_RDAT, len - 4);
155 if (err < 0) {
156 kfree_skb(skb);
157 return err;
158 }
159
160 data->hdev->stat.byte_rx += len;
161
162 hci_skb_pkt_type(skb) = hdr[3];
163
164 err = hci_recv_frame(data->hdev, skb);
165 if (err < 0)
166 return err;
167
168 sdio_writeb(data->func, 0x00, REG_PC_RRT, NULL);
169
170 return 0;
171}
172
173static void btsdio_interrupt(struct sdio_func *func)
174{
175 struct btsdio_data *data = sdio_get_drvdata(func);
176 int intrd;
177
178 BT_DBG("%s", data->hdev->name);
179
180 intrd = sdio_readb(func, REG_INTRD, NULL);
181 if (intrd & 0x01) {
182 sdio_writeb(func, 0x01, REG_CL_INTRD, NULL);
183
184 if (btsdio_rx_packet(data) < 0) {
185 data->hdev->stat.err_rx++;
186 sdio_writeb(data->func, 0x01, REG_PC_RRT, NULL);
187 }
188 }
189}
190
191static int btsdio_open(struct hci_dev *hdev)
192{
193 struct btsdio_data *data = hci_get_drvdata(hdev);
194 int err;
195
196 BT_DBG("%s", hdev->name);
197
198 sdio_claim_host(data->func);
199
200 err = sdio_enable_func(data->func);
201 if (err < 0)
202 goto release;
203
204 err = sdio_claim_irq(data->func, btsdio_interrupt);
205 if (err < 0) {
206 sdio_disable_func(data->func);
207 goto release;
208 }
209
210 if (data->func->class == SDIO_CLASS_BT_B)
211 sdio_writeb(data->func, 0x00, REG_MD_SET, NULL);
212
213 sdio_writeb(data->func, 0x01, REG_EN_INTRD, NULL);
214
215release:
216 sdio_release_host(data->func);
217
218 return err;
219}
220
221static int btsdio_close(struct hci_dev *hdev)
222{
223 struct btsdio_data *data = hci_get_drvdata(hdev);
224
225 BT_DBG("%s", hdev->name);
226
227 sdio_claim_host(data->func);
228
229 sdio_writeb(data->func, 0x00, REG_EN_INTRD, NULL);
230
231 sdio_release_irq(data->func);
232 sdio_disable_func(data->func);
233
234 sdio_release_host(data->func);
235
236 return 0;
237}
238
239static int btsdio_flush(struct hci_dev *hdev)
240{
241 struct btsdio_data *data = hci_get_drvdata(hdev);
242
243 BT_DBG("%s", hdev->name);
244
245 skb_queue_purge(&data->txq);
246
247 return 0;
248}
249
250static int btsdio_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
251{
252 struct btsdio_data *data = hci_get_drvdata(hdev);
253
254 BT_DBG("%s", hdev->name);
255
256 switch (hci_skb_pkt_type(skb)) {
257 case HCI_COMMAND_PKT:
258 hdev->stat.cmd_tx++;
259 break;
260
261 case HCI_ACLDATA_PKT:
262 hdev->stat.acl_tx++;
263 break;
264
265 case HCI_SCODATA_PKT:
266 hdev->stat.sco_tx++;
267 break;
268
269 default:
270 return -EILSEQ;
271 }
272
273 skb_queue_tail(&data->txq, skb);
274
275 schedule_work(&data->work);
276
277 return 0;
278}
279
280static int btsdio_probe(struct sdio_func *func,
281 const struct sdio_device_id *id)
282{
283 struct btsdio_data *data;
284 struct hci_dev *hdev;
285 struct sdio_func_tuple *tuple = func->tuples;
286 int err;
287
288 BT_DBG("func %p id %p class 0x%04x", func, id, func->class);
289
290 while (tuple) {
291 BT_DBG("code 0x%x size %d", tuple->code, tuple->size);
292 tuple = tuple->next;
293 }
294
295 data = devm_kzalloc(&func->dev, sizeof(*data), GFP_KERNEL);
296 if (!data)
297 return -ENOMEM;
298
299 data->func = func;
300
301 INIT_WORK(&data->work, btsdio_work);
302
303 skb_queue_head_init(&data->txq);
304
305 hdev = hci_alloc_dev();
306 if (!hdev)
307 return -ENOMEM;
308
309 hdev->bus = HCI_SDIO;
310 hci_set_drvdata(hdev, data);
311
312 if (id->class == SDIO_CLASS_BT_AMP)
313 hdev->dev_type = HCI_AMP;
314 else
315 hdev->dev_type = HCI_PRIMARY;
316
317 data->hdev = hdev;
318
319 SET_HCIDEV_DEV(hdev, &func->dev);
320
321 hdev->open = btsdio_open;
322 hdev->close = btsdio_close;
323 hdev->flush = btsdio_flush;
324 hdev->send = btsdio_send_frame;
325
326 if (func->vendor == 0x0104 && func->device == 0x00c5)
327 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
328
329 err = hci_register_dev(hdev);
330 if (err < 0) {
331 hci_free_dev(hdev);
332 return err;
333 }
334
335 sdio_set_drvdata(func, data);
336
337 return 0;
338}
339
340static void btsdio_remove(struct sdio_func *func)
341{
342 struct btsdio_data *data = sdio_get_drvdata(func);
343 struct hci_dev *hdev;
344
345 BT_DBG("func %p", func);
346
347 if (!data)
348 return;
349
350 hdev = data->hdev;
351
352 sdio_set_drvdata(func, NULL);
353
354 hci_unregister_dev(hdev);
355
356 hci_free_dev(hdev);
357}
358
359static struct sdio_driver btsdio_driver = {
360 .name = "btsdio",
361 .probe = btsdio_probe,
362 .remove = btsdio_remove,
363 .id_table = btsdio_table,
364};
365
366static int __init btsdio_init(void)
367{
368 BT_INFO("Generic Bluetooth SDIO driver ver %s", VERSION);
369
370 return sdio_register_driver(&btsdio_driver);
371}
372
373static void __exit btsdio_exit(void)
374{
375 sdio_unregister_driver(&btsdio_driver);
376}
377
378module_init(btsdio_init);
379module_exit(btsdio_exit);
380
381MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
382MODULE_DESCRIPTION("Generic Bluetooth SDIO driver ver " VERSION);
383MODULE_VERSION(VERSION);
384MODULE_LICENSE("GPL");
385
