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