1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Marvell Bluetooth driver
4 *
5 * Copyright (C) 2009, Marvell International Ltd.
6 **/
7
8 #include <linux/module.h>
9 #include <linux/of.h>
10 #include <linux/string_choices.h>
11 #include <net/bluetooth/bluetooth.h>
12 #include <net/bluetooth/hci_core.h>
13 #include <linux/mmc/sdio_func.h>
14
15 #include "btmrvl_drv.h"
16 #include "btmrvl_sdio.h"
17
18 #define VERSION "1.0"
19
20 /*
21 * This function is called by interface specific interrupt handler.
22 * It updates Power Save & Host Sleep states, and wakes up the main
23 * thread.
24 */
btmrvl_interrupt(struct btmrvl_private * priv)25 void btmrvl_interrupt(struct btmrvl_private *priv)
26 {
27 priv->adapter->ps_state = PS_AWAKE;
28
29 priv->adapter->wakeup_tries = 0;
30
31 priv->adapter->int_count++;
32
33 if (priv->adapter->hs_state == HS_ACTIVATED) {
34 BT_DBG("BT: HS DEACTIVATED in ISR!");
35 priv->adapter->hs_state = HS_DEACTIVATED;
36 }
37
38 wake_up_interruptible(&priv->main_thread.wait_q);
39 }
40 EXPORT_SYMBOL_GPL(btmrvl_interrupt);
41
btmrvl_check_evtpkt(struct btmrvl_private * priv,struct sk_buff * skb)42 bool btmrvl_check_evtpkt(struct btmrvl_private *priv, struct sk_buff *skb)
43 {
44 struct hci_event_hdr *hdr = (void *) skb->data;
45
46 if (skb->len < sizeof(*hdr))
47 return true;
48
49 if (hdr->evt == HCI_EV_CMD_COMPLETE) {
50 struct hci_ev_cmd_complete *ec;
51 u16 opcode;
52
53 if (hdr->plen < sizeof(*ec) ||
54 skb->len < HCI_EVENT_HDR_SIZE + sizeof(*ec))
55 return true;
56
57 ec = (void *) (skb->data + HCI_EVENT_HDR_SIZE);
58 opcode = __le16_to_cpu(ec->opcode);
59
60 if (priv->btmrvl_dev.sendcmdflag) {
61 priv->btmrvl_dev.sendcmdflag = false;
62 priv->adapter->cmd_complete = true;
63 wake_up_interruptible(&priv->adapter->cmd_wait_q);
64
65 if (hci_opcode_ogf(opcode) == 0x3F) {
66 BT_DBG("vendor event skipped: opcode=%#4.4x",
67 opcode);
68 kfree_skb(skb);
69 return false;
70 }
71 }
72 }
73
74 return true;
75 }
76 EXPORT_SYMBOL_GPL(btmrvl_check_evtpkt);
77
btmrvl_process_event(struct btmrvl_private * priv,struct sk_buff * skb)78 int btmrvl_process_event(struct btmrvl_private *priv, struct sk_buff *skb)
79 {
80 struct btmrvl_adapter *adapter = priv->adapter;
81 struct btmrvl_event *event;
82 int ret = 0;
83
84 if (skb->len <= offsetof(typeof(*event), data[0]))
85 return -EINVAL;
86
87 event = (struct btmrvl_event *) skb->data;
88 if (event->ec != 0xff) {
89 BT_DBG("Not Marvell Event=%x", event->ec);
90 ret = -EINVAL;
91 goto exit;
92 }
93
94 switch (event->data[0]) {
95 case BT_EVENT_AUTO_SLEEP_MODE:
96 if (skb->len <= offsetof(typeof(*event), data[2]))
97 return -EINVAL;
98 if (!event->data[2]) {
99 if (event->data[1] == BT_PS_ENABLE)
100 adapter->psmode = 1;
101 else
102 adapter->psmode = 0;
103 BT_DBG("PS Mode:%s",
104 str_enable_disable(adapter->psmode));
105 } else {
106 BT_DBG("PS Mode command failed");
107 }
108 break;
109
110 case BT_EVENT_HOST_SLEEP_CONFIG:
111 if (skb->len <= offsetof(typeof(*event), data[3]))
112 return -EINVAL;
113 if (!event->data[3])
114 BT_DBG("gpio=%x, gap=%x", event->data[1],
115 event->data[2]);
116 else
117 BT_DBG("HSCFG command failed");
118 break;
119
120 case BT_EVENT_HOST_SLEEP_ENABLE:
121 if (skb->len <= offsetof(typeof(*event), data[1]))
122 return -EINVAL;
123 if (!event->data[1]) {
124 adapter->hs_state = HS_ACTIVATED;
125 if (adapter->psmode)
126 adapter->ps_state = PS_SLEEP;
127 wake_up_interruptible(&adapter->event_hs_wait_q);
128 BT_DBG("HS ACTIVATED!");
129 } else {
130 BT_DBG("HS Enable failed");
131 }
132 break;
133
134 case BT_EVENT_MODULE_CFG_REQ:
135 if (skb->len <= offsetof(typeof(*event), data[2]))
136 return -EINVAL;
137 if (priv->btmrvl_dev.sendcmdflag &&
138 event->data[1] == MODULE_BRINGUP_REQ) {
139 BT_DBG("EVENT:%s",
140 ((event->data[2] == MODULE_BROUGHT_UP) ||
141 (event->data[2] == MODULE_ALREADY_UP)) ?
142 "Bring-up succeed" : "Bring-up failed");
143 } else if (priv->btmrvl_dev.sendcmdflag &&
144 event->data[1] == MODULE_SHUTDOWN_REQ) {
145 BT_DBG("EVENT:%s", (event->data[2]) ?
146 "Shutdown failed" : "Shutdown succeed");
147 } else {
148 BT_DBG("BT_CMD_MODULE_CFG_REQ resp for APP");
149 ret = -EINVAL;
150 }
151 break;
152
153 case BT_EVENT_POWER_STATE:
154 if (skb->len <= offsetof(typeof(*event), data[1]))
155 return -EINVAL;
156 if (event->data[1] == BT_PS_SLEEP)
157 adapter->ps_state = PS_SLEEP;
158 BT_DBG("EVENT:%s",
159 (adapter->ps_state) ? "PS_SLEEP" : "PS_AWAKE");
160 break;
161
162 default:
163 BT_DBG("Unknown Event=%d", event->data[0]);
164 ret = -EINVAL;
165 break;
166 }
167
168 exit:
169 if (!ret)
170 kfree_skb(skb);
171
172 return ret;
173 }
174 EXPORT_SYMBOL_GPL(btmrvl_process_event);
175
btmrvl_send_sync_cmd(struct btmrvl_private * priv,u16 opcode,const void * param,u8 len)176 static int btmrvl_send_sync_cmd(struct btmrvl_private *priv, u16 opcode,
177 const void *param, u8 len)
178 {
179 struct sk_buff *skb;
180 struct hci_command_hdr *hdr;
181
182 if (priv->surprise_removed) {
183 BT_ERR("Card is removed");
184 return -EFAULT;
185 }
186
187 skb = bt_skb_alloc(HCI_COMMAND_HDR_SIZE + len, GFP_KERNEL);
188 if (!skb) {
189 BT_ERR("No free skb");
190 return -ENOMEM;
191 }
192
193 hdr = skb_put(skb, HCI_COMMAND_HDR_SIZE);
194 hdr->opcode = cpu_to_le16(opcode);
195 hdr->plen = len;
196
197 if (len)
198 skb_put_data(skb, param, len);
199
200 hci_skb_pkt_type(skb) = MRVL_VENDOR_PKT;
201
202 skb_queue_head(&priv->adapter->tx_queue, skb);
203
204 priv->btmrvl_dev.sendcmdflag = true;
205
206 priv->adapter->cmd_complete = false;
207
208 wake_up_interruptible(&priv->main_thread.wait_q);
209
210 if (!wait_event_interruptible_timeout(priv->adapter->cmd_wait_q,
211 priv->adapter->cmd_complete ||
212 priv->surprise_removed,
213 WAIT_UNTIL_CMD_RESP))
214 return -ETIMEDOUT;
215
216 if (priv->surprise_removed)
217 return -EFAULT;
218
219 return 0;
220 }
221
btmrvl_send_module_cfg_cmd(struct btmrvl_private * priv,u8 subcmd)222 int btmrvl_send_module_cfg_cmd(struct btmrvl_private *priv, u8 subcmd)
223 {
224 int ret;
225
226 ret = btmrvl_send_sync_cmd(priv, BT_CMD_MODULE_CFG_REQ, &subcmd, 1);
227 if (ret)
228 BT_ERR("module_cfg_cmd(%x) failed", subcmd);
229
230 return ret;
231 }
232 EXPORT_SYMBOL_GPL(btmrvl_send_module_cfg_cmd);
233
btmrvl_enable_sco_routing_to_host(struct btmrvl_private * priv)234 static int btmrvl_enable_sco_routing_to_host(struct btmrvl_private *priv)
235 {
236 int ret;
237 u8 subcmd = 0;
238
239 ret = btmrvl_send_sync_cmd(priv, BT_CMD_ROUTE_SCO_TO_HOST, &subcmd, 1);
240 if (ret)
241 BT_ERR("BT_CMD_ROUTE_SCO_TO_HOST command failed: %#x", ret);
242
243 return ret;
244 }
245
btmrvl_pscan_window_reporting(struct btmrvl_private * priv,u8 subcmd)246 int btmrvl_pscan_window_reporting(struct btmrvl_private *priv, u8 subcmd)
247 {
248 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
249 int ret;
250
251 if (!card->support_pscan_win_report)
252 return 0;
253
254 ret = btmrvl_send_sync_cmd(priv, BT_CMD_PSCAN_WIN_REPORT_ENABLE,
255 &subcmd, 1);
256 if (ret)
257 BT_ERR("PSCAN_WIN_REPORT_ENABLE command failed: %#x", ret);
258
259 return ret;
260 }
261 EXPORT_SYMBOL_GPL(btmrvl_pscan_window_reporting);
262
btmrvl_send_hscfg_cmd(struct btmrvl_private * priv)263 int btmrvl_send_hscfg_cmd(struct btmrvl_private *priv)
264 {
265 int ret;
266 u8 param[2];
267
268 param[0] = (priv->btmrvl_dev.gpio_gap & 0xff00) >> 8;
269 param[1] = (u8) (priv->btmrvl_dev.gpio_gap & 0x00ff);
270
271 BT_DBG("Sending HSCFG Command, gpio=0x%x, gap=0x%x",
272 param[0], param[1]);
273
274 ret = btmrvl_send_sync_cmd(priv, BT_CMD_HOST_SLEEP_CONFIG, param, 2);
275 if (ret)
276 BT_ERR("HSCFG command failed");
277
278 return ret;
279 }
280 EXPORT_SYMBOL_GPL(btmrvl_send_hscfg_cmd);
281
btmrvl_enable_ps(struct btmrvl_private * priv)282 int btmrvl_enable_ps(struct btmrvl_private *priv)
283 {
284 int ret;
285 u8 param;
286
287 if (priv->btmrvl_dev.psmode)
288 param = BT_PS_ENABLE;
289 else
290 param = BT_PS_DISABLE;
291
292 ret = btmrvl_send_sync_cmd(priv, BT_CMD_AUTO_SLEEP_MODE, ¶m, 1);
293 if (ret)
294 BT_ERR("PSMODE command failed");
295
296 return 0;
297 }
298 EXPORT_SYMBOL_GPL(btmrvl_enable_ps);
299
btmrvl_enable_hs(struct btmrvl_private * priv)300 int btmrvl_enable_hs(struct btmrvl_private *priv)
301 {
302 struct btmrvl_adapter *adapter = priv->adapter;
303 int ret;
304
305 ret = btmrvl_send_sync_cmd(priv, BT_CMD_HOST_SLEEP_ENABLE, NULL, 0);
306 if (ret) {
307 BT_ERR("Host sleep enable command failed");
308 return ret;
309 }
310
311 ret = wait_event_interruptible_timeout(adapter->event_hs_wait_q,
312 adapter->hs_state ||
313 priv->surprise_removed,
314 WAIT_UNTIL_HS_STATE_CHANGED);
315 if (ret < 0 || priv->surprise_removed) {
316 BT_ERR("event_hs_wait_q terminated (%d): %d,%d,%d",
317 ret, adapter->hs_state, adapter->ps_state,
318 adapter->wakeup_tries);
319 } else if (!ret) {
320 BT_ERR("hs_enable timeout: %d,%d,%d", adapter->hs_state,
321 adapter->ps_state, adapter->wakeup_tries);
322 ret = -ETIMEDOUT;
323 } else {
324 BT_DBG("host sleep enabled: %d,%d,%d", adapter->hs_state,
325 adapter->ps_state, adapter->wakeup_tries);
326 ret = 0;
327 }
328
329 return ret;
330 }
331 EXPORT_SYMBOL_GPL(btmrvl_enable_hs);
332
btmrvl_prepare_command(struct btmrvl_private * priv)333 int btmrvl_prepare_command(struct btmrvl_private *priv)
334 {
335 int ret = 0;
336
337 if (priv->btmrvl_dev.hscfgcmd) {
338 priv->btmrvl_dev.hscfgcmd = 0;
339 btmrvl_send_hscfg_cmd(priv);
340 }
341
342 if (priv->btmrvl_dev.pscmd) {
343 priv->btmrvl_dev.pscmd = 0;
344 btmrvl_enable_ps(priv);
345 }
346
347 if (priv->btmrvl_dev.hscmd) {
348 priv->btmrvl_dev.hscmd = 0;
349
350 if (priv->btmrvl_dev.hsmode) {
351 ret = btmrvl_enable_hs(priv);
352 } else {
353 ret = priv->hw_wakeup_firmware(priv);
354 priv->adapter->hs_state = HS_DEACTIVATED;
355 BT_DBG("BT: HS DEACTIVATED due to host activity!");
356 }
357 }
358
359 return ret;
360 }
361
btmrvl_tx_pkt(struct btmrvl_private * priv,struct sk_buff * skb)362 static int btmrvl_tx_pkt(struct btmrvl_private *priv, struct sk_buff *skb)
363 {
364 int ret = 0;
365
366 if (!skb || !skb->data)
367 return -EINVAL;
368
369 if (!skb->len || ((skb->len + BTM_HEADER_LEN) > BTM_UPLD_SIZE)) {
370 BT_ERR("Tx Error: Bad skb length %d : %d",
371 skb->len, BTM_UPLD_SIZE);
372 return -EINVAL;
373 }
374
375 skb_push(skb, BTM_HEADER_LEN);
376
377 /* header type: byte[3]
378 * HCI_COMMAND = 1, ACL_DATA = 2, SCO_DATA = 3, 0xFE = Vendor
379 * header length: byte[2][1][0]
380 */
381
382 skb->data[0] = (skb->len & 0x0000ff);
383 skb->data[1] = (skb->len & 0x00ff00) >> 8;
384 skb->data[2] = (skb->len & 0xff0000) >> 16;
385 skb->data[3] = hci_skb_pkt_type(skb);
386
387 if (priv->hw_host_to_card)
388 ret = priv->hw_host_to_card(priv, skb->data, skb->len);
389
390 return ret;
391 }
392
btmrvl_init_adapter(struct btmrvl_private * priv)393 static void btmrvl_init_adapter(struct btmrvl_private *priv)
394 {
395 int buf_size;
396
397 skb_queue_head_init(&priv->adapter->tx_queue);
398
399 priv->adapter->ps_state = PS_AWAKE;
400
401 buf_size = ALIGN_SZ(SDIO_BLOCK_SIZE, BTSDIO_DMA_ALIGN);
402 priv->adapter->hw_regs_buf = kzalloc(buf_size, GFP_KERNEL);
403 if (!priv->adapter->hw_regs_buf) {
404 priv->adapter->hw_regs = NULL;
405 BT_ERR("Unable to allocate buffer for hw_regs.");
406 } else {
407 priv->adapter->hw_regs =
408 (u8 *)ALIGN_ADDR(priv->adapter->hw_regs_buf,
409 BTSDIO_DMA_ALIGN);
410 BT_DBG("hw_regs_buf=%p hw_regs=%p",
411 priv->adapter->hw_regs_buf, priv->adapter->hw_regs);
412 }
413
414 init_waitqueue_head(&priv->adapter->cmd_wait_q);
415 init_waitqueue_head(&priv->adapter->event_hs_wait_q);
416 }
417
btmrvl_free_adapter(struct btmrvl_private * priv)418 static void btmrvl_free_adapter(struct btmrvl_private *priv)
419 {
420 skb_queue_purge(&priv->adapter->tx_queue);
421
422 kfree(priv->adapter->hw_regs_buf);
423 kfree(priv->adapter);
424
425 priv->adapter = NULL;
426 }
427
btmrvl_send_frame(struct hci_dev * hdev,struct sk_buff * skb)428 static int btmrvl_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
429 {
430 struct btmrvl_private *priv = hci_get_drvdata(hdev);
431
432 BT_DBG("type=%d, len=%d", hci_skb_pkt_type(skb), skb->len);
433
434 if (priv->adapter->is_suspending || priv->adapter->is_suspended) {
435 BT_ERR("%s: Device is suspending or suspended", __func__);
436 return -EBUSY;
437 }
438
439 switch (hci_skb_pkt_type(skb)) {
440 case HCI_COMMAND_PKT:
441 hdev->stat.cmd_tx++;
442 break;
443
444 case HCI_ACLDATA_PKT:
445 hdev->stat.acl_tx++;
446 break;
447
448 case HCI_SCODATA_PKT:
449 hdev->stat.sco_tx++;
450 break;
451 }
452
453 skb_queue_tail(&priv->adapter->tx_queue, skb);
454
455 if (!priv->adapter->is_suspended)
456 wake_up_interruptible(&priv->main_thread.wait_q);
457
458 return 0;
459 }
460
btmrvl_flush(struct hci_dev * hdev)461 static int btmrvl_flush(struct hci_dev *hdev)
462 {
463 struct btmrvl_private *priv = hci_get_drvdata(hdev);
464
465 skb_queue_purge(&priv->adapter->tx_queue);
466
467 return 0;
468 }
469
btmrvl_close(struct hci_dev * hdev)470 static int btmrvl_close(struct hci_dev *hdev)
471 {
472 struct btmrvl_private *priv = hci_get_drvdata(hdev);
473
474 skb_queue_purge(&priv->adapter->tx_queue);
475
476 return 0;
477 }
478
btmrvl_open(struct hci_dev * hdev)479 static int btmrvl_open(struct hci_dev *hdev)
480 {
481 return 0;
482 }
483
btmrvl_download_cal_data(struct btmrvl_private * priv,u8 * data,int len)484 static int btmrvl_download_cal_data(struct btmrvl_private *priv,
485 u8 *data, int len)
486 {
487 int ret;
488
489 data[0] = 0x00;
490 data[1] = 0x00;
491 data[2] = 0x00;
492 data[3] = len;
493
494 print_hex_dump_bytes("Calibration data: ",
495 DUMP_PREFIX_OFFSET, data, BT_CAL_HDR_LEN + len);
496
497 ret = btmrvl_send_sync_cmd(priv, BT_CMD_LOAD_CONFIG_DATA, data,
498 BT_CAL_HDR_LEN + len);
499 if (ret)
500 BT_ERR("Failed to download calibration data");
501
502 return 0;
503 }
504
btmrvl_check_device_tree(struct btmrvl_private * priv)505 static int btmrvl_check_device_tree(struct btmrvl_private *priv)
506 {
507 struct device_node *dt_node;
508 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
509 u8 cal_data[BT_CAL_HDR_LEN + BT_CAL_DATA_SIZE];
510 int ret = 0;
511 u16 gpio, gap;
512
513 if (card->plt_of_node) {
514 dt_node = card->plt_of_node;
515 ret = of_property_read_u16(dt_node, "marvell,wakeup-pin",
516 &gpio);
517 if (ret)
518 gpio = (priv->btmrvl_dev.gpio_gap & 0xff00) >> 8;
519
520 ret = of_property_read_u16(dt_node, "marvell,wakeup-gap-ms",
521 &gap);
522 if (ret)
523 gap = (u8)(priv->btmrvl_dev.gpio_gap & 0x00ff);
524
525 priv->btmrvl_dev.gpio_gap = (gpio << 8) + gap;
526
527 ret = of_property_read_u8_array(dt_node, "marvell,cal-data",
528 cal_data + BT_CAL_HDR_LEN,
529 BT_CAL_DATA_SIZE);
530 if (ret)
531 return ret;
532
533 BT_DBG("Use cal data from device tree");
534 ret = btmrvl_download_cal_data(priv, cal_data,
535 BT_CAL_DATA_SIZE);
536 if (ret)
537 BT_ERR("Fail to download calibrate data");
538 }
539
540 return ret;
541 }
542
btmrvl_setup(struct hci_dev * hdev)543 static int btmrvl_setup(struct hci_dev *hdev)
544 {
545 struct btmrvl_private *priv = hci_get_drvdata(hdev);
546 int ret;
547
548 ret = btmrvl_send_module_cfg_cmd(priv, MODULE_BRINGUP_REQ);
549 if (ret)
550 return ret;
551
552 priv->btmrvl_dev.gpio_gap = 0xfffe;
553
554 btmrvl_check_device_tree(priv);
555
556 btmrvl_enable_sco_routing_to_host(priv);
557
558 btmrvl_pscan_window_reporting(priv, 0x01);
559
560 priv->btmrvl_dev.psmode = 1;
561 btmrvl_enable_ps(priv);
562
563 btmrvl_send_hscfg_cmd(priv);
564
565 return 0;
566 }
567
btmrvl_set_bdaddr(struct hci_dev * hdev,const bdaddr_t * bdaddr)568 static int btmrvl_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
569 {
570 struct sk_buff *skb;
571 long ret;
572 u8 buf[8];
573
574 buf[0] = MRVL_VENDOR_PKT;
575 buf[1] = sizeof(bdaddr_t);
576 memcpy(buf + 2, bdaddr, sizeof(bdaddr_t));
577
578 skb = __hci_cmd_sync(hdev, BT_CMD_SET_BDADDR, sizeof(buf), buf,
579 HCI_INIT_TIMEOUT);
580 if (IS_ERR(skb)) {
581 ret = PTR_ERR(skb);
582 BT_ERR("%s: changing btmrvl device address failed (%ld)",
583 hdev->name, ret);
584 return ret;
585 }
586 kfree_skb(skb);
587
588 return 0;
589 }
590
btmrvl_wakeup(struct hci_dev * hdev)591 static bool btmrvl_wakeup(struct hci_dev *hdev)
592 {
593 struct btmrvl_private *priv = hci_get_drvdata(hdev);
594 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
595
596 return device_may_wakeup(&card->func->dev);
597 }
598
599 /*
600 * This function handles the event generated by firmware, rx data
601 * received from firmware, and tx data sent from kernel.
602 */
btmrvl_service_main_thread(void * data)603 static int btmrvl_service_main_thread(void *data)
604 {
605 struct btmrvl_thread *thread = data;
606 struct btmrvl_private *priv = thread->priv;
607 struct btmrvl_adapter *adapter = priv->adapter;
608 wait_queue_entry_t wait;
609 struct sk_buff *skb;
610 ulong flags;
611
612 init_waitqueue_entry(&wait, current);
613
614 for (;;) {
615 add_wait_queue(&thread->wait_q, &wait);
616
617 set_current_state(TASK_INTERRUPTIBLE);
618 if (kthread_should_stop() || priv->surprise_removed) {
619 BT_DBG("main_thread: break from main thread");
620 break;
621 }
622
623 if (adapter->wakeup_tries ||
624 ((!adapter->int_count) &&
625 (!priv->btmrvl_dev.tx_dnld_rdy ||
626 skb_queue_empty(&adapter->tx_queue)))) {
627 BT_DBG("main_thread is sleeping...");
628 schedule();
629 }
630
631 set_current_state(TASK_RUNNING);
632
633 remove_wait_queue(&thread->wait_q, &wait);
634
635 BT_DBG("main_thread woke up");
636
637 if (kthread_should_stop() || priv->surprise_removed) {
638 BT_DBG("main_thread: break from main thread");
639 break;
640 }
641
642 spin_lock_irqsave(&priv->driver_lock, flags);
643 if (adapter->int_count) {
644 adapter->int_count = 0;
645 spin_unlock_irqrestore(&priv->driver_lock, flags);
646 priv->hw_process_int_status(priv);
647 } else if (adapter->ps_state == PS_SLEEP &&
648 !skb_queue_empty(&adapter->tx_queue)) {
649 spin_unlock_irqrestore(&priv->driver_lock, flags);
650 adapter->wakeup_tries++;
651 priv->hw_wakeup_firmware(priv);
652 continue;
653 } else {
654 spin_unlock_irqrestore(&priv->driver_lock, flags);
655 }
656
657 if (adapter->ps_state == PS_SLEEP)
658 continue;
659
660 if (!priv->btmrvl_dev.tx_dnld_rdy ||
661 priv->adapter->is_suspended)
662 continue;
663
664 skb = skb_dequeue(&adapter->tx_queue);
665 if (skb) {
666 if (btmrvl_tx_pkt(priv, skb))
667 priv->btmrvl_dev.hcidev->stat.err_tx++;
668 else
669 priv->btmrvl_dev.hcidev->stat.byte_tx += skb->len;
670
671 kfree_skb(skb);
672 }
673 }
674
675 return 0;
676 }
677
btmrvl_register_hdev(struct btmrvl_private * priv)678 int btmrvl_register_hdev(struct btmrvl_private *priv)
679 {
680 struct hci_dev *hdev = NULL;
681 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
682 int ret;
683
684 hdev = hci_alloc_dev();
685 if (!hdev) {
686 BT_ERR("Can not allocate HCI device");
687 goto err_hdev;
688 }
689
690 priv->btmrvl_dev.hcidev = hdev;
691 hci_set_drvdata(hdev, priv);
692
693 hdev->bus = HCI_SDIO;
694 hdev->open = btmrvl_open;
695 hdev->close = btmrvl_close;
696 hdev->flush = btmrvl_flush;
697 hdev->send = btmrvl_send_frame;
698 hdev->setup = btmrvl_setup;
699 hdev->set_bdaddr = btmrvl_set_bdaddr;
700 hdev->wakeup = btmrvl_wakeup;
701 SET_HCIDEV_DEV(hdev, &card->func->dev);
702
703 ret = hci_register_dev(hdev);
704 if (ret < 0) {
705 BT_ERR("Can not register HCI device");
706 goto err_hci_register_dev;
707 }
708
709 #ifdef CONFIG_DEBUG_FS
710 btmrvl_debugfs_init(hdev);
711 #endif
712
713 return 0;
714
715 err_hci_register_dev:
716 hci_free_dev(hdev);
717
718 err_hdev:
719 /* Stop the thread servicing the interrupts */
720 kthread_stop(priv->main_thread.task);
721
722 btmrvl_free_adapter(priv);
723 kfree(priv);
724
725 return -ENOMEM;
726 }
727 EXPORT_SYMBOL_GPL(btmrvl_register_hdev);
728
btmrvl_add_card(void * card)729 struct btmrvl_private *btmrvl_add_card(void *card)
730 {
731 struct btmrvl_private *priv;
732
733 priv = kzalloc_obj(*priv);
734 if (!priv) {
735 BT_ERR("Can not allocate priv");
736 goto err_priv;
737 }
738
739 priv->adapter = kzalloc_obj(*priv->adapter);
740 if (!priv->adapter) {
741 BT_ERR("Allocate buffer for btmrvl_adapter failed!");
742 goto err_adapter;
743 }
744
745 btmrvl_init_adapter(priv);
746
747 BT_DBG("Starting kthread...");
748 priv->main_thread.priv = priv;
749 spin_lock_init(&priv->driver_lock);
750
751 init_waitqueue_head(&priv->main_thread.wait_q);
752 priv->main_thread.task = kthread_run(btmrvl_service_main_thread,
753 &priv->main_thread, "btmrvl_main_service");
754 if (IS_ERR(priv->main_thread.task))
755 goto err_thread;
756
757 priv->btmrvl_dev.card = card;
758 priv->btmrvl_dev.tx_dnld_rdy = true;
759
760 return priv;
761
762 err_thread:
763 btmrvl_free_adapter(priv);
764
765 err_adapter:
766 kfree(priv);
767
768 err_priv:
769 return NULL;
770 }
771 EXPORT_SYMBOL_GPL(btmrvl_add_card);
772
btmrvl_remove_card(struct btmrvl_private * priv)773 int btmrvl_remove_card(struct btmrvl_private *priv)
774 {
775 struct hci_dev *hdev;
776
777 hdev = priv->btmrvl_dev.hcidev;
778
779 wake_up_interruptible(&priv->adapter->cmd_wait_q);
780 wake_up_interruptible(&priv->adapter->event_hs_wait_q);
781
782 kthread_stop(priv->main_thread.task);
783
784 #ifdef CONFIG_DEBUG_FS
785 btmrvl_debugfs_remove(hdev);
786 #endif
787
788 hci_unregister_dev(hdev);
789
790 hci_free_dev(hdev);
791
792 priv->btmrvl_dev.hcidev = NULL;
793
794 btmrvl_free_adapter(priv);
795
796 kfree(priv);
797
798 return 0;
799 }
800 EXPORT_SYMBOL_GPL(btmrvl_remove_card);
801
802 MODULE_AUTHOR("Marvell International Ltd.");
803 MODULE_DESCRIPTION("Marvell Bluetooth driver ver " VERSION);
804 MODULE_VERSION(VERSION);
805 MODULE_LICENSE("GPL v2");
806