1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/module.h>
22
23#include <net/bluetooth/bluetooth.h>
24#include <net/bluetooth/hci_core.h>
25
26#include "btmrvl_drv.h"
27
28#define VERSION "1.0"
29
30
31
32
33
34
35void btmrvl_interrupt(struct btmrvl_private *priv)
36{
37 priv->adapter->ps_state = PS_AWAKE;
38
39 priv->adapter->wakeup_tries = 0;
40
41 priv->adapter->int_count++;
42
43 wake_up_interruptible(&priv->main_thread.wait_q);
44}
45EXPORT_SYMBOL_GPL(btmrvl_interrupt);
46
47bool btmrvl_check_evtpkt(struct btmrvl_private *priv, struct sk_buff *skb)
48{
49 struct hci_event_hdr *hdr = (void *) skb->data;
50
51 if (hdr->evt == HCI_EV_CMD_COMPLETE) {
52 struct hci_ev_cmd_complete *ec;
53 u16 opcode, ocf, ogf;
54
55 ec = (void *) (skb->data + HCI_EVENT_HDR_SIZE);
56 opcode = __le16_to_cpu(ec->opcode);
57 ocf = hci_opcode_ocf(opcode);
58 ogf = hci_opcode_ogf(opcode);
59
60 if (ocf == BT_CMD_MODULE_CFG_REQ &&
61 priv->btmrvl_dev.sendcmdflag) {
62 priv->btmrvl_dev.sendcmdflag = false;
63 priv->adapter->cmd_complete = true;
64 wake_up_interruptible(&priv->adapter->cmd_wait_q);
65 }
66
67 if (ogf == OGF) {
68 BT_DBG("vendor event skipped: ogf 0x%4.4x ocf 0x%4.4x",
69 ogf, ocf);
70 kfree_skb(skb);
71 return false;
72 }
73 }
74
75 return true;
76}
77EXPORT_SYMBOL_GPL(btmrvl_check_evtpkt);
78
79int btmrvl_process_event(struct btmrvl_private *priv, struct sk_buff *skb)
80{
81 struct btmrvl_adapter *adapter = priv->adapter;
82 struct btmrvl_event *event;
83 int ret = 0;
84
85 event = (struct btmrvl_event *) skb->data;
86 if (event->ec != 0xff) {
87 BT_DBG("Not Marvell Event=%x", event->ec);
88 ret = -EINVAL;
89 goto exit;
90 }
91
92 switch (event->data[0]) {
93 case BT_CMD_AUTO_SLEEP_MODE:
94 if (!event->data[2]) {
95 if (event->data[1] == BT_PS_ENABLE)
96 adapter->psmode = 1;
97 else
98 adapter->psmode = 0;
99 BT_DBG("PS Mode:%s",
100 (adapter->psmode) ? "Enable" : "Disable");
101 } else {
102 BT_DBG("PS Mode command failed");
103 }
104 break;
105
106 case BT_CMD_HOST_SLEEP_CONFIG:
107 if (!event->data[3])
108 BT_DBG("gpio=%x, gap=%x", event->data[1],
109 event->data[2]);
110 else
111 BT_DBG("HSCFG command failed");
112 break;
113
114 case BT_CMD_HOST_SLEEP_ENABLE:
115 if (!event->data[1]) {
116 adapter->hs_state = HS_ACTIVATED;
117 if (adapter->psmode)
118 adapter->ps_state = PS_SLEEP;
119 wake_up_interruptible(&adapter->cmd_wait_q);
120 BT_DBG("HS ACTIVATED!");
121 } else {
122 BT_DBG("HS Enable failed");
123 }
124 break;
125
126 case BT_CMD_MODULE_CFG_REQ:
127 if (priv->btmrvl_dev.sendcmdflag &&
128 event->data[1] == MODULE_BRINGUP_REQ) {
129 BT_DBG("EVENT:%s",
130 ((event->data[2] == MODULE_BROUGHT_UP) ||
131 (event->data[2] == MODULE_ALREADY_UP)) ?
132 "Bring-up succeed" : "Bring-up failed");
133
134 if (event->length > 3 && event->data[3])
135 priv->btmrvl_dev.dev_type = HCI_AMP;
136 else
137 priv->btmrvl_dev.dev_type = HCI_BREDR;
138
139 BT_DBG("dev_type: %d", priv->btmrvl_dev.dev_type);
140 } else if (priv->btmrvl_dev.sendcmdflag &&
141 event->data[1] == MODULE_SHUTDOWN_REQ) {
142 BT_DBG("EVENT:%s", (event->data[2]) ?
143 "Shutdown failed" : "Shutdown succeed");
144 } else {
145 BT_DBG("BT_CMD_MODULE_CFG_REQ resp for APP");
146 ret = -EINVAL;
147 }
148 break;
149
150 case BT_EVENT_POWER_STATE:
151 if (event->data[1] == BT_PS_SLEEP)
152 adapter->ps_state = PS_SLEEP;
153 BT_DBG("EVENT:%s",
154 (adapter->ps_state) ? "PS_SLEEP" : "PS_AWAKE");
155 break;
156
157 default:
158 BT_DBG("Unknown Event=%d", event->data[0]);
159 ret = -EINVAL;
160 break;
161 }
162
163exit:
164 if (!ret)
165 kfree_skb(skb);
166
167 return ret;
168}
169EXPORT_SYMBOL_GPL(btmrvl_process_event);
170
171int btmrvl_send_module_cfg_cmd(struct btmrvl_private *priv, int subcmd)
172{
173 struct sk_buff *skb;
174 struct btmrvl_cmd *cmd;
175 int ret = 0;
176
177 skb = bt_skb_alloc(sizeof(*cmd), GFP_ATOMIC);
178 if (skb == NULL) {
179 BT_ERR("No free skb");
180 return -ENOMEM;
181 }
182
183 cmd = (struct btmrvl_cmd *) skb_put(skb, sizeof(*cmd));
184 cmd->ocf_ogf = cpu_to_le16(hci_opcode_pack(OGF, BT_CMD_MODULE_CFG_REQ));
185 cmd->length = 1;
186 cmd->data[0] = subcmd;
187
188 bt_cb(skb)->pkt_type = MRVL_VENDOR_PKT;
189
190 skb->dev = (void *) priv->btmrvl_dev.hcidev;
191 skb_queue_head(&priv->adapter->tx_queue, skb);
192
193 priv->btmrvl_dev.sendcmdflag = true;
194
195 priv->adapter->cmd_complete = false;
196
197 BT_DBG("Queue module cfg Command");
198
199 wake_up_interruptible(&priv->main_thread.wait_q);
200
201 if (!wait_event_interruptible_timeout(priv->adapter->cmd_wait_q,
202 priv->adapter->cmd_complete,
203 msecs_to_jiffies(WAIT_UNTIL_CMD_RESP))) {
204 ret = -ETIMEDOUT;
205 BT_ERR("module_cfg_cmd(%x): timeout: %d",
206 subcmd, priv->btmrvl_dev.sendcmdflag);
207 }
208
209 BT_DBG("module cfg Command done");
210
211 return ret;
212}
213EXPORT_SYMBOL_GPL(btmrvl_send_module_cfg_cmd);
214
215int btmrvl_send_hscfg_cmd(struct btmrvl_private *priv)
216{
217 struct sk_buff *skb;
218 struct btmrvl_cmd *cmd;
219
220 skb = bt_skb_alloc(sizeof(*cmd), GFP_ATOMIC);
221 if (!skb) {
222 BT_ERR("No free skb");
223 return -ENOMEM;
224 }
225
226 cmd = (struct btmrvl_cmd *) skb_put(skb, sizeof(*cmd));
227 cmd->ocf_ogf = cpu_to_le16(hci_opcode_pack(OGF,
228 BT_CMD_HOST_SLEEP_CONFIG));
229 cmd->length = 2;
230 cmd->data[0] = (priv->btmrvl_dev.gpio_gap & 0xff00) >> 8;
231 cmd->data[1] = (u8) (priv->btmrvl_dev.gpio_gap & 0x00ff);
232
233 bt_cb(skb)->pkt_type = MRVL_VENDOR_PKT;
234
235 skb->dev = (void *) priv->btmrvl_dev.hcidev;
236 skb_queue_head(&priv->adapter->tx_queue, skb);
237
238 BT_DBG("Queue HSCFG Command, gpio=0x%x, gap=0x%x", cmd->data[0],
239 cmd->data[1]);
240
241 return 0;
242}
243EXPORT_SYMBOL_GPL(btmrvl_send_hscfg_cmd);
244
245int btmrvl_enable_ps(struct btmrvl_private *priv)
246{
247 struct sk_buff *skb;
248 struct btmrvl_cmd *cmd;
249
250 skb = bt_skb_alloc(sizeof(*cmd), GFP_ATOMIC);
251 if (skb == NULL) {
252 BT_ERR("No free skb");
253 return -ENOMEM;
254 }
255
256 cmd = (struct btmrvl_cmd *) skb_put(skb, sizeof(*cmd));
257 cmd->ocf_ogf = cpu_to_le16(hci_opcode_pack(OGF,
258 BT_CMD_AUTO_SLEEP_MODE));
259 cmd->length = 1;
260
261 if (priv->btmrvl_dev.psmode)
262 cmd->data[0] = BT_PS_ENABLE;
263 else
264 cmd->data[0] = BT_PS_DISABLE;
265
266 bt_cb(skb)->pkt_type = MRVL_VENDOR_PKT;
267
268 skb->dev = (void *) priv->btmrvl_dev.hcidev;
269 skb_queue_head(&priv->adapter->tx_queue, skb);
270
271 BT_DBG("Queue PSMODE Command:%d", cmd->data[0]);
272
273 return 0;
274}
275EXPORT_SYMBOL_GPL(btmrvl_enable_ps);
276
277int btmrvl_enable_hs(struct btmrvl_private *priv)
278{
279 struct sk_buff *skb;
280 struct btmrvl_cmd *cmd;
281 int ret = 0;
282
283 skb = bt_skb_alloc(sizeof(*cmd), GFP_ATOMIC);
284 if (skb == NULL) {
285 BT_ERR("No free skb");
286 return -ENOMEM;
287 }
288
289 cmd = (struct btmrvl_cmd *) skb_put(skb, sizeof(*cmd));
290 cmd->ocf_ogf = cpu_to_le16(hci_opcode_pack(OGF, BT_CMD_HOST_SLEEP_ENABLE));
291 cmd->length = 0;
292
293 bt_cb(skb)->pkt_type = MRVL_VENDOR_PKT;
294
295 skb->dev = (void *) priv->btmrvl_dev.hcidev;
296 skb_queue_head(&priv->adapter->tx_queue, skb);
297
298 BT_DBG("Queue hs enable Command");
299
300 wake_up_interruptible(&priv->main_thread.wait_q);
301
302 if (!wait_event_interruptible_timeout(priv->adapter->cmd_wait_q,
303 priv->adapter->hs_state,
304 msecs_to_jiffies(WAIT_UNTIL_HS_STATE_CHANGED))) {
305 ret = -ETIMEDOUT;
306 BT_ERR("timeout: %d, %d,%d", priv->adapter->hs_state,
307 priv->adapter->ps_state,
308 priv->adapter->wakeup_tries);
309 }
310
311 return ret;
312}
313EXPORT_SYMBOL_GPL(btmrvl_enable_hs);
314
315int btmrvl_prepare_command(struct btmrvl_private *priv)
316{
317 int ret = 0;
318
319 if (priv->btmrvl_dev.hscfgcmd) {
320 priv->btmrvl_dev.hscfgcmd = 0;
321 btmrvl_send_hscfg_cmd(priv);
322 }
323
324 if (priv->btmrvl_dev.pscmd) {
325 priv->btmrvl_dev.pscmd = 0;
326 btmrvl_enable_ps(priv);
327 }
328
329 if (priv->btmrvl_dev.hscmd) {
330 priv->btmrvl_dev.hscmd = 0;
331
332 if (priv->btmrvl_dev.hsmode) {
333 ret = btmrvl_enable_hs(priv);
334 } else {
335 ret = priv->hw_wakeup_firmware(priv);
336 priv->adapter->hs_state = HS_DEACTIVATED;
337 }
338 }
339
340 return ret;
341}
342
343static int btmrvl_tx_pkt(struct btmrvl_private *priv, struct sk_buff *skb)
344{
345 int ret = 0;
346
347 if (!skb || !skb->data)
348 return -EINVAL;
349
350 if (!skb->len || ((skb->len + BTM_HEADER_LEN) > BTM_UPLD_SIZE)) {
351 BT_ERR("Tx Error: Bad skb length %d : %d",
352 skb->len, BTM_UPLD_SIZE);
353 return -EINVAL;
354 }
355
356 if (skb_headroom(skb) < BTM_HEADER_LEN) {
357 struct sk_buff *tmp = skb;
358
359 skb = skb_realloc_headroom(skb, BTM_HEADER_LEN);
360 if (!skb) {
361 BT_ERR("Tx Error: realloc_headroom failed %d",
362 BTM_HEADER_LEN);
363 skb = tmp;
364 return -EINVAL;
365 }
366
367 kfree_skb(tmp);
368 }
369
370 skb_push(skb, BTM_HEADER_LEN);
371
372
373
374
375
376
377 skb->data[0] = (skb->len & 0x0000ff);
378 skb->data[1] = (skb->len & 0x00ff00) >> 8;
379 skb->data[2] = (skb->len & 0xff0000) >> 16;
380 skb->data[3] = bt_cb(skb)->pkt_type;
381
382 if (priv->hw_host_to_card)
383 ret = priv->hw_host_to_card(priv, skb->data, skb->len);
384
385 return ret;
386}
387
388static void btmrvl_init_adapter(struct btmrvl_private *priv)
389{
390 skb_queue_head_init(&priv->adapter->tx_queue);
391
392 priv->adapter->ps_state = PS_AWAKE;
393
394 init_waitqueue_head(&priv->adapter->cmd_wait_q);
395}
396
397static void btmrvl_free_adapter(struct btmrvl_private *priv)
398{
399 skb_queue_purge(&priv->adapter->tx_queue);
400
401 kfree(priv->adapter);
402
403 priv->adapter = NULL;
404}
405
406static int btmrvl_ioctl(struct hci_dev *hdev,
407 unsigned int cmd, unsigned long arg)
408{
409 return -ENOIOCTLCMD;
410}
411
412static int btmrvl_send_frame(struct sk_buff *skb)
413{
414 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
415 struct btmrvl_private *priv = NULL;
416
417 BT_DBG("type=%d, len=%d", skb->pkt_type, skb->len);
418
419 if (!hdev) {
420 BT_ERR("Frame for unknown HCI device");
421 return -ENODEV;
422 }
423
424 priv = hci_get_drvdata(hdev);
425
426 if (!test_bit(HCI_RUNNING, &hdev->flags)) {
427 BT_ERR("Failed testing HCI_RUNING, flags=%lx", hdev->flags);
428 print_hex_dump_bytes("data: ", DUMP_PREFIX_OFFSET,
429 skb->data, skb->len);
430 return -EBUSY;
431 }
432
433 switch (bt_cb(skb)->pkt_type) {
434 case HCI_COMMAND_PKT:
435 hdev->stat.cmd_tx++;
436 break;
437
438 case HCI_ACLDATA_PKT:
439 hdev->stat.acl_tx++;
440 break;
441
442 case HCI_SCODATA_PKT:
443 hdev->stat.sco_tx++;
444 break;
445 }
446
447 skb_queue_tail(&priv->adapter->tx_queue, skb);
448
449 wake_up_interruptible(&priv->main_thread.wait_q);
450
451 return 0;
452}
453
454static int btmrvl_flush(struct hci_dev *hdev)
455{
456 struct btmrvl_private *priv = hci_get_drvdata(hdev);
457
458 skb_queue_purge(&priv->adapter->tx_queue);
459
460 return 0;
461}
462
463static int btmrvl_close(struct hci_dev *hdev)
464{
465 struct btmrvl_private *priv = hci_get_drvdata(hdev);
466
467 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
468 return 0;
469
470 skb_queue_purge(&priv->adapter->tx_queue);
471
472 return 0;
473}
474
475static int btmrvl_open(struct hci_dev *hdev)
476{
477 set_bit(HCI_RUNNING, &hdev->flags);
478
479 return 0;
480}
481
482
483
484
485
486static int btmrvl_service_main_thread(void *data)
487{
488 struct btmrvl_thread *thread = data;
489 struct btmrvl_private *priv = thread->priv;
490 struct btmrvl_adapter *adapter = priv->adapter;
491 wait_queue_t wait;
492 struct sk_buff *skb;
493 ulong flags;
494
495 init_waitqueue_entry(&wait, current);
496
497 for (;;) {
498 add_wait_queue(&thread->wait_q, &wait);
499
500 set_current_state(TASK_INTERRUPTIBLE);
501 if (kthread_should_stop()) {
502 BT_DBG("main_thread: break from main thread");
503 break;
504 }
505
506 if (adapter->wakeup_tries ||
507 ((!adapter->int_count) &&
508 (!priv->btmrvl_dev.tx_dnld_rdy ||
509 skb_queue_empty(&adapter->tx_queue)))) {
510 BT_DBG("main_thread is sleeping...");
511 schedule();
512 }
513
514 set_current_state(TASK_RUNNING);
515
516 remove_wait_queue(&thread->wait_q, &wait);
517
518 BT_DBG("main_thread woke up");
519
520 spin_lock_irqsave(&priv->driver_lock, flags);
521 if (adapter->int_count) {
522 adapter->int_count = 0;
523 spin_unlock_irqrestore(&priv->driver_lock, flags);
524 priv->hw_process_int_status(priv);
525 } else if (adapter->ps_state == PS_SLEEP &&
526 !skb_queue_empty(&adapter->tx_queue)) {
527 spin_unlock_irqrestore(&priv->driver_lock, flags);
528 adapter->wakeup_tries++;
529 priv->hw_wakeup_firmware(priv);
530 continue;
531 } else {
532 spin_unlock_irqrestore(&priv->driver_lock, flags);
533 }
534
535 if (adapter->ps_state == PS_SLEEP)
536 continue;
537
538 if (!priv->btmrvl_dev.tx_dnld_rdy)
539 continue;
540
541 skb = skb_dequeue(&adapter->tx_queue);
542 if (skb) {
543 if (btmrvl_tx_pkt(priv, skb))
544 priv->btmrvl_dev.hcidev->stat.err_tx++;
545 else
546 priv->btmrvl_dev.hcidev->stat.byte_tx += skb->len;
547
548 kfree_skb(skb);
549 }
550 }
551
552 return 0;
553}
554
555int btmrvl_register_hdev(struct btmrvl_private *priv)
556{
557 struct hci_dev *hdev = NULL;
558 int ret;
559
560 hdev = hci_alloc_dev();
561 if (!hdev) {
562 BT_ERR("Can not allocate HCI device");
563 goto err_hdev;
564 }
565
566 priv->btmrvl_dev.hcidev = hdev;
567 hci_set_drvdata(hdev, priv);
568
569 hdev->bus = HCI_SDIO;
570 hdev->open = btmrvl_open;
571 hdev->close = btmrvl_close;
572 hdev->flush = btmrvl_flush;
573 hdev->send = btmrvl_send_frame;
574 hdev->ioctl = btmrvl_ioctl;
575
576 btmrvl_send_module_cfg_cmd(priv, MODULE_BRINGUP_REQ);
577
578 hdev->dev_type = priv->btmrvl_dev.dev_type;
579
580 ret = hci_register_dev(hdev);
581 if (ret < 0) {
582 BT_ERR("Can not register HCI device");
583 goto err_hci_register_dev;
584 }
585
586#ifdef CONFIG_DEBUG_FS
587 btmrvl_debugfs_init(hdev);
588#endif
589
590 return 0;
591
592err_hci_register_dev:
593 hci_free_dev(hdev);
594
595err_hdev:
596
597 kthread_stop(priv->main_thread.task);
598
599 btmrvl_free_adapter(priv);
600 kfree(priv);
601
602 return -ENOMEM;
603}
604EXPORT_SYMBOL_GPL(btmrvl_register_hdev);
605
606struct btmrvl_private *btmrvl_add_card(void *card)
607{
608 struct btmrvl_private *priv;
609
610 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
611 if (!priv) {
612 BT_ERR("Can not allocate priv");
613 goto err_priv;
614 }
615
616 priv->adapter = kzalloc(sizeof(*priv->adapter), GFP_KERNEL);
617 if (!priv->adapter) {
618 BT_ERR("Allocate buffer for btmrvl_adapter failed!");
619 goto err_adapter;
620 }
621
622 btmrvl_init_adapter(priv);
623
624 BT_DBG("Starting kthread...");
625 priv->main_thread.priv = priv;
626 spin_lock_init(&priv->driver_lock);
627
628 init_waitqueue_head(&priv->main_thread.wait_q);
629 priv->main_thread.task = kthread_run(btmrvl_service_main_thread,
630 &priv->main_thread, "btmrvl_main_service");
631
632 priv->btmrvl_dev.card = card;
633 priv->btmrvl_dev.tx_dnld_rdy = true;
634
635 return priv;
636
637err_adapter:
638 kfree(priv);
639
640err_priv:
641 return NULL;
642}
643EXPORT_SYMBOL_GPL(btmrvl_add_card);
644
645int btmrvl_remove_card(struct btmrvl_private *priv)
646{
647 struct hci_dev *hdev;
648
649 hdev = priv->btmrvl_dev.hcidev;
650
651 wake_up_interruptible(&priv->adapter->cmd_wait_q);
652
653 kthread_stop(priv->main_thread.task);
654
655#ifdef CONFIG_DEBUG_FS
656 btmrvl_debugfs_remove(hdev);
657#endif
658
659 hci_unregister_dev(hdev);
660
661 hci_free_dev(hdev);
662
663 priv->btmrvl_dev.hcidev = NULL;
664
665 btmrvl_free_adapter(priv);
666
667 kfree(priv);
668
669 return 0;
670}
671EXPORT_SYMBOL_GPL(btmrvl_remove_card);
672
673MODULE_AUTHOR("Marvell International Ltd.");
674MODULE_DESCRIPTION("Marvell Bluetooth driver ver " VERSION);
675MODULE_VERSION(VERSION);
676MODULE_LICENSE("GPL v2");
677
