drivers/bluetooth/btmrvl_main.c

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