Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Marvell Bluetooth driver
0004  *
0005  * Copyright (C) 2009, Marvell International Ltd.
0006  **/
0007 
0008 #include <linux/module.h>
0009 #include <linux/of.h>
0010 #include <net/bluetooth/bluetooth.h>
0011 #include <net/bluetooth/hci_core.h>
0012 #include <linux/mmc/sdio_func.h>
0013 
0014 #include "btmrvl_drv.h"
0015 #include "btmrvl_sdio.h"
0016 
0017 #define VERSION "1.0"
0018 
0019 /*
0020  * This function is called by interface specific interrupt handler.
0021  * It updates Power Save & Host Sleep states, and wakes up the main
0022  * thread.
0023  */
0024 void btmrvl_interrupt(struct btmrvl_private *priv)
0025 {
0026     priv->adapter->ps_state = PS_AWAKE;
0027 
0028     priv->adapter->wakeup_tries = 0;
0029 
0030     priv->adapter->int_count++;
0031 
0032     if (priv->adapter->hs_state == HS_ACTIVATED) {
0033         BT_DBG("BT: HS DEACTIVATED in ISR!");
0034         priv->adapter->hs_state = HS_DEACTIVATED;
0035     }
0036 
0037     wake_up_interruptible(&priv->main_thread.wait_q);
0038 }
0039 EXPORT_SYMBOL_GPL(btmrvl_interrupt);
0040 
0041 bool btmrvl_check_evtpkt(struct btmrvl_private *priv, struct sk_buff *skb)
0042 {
0043     struct hci_event_hdr *hdr = (void *) skb->data;
0044 
0045     if (hdr->evt == HCI_EV_CMD_COMPLETE) {
0046         struct hci_ev_cmd_complete *ec;
0047         u16 opcode;
0048 
0049         ec = (void *) (skb->data + HCI_EVENT_HDR_SIZE);
0050         opcode = __le16_to_cpu(ec->opcode);
0051 
0052         if (priv->btmrvl_dev.sendcmdflag) {
0053             priv->btmrvl_dev.sendcmdflag = false;
0054             priv->adapter->cmd_complete = true;
0055             wake_up_interruptible(&priv->adapter->cmd_wait_q);
0056 
0057             if (hci_opcode_ogf(opcode) == 0x3F) {
0058                 BT_DBG("vendor event skipped: opcode=%#4.4x",
0059                        opcode);
0060                 kfree_skb(skb);
0061                 return false;
0062             }
0063         }
0064     }
0065 
0066     return true;
0067 }
0068 EXPORT_SYMBOL_GPL(btmrvl_check_evtpkt);
0069 
0070 int btmrvl_process_event(struct btmrvl_private *priv, struct sk_buff *skb)
0071 {
0072     struct btmrvl_adapter *adapter = priv->adapter;
0073     struct btmrvl_event *event;
0074     int ret = 0;
0075 
0076     event = (struct btmrvl_event *) skb->data;
0077     if (event->ec != 0xff) {
0078         BT_DBG("Not Marvell Event=%x", event->ec);
0079         ret = -EINVAL;
0080         goto exit;
0081     }
0082 
0083     switch (event->data[0]) {
0084     case BT_EVENT_AUTO_SLEEP_MODE:
0085         if (!event->data[2]) {
0086             if (event->data[1] == BT_PS_ENABLE)
0087                 adapter->psmode = 1;
0088             else
0089                 adapter->psmode = 0;
0090             BT_DBG("PS Mode:%s",
0091                 (adapter->psmode) ? "Enable" : "Disable");
0092         } else {
0093             BT_DBG("PS Mode command failed");
0094         }
0095         break;
0096 
0097     case BT_EVENT_HOST_SLEEP_CONFIG:
0098         if (!event->data[3])
0099             BT_DBG("gpio=%x, gap=%x", event->data[1],
0100                             event->data[2]);
0101         else
0102             BT_DBG("HSCFG command failed");
0103         break;
0104 
0105     case BT_EVENT_HOST_SLEEP_ENABLE:
0106         if (!event->data[1]) {
0107             adapter->hs_state = HS_ACTIVATED;
0108             if (adapter->psmode)
0109                 adapter->ps_state = PS_SLEEP;
0110             wake_up_interruptible(&adapter->event_hs_wait_q);
0111             BT_DBG("HS ACTIVATED!");
0112         } else {
0113             BT_DBG("HS Enable failed");
0114         }
0115         break;
0116 
0117     case BT_EVENT_MODULE_CFG_REQ:
0118         if (priv->btmrvl_dev.sendcmdflag &&
0119                 event->data[1] == MODULE_BRINGUP_REQ) {
0120             BT_DBG("EVENT:%s",
0121                 ((event->data[2] == MODULE_BROUGHT_UP) ||
0122                 (event->data[2] == MODULE_ALREADY_UP)) ?
0123                 "Bring-up succeed" : "Bring-up failed");
0124 
0125             if (event->length > 3 && event->data[3])
0126                 priv->btmrvl_dev.dev_type = HCI_AMP;
0127             else
0128                 priv->btmrvl_dev.dev_type = HCI_PRIMARY;
0129 
0130             BT_DBG("dev_type: %d", priv->btmrvl_dev.dev_type);
0131         } else if (priv->btmrvl_dev.sendcmdflag &&
0132                 event->data[1] == MODULE_SHUTDOWN_REQ) {
0133             BT_DBG("EVENT:%s", (event->data[2]) ?
0134                 "Shutdown failed" : "Shutdown succeed");
0135         } else {
0136             BT_DBG("BT_CMD_MODULE_CFG_REQ resp for APP");
0137             ret = -EINVAL;
0138         }
0139         break;
0140 
0141     case BT_EVENT_POWER_STATE:
0142         if (event->data[1] == BT_PS_SLEEP)
0143             adapter->ps_state = PS_SLEEP;
0144         BT_DBG("EVENT:%s",
0145             (adapter->ps_state) ? "PS_SLEEP" : "PS_AWAKE");
0146         break;
0147 
0148     default:
0149         BT_DBG("Unknown Event=%d", event->data[0]);
0150         ret = -EINVAL;
0151         break;
0152     }
0153 
0154 exit:
0155     if (!ret)
0156         kfree_skb(skb);
0157 
0158     return ret;
0159 }
0160 EXPORT_SYMBOL_GPL(btmrvl_process_event);
0161 
0162 static int btmrvl_send_sync_cmd(struct btmrvl_private *priv, u16 opcode,
0163                 const void *param, u8 len)
0164 {
0165     struct sk_buff *skb;
0166     struct hci_command_hdr *hdr;
0167 
0168     if (priv->surprise_removed) {
0169         BT_ERR("Card is removed");
0170         return -EFAULT;
0171     }
0172 
0173     skb = bt_skb_alloc(HCI_COMMAND_HDR_SIZE + len, GFP_KERNEL);
0174     if (!skb) {
0175         BT_ERR("No free skb");
0176         return -ENOMEM;
0177     }
0178 
0179     hdr = skb_put(skb, HCI_COMMAND_HDR_SIZE);
0180     hdr->opcode = cpu_to_le16(opcode);
0181     hdr->plen = len;
0182 
0183     if (len)
0184         skb_put_data(skb, param, len);
0185 
0186     hci_skb_pkt_type(skb) = MRVL_VENDOR_PKT;
0187 
0188     skb_queue_head(&priv->adapter->tx_queue, skb);
0189 
0190     priv->btmrvl_dev.sendcmdflag = true;
0191 
0192     priv->adapter->cmd_complete = false;
0193 
0194     wake_up_interruptible(&priv->main_thread.wait_q);
0195 
0196     if (!wait_event_interruptible_timeout(priv->adapter->cmd_wait_q,
0197                           priv->adapter->cmd_complete ||
0198                           priv->surprise_removed,
0199                           WAIT_UNTIL_CMD_RESP))
0200         return -ETIMEDOUT;
0201 
0202     if (priv->surprise_removed)
0203         return -EFAULT;
0204 
0205     return 0;
0206 }
0207 
0208 int btmrvl_send_module_cfg_cmd(struct btmrvl_private *priv, u8 subcmd)
0209 {
0210     int ret;
0211 
0212     ret = btmrvl_send_sync_cmd(priv, BT_CMD_MODULE_CFG_REQ, &subcmd, 1);
0213     if (ret)
0214         BT_ERR("module_cfg_cmd(%x) failed", subcmd);
0215 
0216     return ret;
0217 }
0218 EXPORT_SYMBOL_GPL(btmrvl_send_module_cfg_cmd);
0219 
0220 static int btmrvl_enable_sco_routing_to_host(struct btmrvl_private *priv)
0221 {
0222     int ret;
0223     u8 subcmd = 0;
0224 
0225     ret = btmrvl_send_sync_cmd(priv, BT_CMD_ROUTE_SCO_TO_HOST, &subcmd, 1);
0226     if (ret)
0227         BT_ERR("BT_CMD_ROUTE_SCO_TO_HOST command failed: %#x", ret);
0228 
0229     return ret;
0230 }
0231 
0232 int btmrvl_pscan_window_reporting(struct btmrvl_private *priv, u8 subcmd)
0233 {
0234     struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
0235     int ret;
0236 
0237     if (!card->support_pscan_win_report)
0238         return 0;
0239 
0240     ret = btmrvl_send_sync_cmd(priv, BT_CMD_PSCAN_WIN_REPORT_ENABLE,
0241                    &subcmd, 1);
0242     if (ret)
0243         BT_ERR("PSCAN_WIN_REPORT_ENABLE command failed: %#x", ret);
0244 
0245     return ret;
0246 }
0247 EXPORT_SYMBOL_GPL(btmrvl_pscan_window_reporting);
0248 
0249 int btmrvl_send_hscfg_cmd(struct btmrvl_private *priv)
0250 {
0251     int ret;
0252     u8 param[2];
0253 
0254     param[0] = (priv->btmrvl_dev.gpio_gap & 0xff00) >> 8;
0255     param[1] = (u8) (priv->btmrvl_dev.gpio_gap & 0x00ff);
0256 
0257     BT_DBG("Sending HSCFG Command, gpio=0x%x, gap=0x%x",
0258            param[0], param[1]);
0259 
0260     ret = btmrvl_send_sync_cmd(priv, BT_CMD_HOST_SLEEP_CONFIG, param, 2);
0261     if (ret)
0262         BT_ERR("HSCFG command failed");
0263 
0264     return ret;
0265 }
0266 EXPORT_SYMBOL_GPL(btmrvl_send_hscfg_cmd);
0267 
0268 int btmrvl_enable_ps(struct btmrvl_private *priv)
0269 {
0270     int ret;
0271     u8 param;
0272 
0273     if (priv->btmrvl_dev.psmode)
0274         param = BT_PS_ENABLE;
0275     else
0276         param = BT_PS_DISABLE;
0277 
0278     ret = btmrvl_send_sync_cmd(priv, BT_CMD_AUTO_SLEEP_MODE, &param, 1);
0279     if (ret)
0280         BT_ERR("PSMODE command failed");
0281 
0282     return 0;
0283 }
0284 EXPORT_SYMBOL_GPL(btmrvl_enable_ps);
0285 
0286 int btmrvl_enable_hs(struct btmrvl_private *priv)
0287 {
0288     struct btmrvl_adapter *adapter = priv->adapter;
0289     int ret;
0290 
0291     ret = btmrvl_send_sync_cmd(priv, BT_CMD_HOST_SLEEP_ENABLE, NULL, 0);
0292     if (ret) {
0293         BT_ERR("Host sleep enable command failed");
0294         return ret;
0295     }
0296 
0297     ret = wait_event_interruptible_timeout(adapter->event_hs_wait_q,
0298                            adapter->hs_state ||
0299                            priv->surprise_removed,
0300                            WAIT_UNTIL_HS_STATE_CHANGED);
0301     if (ret < 0 || priv->surprise_removed) {
0302         BT_ERR("event_hs_wait_q terminated (%d): %d,%d,%d",
0303                ret, adapter->hs_state, adapter->ps_state,
0304                adapter->wakeup_tries);
0305     } else if (!ret) {
0306         BT_ERR("hs_enable timeout: %d,%d,%d", adapter->hs_state,
0307                adapter->ps_state, adapter->wakeup_tries);
0308         ret = -ETIMEDOUT;
0309     } else {
0310         BT_DBG("host sleep enabled: %d,%d,%d", adapter->hs_state,
0311                adapter->ps_state, adapter->wakeup_tries);
0312         ret = 0;
0313     }
0314 
0315     return ret;
0316 }
0317 EXPORT_SYMBOL_GPL(btmrvl_enable_hs);
0318 
0319 int btmrvl_prepare_command(struct btmrvl_private *priv)
0320 {
0321     int ret = 0;
0322 
0323     if (priv->btmrvl_dev.hscfgcmd) {
0324         priv->btmrvl_dev.hscfgcmd = 0;
0325         btmrvl_send_hscfg_cmd(priv);
0326     }
0327 
0328     if (priv->btmrvl_dev.pscmd) {
0329         priv->btmrvl_dev.pscmd = 0;
0330         btmrvl_enable_ps(priv);
0331     }
0332 
0333     if (priv->btmrvl_dev.hscmd) {
0334         priv->btmrvl_dev.hscmd = 0;
0335 
0336         if (priv->btmrvl_dev.hsmode) {
0337             ret = btmrvl_enable_hs(priv);
0338         } else {
0339             ret = priv->hw_wakeup_firmware(priv);
0340             priv->adapter->hs_state = HS_DEACTIVATED;
0341             BT_DBG("BT: HS DEACTIVATED due to host activity!");
0342         }
0343     }
0344 
0345     return ret;
0346 }
0347 
0348 static int btmrvl_tx_pkt(struct btmrvl_private *priv, struct sk_buff *skb)
0349 {
0350     int ret = 0;
0351 
0352     if (!skb || !skb->data)
0353         return -EINVAL;
0354 
0355     if (!skb->len || ((skb->len + BTM_HEADER_LEN) > BTM_UPLD_SIZE)) {
0356         BT_ERR("Tx Error: Bad skb length %d : %d",
0357                         skb->len, BTM_UPLD_SIZE);
0358         return -EINVAL;
0359     }
0360 
0361     skb_push(skb, BTM_HEADER_LEN);
0362 
0363     /* header type: byte[3]
0364      * HCI_COMMAND = 1, ACL_DATA = 2, SCO_DATA = 3, 0xFE = Vendor
0365      * header length: byte[2][1][0]
0366      */
0367 
0368     skb->data[0] = (skb->len & 0x0000ff);
0369     skb->data[1] = (skb->len & 0x00ff00) >> 8;
0370     skb->data[2] = (skb->len & 0xff0000) >> 16;
0371     skb->data[3] = hci_skb_pkt_type(skb);
0372 
0373     if (priv->hw_host_to_card)
0374         ret = priv->hw_host_to_card(priv, skb->data, skb->len);
0375 
0376     return ret;
0377 }
0378 
0379 static void btmrvl_init_adapter(struct btmrvl_private *priv)
0380 {
0381     int buf_size;
0382 
0383     skb_queue_head_init(&priv->adapter->tx_queue);
0384 
0385     priv->adapter->ps_state = PS_AWAKE;
0386 
0387     buf_size = ALIGN_SZ(SDIO_BLOCK_SIZE, BTSDIO_DMA_ALIGN);
0388     priv->adapter->hw_regs_buf = kzalloc(buf_size, GFP_KERNEL);
0389     if (!priv->adapter->hw_regs_buf) {
0390         priv->adapter->hw_regs = NULL;
0391         BT_ERR("Unable to allocate buffer for hw_regs.");
0392     } else {
0393         priv->adapter->hw_regs =
0394             (u8 *)ALIGN_ADDR(priv->adapter->hw_regs_buf,
0395                      BTSDIO_DMA_ALIGN);
0396         BT_DBG("hw_regs_buf=%p hw_regs=%p",
0397                priv->adapter->hw_regs_buf, priv->adapter->hw_regs);
0398     }
0399 
0400     init_waitqueue_head(&priv->adapter->cmd_wait_q);
0401     init_waitqueue_head(&priv->adapter->event_hs_wait_q);
0402 }
0403 
0404 static void btmrvl_free_adapter(struct btmrvl_private *priv)
0405 {
0406     skb_queue_purge(&priv->adapter->tx_queue);
0407 
0408     kfree(priv->adapter->hw_regs_buf);
0409     kfree(priv->adapter);
0410 
0411     priv->adapter = NULL;
0412 }
0413 
0414 static int btmrvl_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
0415 {
0416     struct btmrvl_private *priv = hci_get_drvdata(hdev);
0417 
0418     BT_DBG("type=%d, len=%d", hci_skb_pkt_type(skb), skb->len);
0419 
0420     if (priv->adapter->is_suspending || priv->adapter->is_suspended) {
0421         BT_ERR("%s: Device is suspending or suspended", __func__);
0422         return -EBUSY;
0423     }
0424 
0425     switch (hci_skb_pkt_type(skb)) {
0426     case HCI_COMMAND_PKT:
0427         hdev->stat.cmd_tx++;
0428         break;
0429 
0430     case HCI_ACLDATA_PKT:
0431         hdev->stat.acl_tx++;
0432         break;
0433 
0434     case HCI_SCODATA_PKT:
0435         hdev->stat.sco_tx++;
0436         break;
0437     }
0438 
0439     skb_queue_tail(&priv->adapter->tx_queue, skb);
0440 
0441     if (!priv->adapter->is_suspended)
0442         wake_up_interruptible(&priv->main_thread.wait_q);
0443 
0444     return 0;
0445 }
0446 
0447 static int btmrvl_flush(struct hci_dev *hdev)
0448 {
0449     struct btmrvl_private *priv = hci_get_drvdata(hdev);
0450 
0451     skb_queue_purge(&priv->adapter->tx_queue);
0452 
0453     return 0;
0454 }
0455 
0456 static int btmrvl_close(struct hci_dev *hdev)
0457 {
0458     struct btmrvl_private *priv = hci_get_drvdata(hdev);
0459 
0460     skb_queue_purge(&priv->adapter->tx_queue);
0461 
0462     return 0;
0463 }
0464 
0465 static int btmrvl_open(struct hci_dev *hdev)
0466 {
0467     return 0;
0468 }
0469 
0470 static int btmrvl_download_cal_data(struct btmrvl_private *priv,
0471                     u8 *data, int len)
0472 {
0473     int ret;
0474 
0475     data[0] = 0x00;
0476     data[1] = 0x00;
0477     data[2] = 0x00;
0478     data[3] = len;
0479 
0480     print_hex_dump_bytes("Calibration data: ",
0481                  DUMP_PREFIX_OFFSET, data, BT_CAL_HDR_LEN + len);
0482 
0483     ret = btmrvl_send_sync_cmd(priv, BT_CMD_LOAD_CONFIG_DATA, data,
0484                    BT_CAL_HDR_LEN + len);
0485     if (ret)
0486         BT_ERR("Failed to download calibration data");
0487 
0488     return 0;
0489 }
0490 
0491 static int btmrvl_check_device_tree(struct btmrvl_private *priv)
0492 {
0493     struct device_node *dt_node;
0494     struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
0495     u8 cal_data[BT_CAL_HDR_LEN + BT_CAL_DATA_SIZE];
0496     int ret = 0;
0497     u16 gpio, gap;
0498 
0499     if (card->plt_of_node) {
0500         dt_node = card->plt_of_node;
0501         ret = of_property_read_u16(dt_node, "marvell,wakeup-pin",
0502                        &gpio);
0503         if (ret)
0504             gpio = (priv->btmrvl_dev.gpio_gap & 0xff00) >> 8;
0505 
0506         ret = of_property_read_u16(dt_node, "marvell,wakeup-gap-ms",
0507                        &gap);
0508         if (ret)
0509             gap = (u8)(priv->btmrvl_dev.gpio_gap & 0x00ff);
0510 
0511         priv->btmrvl_dev.gpio_gap = (gpio << 8) + gap;
0512 
0513         ret = of_property_read_u8_array(dt_node, "marvell,cal-data",
0514                         cal_data + BT_CAL_HDR_LEN,
0515                         BT_CAL_DATA_SIZE);
0516         if (ret)
0517             return ret;
0518 
0519         BT_DBG("Use cal data from device tree");
0520         ret = btmrvl_download_cal_data(priv, cal_data,
0521                            BT_CAL_DATA_SIZE);
0522         if (ret)
0523             BT_ERR("Fail to download calibrate data");
0524     }
0525 
0526     return ret;
0527 }
0528 
0529 static int btmrvl_setup(struct hci_dev *hdev)
0530 {
0531     struct btmrvl_private *priv = hci_get_drvdata(hdev);
0532     int ret;
0533 
0534     ret = btmrvl_send_module_cfg_cmd(priv, MODULE_BRINGUP_REQ);
0535     if (ret)
0536         return ret;
0537 
0538     priv->btmrvl_dev.gpio_gap = 0xfffe;
0539 
0540     btmrvl_check_device_tree(priv);
0541 
0542     btmrvl_enable_sco_routing_to_host(priv);
0543 
0544     btmrvl_pscan_window_reporting(priv, 0x01);
0545 
0546     priv->btmrvl_dev.psmode = 1;
0547     btmrvl_enable_ps(priv);
0548 
0549     btmrvl_send_hscfg_cmd(priv);
0550 
0551     return 0;
0552 }
0553 
0554 static int btmrvl_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
0555 {
0556     struct sk_buff *skb;
0557     long ret;
0558     u8 buf[8];
0559 
0560     buf[0] = MRVL_VENDOR_PKT;
0561     buf[1] = sizeof(bdaddr_t);
0562     memcpy(buf + 2, bdaddr, sizeof(bdaddr_t));
0563 
0564     skb = __hci_cmd_sync(hdev, BT_CMD_SET_BDADDR, sizeof(buf), buf,
0565                  HCI_INIT_TIMEOUT);
0566     if (IS_ERR(skb)) {
0567         ret = PTR_ERR(skb);
0568         BT_ERR("%s: changing btmrvl device address failed (%ld)",
0569                hdev->name, ret);
0570         return ret;
0571     }
0572     kfree_skb(skb);
0573 
0574     return 0;
0575 }
0576 
0577 static bool btmrvl_wakeup(struct hci_dev *hdev)
0578 {
0579     struct btmrvl_private *priv = hci_get_drvdata(hdev);
0580     struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
0581 
0582     return device_may_wakeup(&card->func->dev);
0583 }
0584 
0585 /*
0586  * This function handles the event generated by firmware, rx data
0587  * received from firmware, and tx data sent from kernel.
0588  */
0589 static int btmrvl_service_main_thread(void *data)
0590 {
0591     struct btmrvl_thread *thread = data;
0592     struct btmrvl_private *priv = thread->priv;
0593     struct btmrvl_adapter *adapter = priv->adapter;
0594     wait_queue_entry_t wait;
0595     struct sk_buff *skb;
0596     ulong flags;
0597 
0598     init_waitqueue_entry(&wait, current);
0599 
0600     for (;;) {
0601         add_wait_queue(&thread->wait_q, &wait);
0602 
0603         set_current_state(TASK_INTERRUPTIBLE);
0604         if (kthread_should_stop() || priv->surprise_removed) {
0605             BT_DBG("main_thread: break from main thread");
0606             break;
0607         }
0608 
0609         if (adapter->wakeup_tries ||
0610                 ((!adapter->int_count) &&
0611                 (!priv->btmrvl_dev.tx_dnld_rdy ||
0612                 skb_queue_empty(&adapter->tx_queue)))) {
0613             BT_DBG("main_thread is sleeping...");
0614             schedule();
0615         }
0616 
0617         set_current_state(TASK_RUNNING);
0618 
0619         remove_wait_queue(&thread->wait_q, &wait);
0620 
0621         BT_DBG("main_thread woke up");
0622 
0623         if (kthread_should_stop() || priv->surprise_removed) {
0624             BT_DBG("main_thread: break from main thread");
0625             break;
0626         }
0627 
0628         spin_lock_irqsave(&priv->driver_lock, flags);
0629         if (adapter->int_count) {
0630             adapter->int_count = 0;
0631             spin_unlock_irqrestore(&priv->driver_lock, flags);
0632             priv->hw_process_int_status(priv);
0633         } else if (adapter->ps_state == PS_SLEEP &&
0634                     !skb_queue_empty(&adapter->tx_queue)) {
0635             spin_unlock_irqrestore(&priv->driver_lock, flags);
0636             adapter->wakeup_tries++;
0637             priv->hw_wakeup_firmware(priv);
0638             continue;
0639         } else {
0640             spin_unlock_irqrestore(&priv->driver_lock, flags);
0641         }
0642 
0643         if (adapter->ps_state == PS_SLEEP)
0644             continue;
0645 
0646         if (!priv->btmrvl_dev.tx_dnld_rdy ||
0647             priv->adapter->is_suspended)
0648             continue;
0649 
0650         skb = skb_dequeue(&adapter->tx_queue);
0651         if (skb) {
0652             if (btmrvl_tx_pkt(priv, skb))
0653                 priv->btmrvl_dev.hcidev->stat.err_tx++;
0654             else
0655                 priv->btmrvl_dev.hcidev->stat.byte_tx += skb->len;
0656 
0657             kfree_skb(skb);
0658         }
0659     }
0660 
0661     return 0;
0662 }
0663 
0664 int btmrvl_register_hdev(struct btmrvl_private *priv)
0665 {
0666     struct hci_dev *hdev = NULL;
0667     struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
0668     int ret;
0669 
0670     hdev = hci_alloc_dev();
0671     if (!hdev) {
0672         BT_ERR("Can not allocate HCI device");
0673         goto err_hdev;
0674     }
0675 
0676     priv->btmrvl_dev.hcidev = hdev;
0677     hci_set_drvdata(hdev, priv);
0678 
0679     hdev->bus   = HCI_SDIO;
0680     hdev->open  = btmrvl_open;
0681     hdev->close = btmrvl_close;
0682     hdev->flush = btmrvl_flush;
0683     hdev->send  = btmrvl_send_frame;
0684     hdev->setup = btmrvl_setup;
0685     hdev->set_bdaddr = btmrvl_set_bdaddr;
0686     hdev->wakeup = btmrvl_wakeup;
0687     SET_HCIDEV_DEV(hdev, &card->func->dev);
0688 
0689     hdev->dev_type = priv->btmrvl_dev.dev_type;
0690 
0691     ret = hci_register_dev(hdev);
0692     if (ret < 0) {
0693         BT_ERR("Can not register HCI device");
0694         goto err_hci_register_dev;
0695     }
0696 
0697 #ifdef CONFIG_DEBUG_FS
0698     btmrvl_debugfs_init(hdev);
0699 #endif
0700 
0701     return 0;
0702 
0703 err_hci_register_dev:
0704     hci_free_dev(hdev);
0705 
0706 err_hdev:
0707     /* Stop the thread servicing the interrupts */
0708     kthread_stop(priv->main_thread.task);
0709 
0710     btmrvl_free_adapter(priv);
0711     kfree(priv);
0712 
0713     return -ENOMEM;
0714 }
0715 EXPORT_SYMBOL_GPL(btmrvl_register_hdev);
0716 
0717 struct btmrvl_private *btmrvl_add_card(void *card)
0718 {
0719     struct btmrvl_private *priv;
0720 
0721     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
0722     if (!priv) {
0723         BT_ERR("Can not allocate priv");
0724         goto err_priv;
0725     }
0726 
0727     priv->adapter = kzalloc(sizeof(*priv->adapter), GFP_KERNEL);
0728     if (!priv->adapter) {
0729         BT_ERR("Allocate buffer for btmrvl_adapter failed!");
0730         goto err_adapter;
0731     }
0732 
0733     btmrvl_init_adapter(priv);
0734 
0735     BT_DBG("Starting kthread...");
0736     priv->main_thread.priv = priv;
0737     spin_lock_init(&priv->driver_lock);
0738 
0739     init_waitqueue_head(&priv->main_thread.wait_q);
0740     priv->main_thread.task = kthread_run(btmrvl_service_main_thread,
0741                 &priv->main_thread, "btmrvl_main_service");
0742     if (IS_ERR(priv->main_thread.task))
0743         goto err_thread;
0744 
0745     priv->btmrvl_dev.card = card;
0746     priv->btmrvl_dev.tx_dnld_rdy = true;
0747 
0748     return priv;
0749 
0750 err_thread:
0751     btmrvl_free_adapter(priv);
0752 
0753 err_adapter:
0754     kfree(priv);
0755 
0756 err_priv:
0757     return NULL;
0758 }
0759 EXPORT_SYMBOL_GPL(btmrvl_add_card);
0760 
0761 int btmrvl_remove_card(struct btmrvl_private *priv)
0762 {
0763     struct hci_dev *hdev;
0764 
0765     hdev = priv->btmrvl_dev.hcidev;
0766 
0767     wake_up_interruptible(&priv->adapter->cmd_wait_q);
0768     wake_up_interruptible(&priv->adapter->event_hs_wait_q);
0769 
0770     kthread_stop(priv->main_thread.task);
0771 
0772 #ifdef CONFIG_DEBUG_FS
0773     btmrvl_debugfs_remove(hdev);
0774 #endif
0775 
0776     hci_unregister_dev(hdev);
0777 
0778     hci_free_dev(hdev);
0779 
0780     priv->btmrvl_dev.hcidev = NULL;
0781 
0782     btmrvl_free_adapter(priv);
0783 
0784     kfree(priv);
0785 
0786     return 0;
0787 }
0788 EXPORT_SYMBOL_GPL(btmrvl_remove_card);
0789 
0790 MODULE_AUTHOR("Marvell International Ltd.");
0791 MODULE_DESCRIPTION("Marvell Bluetooth driver ver " VERSION);
0792 MODULE_VERSION(VERSION);
0793 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!