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