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