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