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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 479 static int btmrvl_open(struct hci_dev *hdev) 480 { 481 return 0; 482 } 483 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 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 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 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 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 */ 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 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 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 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