Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  Bluetooth supports for Qualcomm Atheros chips
0004  *
0005  *  Copyright (c) 2015 The Linux Foundation. All rights reserved.
0006  */
0007 #include <linux/module.h>
0008 #include <linux/firmware.h>
0009 #include <linux/vmalloc.h>
0010 
0011 #include <net/bluetooth/bluetooth.h>
0012 #include <net/bluetooth/hci_core.h>
0013 
0014 #include "btqca.h"
0015 
0016 #define VERSION "0.1"
0017 
0018 int qca_read_soc_version(struct hci_dev *hdev, struct qca_btsoc_version *ver,
0019              enum qca_btsoc_type soc_type)
0020 {
0021     struct sk_buff *skb;
0022     struct edl_event_hdr *edl;
0023     char cmd;
0024     int err = 0;
0025     u8 event_type = HCI_EV_VENDOR;
0026     u8 rlen = sizeof(*edl) + sizeof(*ver);
0027     u8 rtype = EDL_APP_VER_RES_EVT;
0028 
0029     bt_dev_dbg(hdev, "QCA Version Request");
0030 
0031     /* Unlike other SoC's sending version command response as payload to
0032      * VSE event. WCN3991 sends version command response as a payload to
0033      * command complete event.
0034      */
0035     if (soc_type >= QCA_WCN3991) {
0036         event_type = 0;
0037         rlen += 1;
0038         rtype = EDL_PATCH_VER_REQ_CMD;
0039     }
0040 
0041     cmd = EDL_PATCH_VER_REQ_CMD;
0042     skb = __hci_cmd_sync_ev(hdev, EDL_PATCH_CMD_OPCODE, EDL_PATCH_CMD_LEN,
0043                 &cmd, event_type, HCI_INIT_TIMEOUT);
0044     if (IS_ERR(skb)) {
0045         err = PTR_ERR(skb);
0046         bt_dev_err(hdev, "Reading QCA version information failed (%d)",
0047                err);
0048         return err;
0049     }
0050 
0051     if (skb->len != rlen) {
0052         bt_dev_err(hdev, "QCA Version size mismatch len %d", skb->len);
0053         err = -EILSEQ;
0054         goto out;
0055     }
0056 
0057     edl = (struct edl_event_hdr *)(skb->data);
0058     if (!edl) {
0059         bt_dev_err(hdev, "QCA TLV with no header");
0060         err = -EILSEQ;
0061         goto out;
0062     }
0063 
0064     if (edl->cresp != EDL_CMD_REQ_RES_EVT ||
0065         edl->rtype != rtype) {
0066         bt_dev_err(hdev, "QCA Wrong packet received %d %d", edl->cresp,
0067                edl->rtype);
0068         err = -EIO;
0069         goto out;
0070     }
0071 
0072     if (soc_type >= QCA_WCN3991)
0073         memcpy(ver, edl->data + 1, sizeof(*ver));
0074     else
0075         memcpy(ver, &edl->data, sizeof(*ver));
0076 
0077     bt_dev_info(hdev, "QCA Product ID   :0x%08x",
0078             le32_to_cpu(ver->product_id));
0079     bt_dev_info(hdev, "QCA SOC Version  :0x%08x",
0080             le32_to_cpu(ver->soc_id));
0081     bt_dev_info(hdev, "QCA ROM Version  :0x%08x",
0082             le16_to_cpu(ver->rom_ver));
0083     bt_dev_info(hdev, "QCA Patch Version:0x%08x",
0084             le16_to_cpu(ver->patch_ver));
0085 
0086     if (ver->soc_id == 0 || ver->rom_ver == 0)
0087         err = -EILSEQ;
0088 
0089 out:
0090     kfree_skb(skb);
0091     if (err)
0092         bt_dev_err(hdev, "QCA Failed to get version (%d)", err);
0093 
0094     return err;
0095 }
0096 EXPORT_SYMBOL_GPL(qca_read_soc_version);
0097 
0098 static int qca_read_fw_build_info(struct hci_dev *hdev)
0099 {
0100     struct sk_buff *skb;
0101     struct edl_event_hdr *edl;
0102     char cmd, build_label[QCA_FW_BUILD_VER_LEN];
0103     int build_lbl_len, err = 0;
0104 
0105     bt_dev_dbg(hdev, "QCA read fw build info");
0106 
0107     cmd = EDL_GET_BUILD_INFO_CMD;
0108     skb = __hci_cmd_sync_ev(hdev, EDL_PATCH_CMD_OPCODE, EDL_PATCH_CMD_LEN,
0109                 &cmd, 0, HCI_INIT_TIMEOUT);
0110     if (IS_ERR(skb)) {
0111         err = PTR_ERR(skb);
0112         bt_dev_err(hdev, "Reading QCA fw build info failed (%d)",
0113                err);
0114         return err;
0115     }
0116 
0117     edl = (struct edl_event_hdr *)(skb->data);
0118     if (!edl) {
0119         bt_dev_err(hdev, "QCA read fw build info with no header");
0120         err = -EILSEQ;
0121         goto out;
0122     }
0123 
0124     if (edl->cresp != EDL_CMD_REQ_RES_EVT ||
0125         edl->rtype != EDL_GET_BUILD_INFO_CMD) {
0126         bt_dev_err(hdev, "QCA Wrong packet received %d %d", edl->cresp,
0127                edl->rtype);
0128         err = -EIO;
0129         goto out;
0130     }
0131 
0132     build_lbl_len = edl->data[0];
0133     if (build_lbl_len <= QCA_FW_BUILD_VER_LEN - 1) {
0134         memcpy(build_label, edl->data + 1, build_lbl_len);
0135         *(build_label + build_lbl_len) = '\0';
0136     }
0137 
0138     hci_set_fw_info(hdev, "%s", build_label);
0139 
0140 out:
0141     kfree_skb(skb);
0142     return err;
0143 }
0144 
0145 static int qca_send_patch_config_cmd(struct hci_dev *hdev)
0146 {
0147     const u8 cmd[] = { EDL_PATCH_CONFIG_CMD, 0x01, 0, 0, 0 };
0148     struct sk_buff *skb;
0149     struct edl_event_hdr *edl;
0150     int err;
0151 
0152     bt_dev_dbg(hdev, "QCA Patch config");
0153 
0154     skb = __hci_cmd_sync_ev(hdev, EDL_PATCH_CMD_OPCODE, sizeof(cmd),
0155                 cmd, HCI_EV_VENDOR, HCI_INIT_TIMEOUT);
0156     if (IS_ERR(skb)) {
0157         err = PTR_ERR(skb);
0158         bt_dev_err(hdev, "Sending QCA Patch config failed (%d)", err);
0159         return err;
0160     }
0161 
0162     if (skb->len != 2) {
0163         bt_dev_err(hdev, "QCA Patch config cmd size mismatch len %d", skb->len);
0164         err = -EILSEQ;
0165         goto out;
0166     }
0167 
0168     edl = (struct edl_event_hdr *)(skb->data);
0169     if (!edl) {
0170         bt_dev_err(hdev, "QCA Patch config with no header");
0171         err = -EILSEQ;
0172         goto out;
0173     }
0174 
0175     if (edl->cresp != EDL_PATCH_CONFIG_RES_EVT || edl->rtype != EDL_PATCH_CONFIG_CMD) {
0176         bt_dev_err(hdev, "QCA Wrong packet received %d %d", edl->cresp,
0177                edl->rtype);
0178         err = -EIO;
0179         goto out;
0180     }
0181 
0182     err = 0;
0183 
0184 out:
0185     kfree_skb(skb);
0186     return err;
0187 }
0188 
0189 static int qca_send_reset(struct hci_dev *hdev)
0190 {
0191     struct sk_buff *skb;
0192     int err;
0193 
0194     bt_dev_dbg(hdev, "QCA HCI_RESET");
0195 
0196     skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
0197     if (IS_ERR(skb)) {
0198         err = PTR_ERR(skb);
0199         bt_dev_err(hdev, "QCA Reset failed (%d)", err);
0200         return err;
0201     }
0202 
0203     kfree_skb(skb);
0204 
0205     return 0;
0206 }
0207 
0208 int qca_send_pre_shutdown_cmd(struct hci_dev *hdev)
0209 {
0210     struct sk_buff *skb;
0211     int err;
0212 
0213     bt_dev_dbg(hdev, "QCA pre shutdown cmd");
0214 
0215     skb = __hci_cmd_sync_ev(hdev, QCA_PRE_SHUTDOWN_CMD, 0,
0216                 NULL, HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
0217 
0218     if (IS_ERR(skb)) {
0219         err = PTR_ERR(skb);
0220         bt_dev_err(hdev, "QCA preshutdown_cmd failed (%d)", err);
0221         return err;
0222     }
0223 
0224     kfree_skb(skb);
0225 
0226     return 0;
0227 }
0228 EXPORT_SYMBOL_GPL(qca_send_pre_shutdown_cmd);
0229 
0230 static void qca_tlv_check_data(struct hci_dev *hdev,
0231                    struct qca_fw_config *config,
0232         u8 *fw_data, enum qca_btsoc_type soc_type)
0233 {
0234     const u8 *data;
0235     u32 type_len;
0236     u16 tag_id, tag_len;
0237     int idx, length;
0238     struct tlv_type_hdr *tlv;
0239     struct tlv_type_patch *tlv_patch;
0240     struct tlv_type_nvm *tlv_nvm;
0241     uint8_t nvm_baud_rate = config->user_baud_rate;
0242 
0243     config->dnld_mode = QCA_SKIP_EVT_NONE;
0244     config->dnld_type = QCA_SKIP_EVT_NONE;
0245 
0246     switch (config->type) {
0247     case ELF_TYPE_PATCH:
0248         config->dnld_mode = QCA_SKIP_EVT_VSE_CC;
0249         config->dnld_type = QCA_SKIP_EVT_VSE_CC;
0250 
0251         bt_dev_dbg(hdev, "File Class        : 0x%x", fw_data[4]);
0252         bt_dev_dbg(hdev, "Data Encoding     : 0x%x", fw_data[5]);
0253         bt_dev_dbg(hdev, "File version      : 0x%x", fw_data[6]);
0254         break;
0255     case TLV_TYPE_PATCH:
0256         tlv = (struct tlv_type_hdr *)fw_data;
0257         type_len = le32_to_cpu(tlv->type_len);
0258         tlv_patch = (struct tlv_type_patch *)tlv->data;
0259 
0260         /* For Rome version 1.1 to 3.1, all segment commands
0261          * are acked by a vendor specific event (VSE).
0262          * For Rome >= 3.2, the download mode field indicates
0263          * if VSE is skipped by the controller.
0264          * In case VSE is skipped, only the last segment is acked.
0265          */
0266         config->dnld_mode = tlv_patch->download_mode;
0267         config->dnld_type = config->dnld_mode;
0268 
0269         BT_DBG("TLV Type\t\t : 0x%x", type_len & 0x000000ff);
0270         BT_DBG("Total Length           : %d bytes",
0271                le32_to_cpu(tlv_patch->total_size));
0272         BT_DBG("Patch Data Length      : %d bytes",
0273                le32_to_cpu(tlv_patch->data_length));
0274         BT_DBG("Signing Format Version : 0x%x",
0275                tlv_patch->format_version);
0276         BT_DBG("Signature Algorithm    : 0x%x",
0277                tlv_patch->signature);
0278         BT_DBG("Download mode          : 0x%x",
0279                tlv_patch->download_mode);
0280         BT_DBG("Reserved               : 0x%x",
0281                tlv_patch->reserved1);
0282         BT_DBG("Product ID             : 0x%04x",
0283                le16_to_cpu(tlv_patch->product_id));
0284         BT_DBG("Rom Build Version      : 0x%04x",
0285                le16_to_cpu(tlv_patch->rom_build));
0286         BT_DBG("Patch Version          : 0x%04x",
0287                le16_to_cpu(tlv_patch->patch_version));
0288         BT_DBG("Reserved               : 0x%x",
0289                le16_to_cpu(tlv_patch->reserved2));
0290         BT_DBG("Patch Entry Address    : 0x%x",
0291                le32_to_cpu(tlv_patch->entry));
0292         break;
0293 
0294     case TLV_TYPE_NVM:
0295         tlv = (struct tlv_type_hdr *)fw_data;
0296 
0297         type_len = le32_to_cpu(tlv->type_len);
0298         length = (type_len >> 8) & 0x00ffffff;
0299 
0300         BT_DBG("TLV Type\t\t : 0x%x", type_len & 0x000000ff);
0301         BT_DBG("Length\t\t : %d bytes", length);
0302 
0303         idx = 0;
0304         data = tlv->data;
0305         while (idx < length) {
0306             tlv_nvm = (struct tlv_type_nvm *)(data + idx);
0307 
0308             tag_id = le16_to_cpu(tlv_nvm->tag_id);
0309             tag_len = le16_to_cpu(tlv_nvm->tag_len);
0310 
0311             /* Update NVM tags as needed */
0312             switch (tag_id) {
0313             case EDL_TAG_ID_HCI:
0314                 /* HCI transport layer parameters
0315                  * enabling software inband sleep
0316                  * onto controller side.
0317                  */
0318                 tlv_nvm->data[0] |= 0x80;
0319 
0320                 /* UART Baud Rate */
0321                 if (soc_type >= QCA_WCN3991)
0322                     tlv_nvm->data[1] = nvm_baud_rate;
0323                 else
0324                     tlv_nvm->data[2] = nvm_baud_rate;
0325 
0326                 break;
0327 
0328             case EDL_TAG_ID_DEEP_SLEEP:
0329                 /* Sleep enable mask
0330                  * enabling deep sleep feature on controller.
0331                  */
0332                 tlv_nvm->data[0] |= 0x01;
0333 
0334                 break;
0335             }
0336 
0337             idx += (sizeof(u16) + sizeof(u16) + 8 + tag_len);
0338         }
0339         break;
0340 
0341     default:
0342         BT_ERR("Unknown TLV type %d", config->type);
0343         break;
0344     }
0345 }
0346 
0347 static int qca_tlv_send_segment(struct hci_dev *hdev, int seg_size,
0348                 const u8 *data, enum qca_tlv_dnld_mode mode,
0349                 enum qca_btsoc_type soc_type)
0350 {
0351     struct sk_buff *skb;
0352     struct edl_event_hdr *edl;
0353     struct tlv_seg_resp *tlv_resp;
0354     u8 cmd[MAX_SIZE_PER_TLV_SEGMENT + 2];
0355     int err = 0;
0356     u8 event_type = HCI_EV_VENDOR;
0357     u8 rlen = (sizeof(*edl) + sizeof(*tlv_resp));
0358     u8 rtype = EDL_TVL_DNLD_RES_EVT;
0359 
0360     cmd[0] = EDL_PATCH_TLV_REQ_CMD;
0361     cmd[1] = seg_size;
0362     memcpy(cmd + 2, data, seg_size);
0363 
0364     if (mode == QCA_SKIP_EVT_VSE_CC || mode == QCA_SKIP_EVT_VSE)
0365         return __hci_cmd_send(hdev, EDL_PATCH_CMD_OPCODE, seg_size + 2,
0366                       cmd);
0367 
0368     /* Unlike other SoC's sending version command response as payload to
0369      * VSE event. WCN3991 sends version command response as a payload to
0370      * command complete event.
0371      */
0372     if (soc_type >= QCA_WCN3991) {
0373         event_type = 0;
0374         rlen = sizeof(*edl);
0375         rtype = EDL_PATCH_TLV_REQ_CMD;
0376     }
0377 
0378     skb = __hci_cmd_sync_ev(hdev, EDL_PATCH_CMD_OPCODE, seg_size + 2, cmd,
0379                 event_type, HCI_INIT_TIMEOUT);
0380     if (IS_ERR(skb)) {
0381         err = PTR_ERR(skb);
0382         bt_dev_err(hdev, "QCA Failed to send TLV segment (%d)", err);
0383         return err;
0384     }
0385 
0386     if (skb->len != rlen) {
0387         bt_dev_err(hdev, "QCA TLV response size mismatch");
0388         err = -EILSEQ;
0389         goto out;
0390     }
0391 
0392     edl = (struct edl_event_hdr *)(skb->data);
0393     if (!edl) {
0394         bt_dev_err(hdev, "TLV with no header");
0395         err = -EILSEQ;
0396         goto out;
0397     }
0398 
0399     if (edl->cresp != EDL_CMD_REQ_RES_EVT || edl->rtype != rtype) {
0400         bt_dev_err(hdev, "QCA TLV with error stat 0x%x rtype 0x%x",
0401                edl->cresp, edl->rtype);
0402         err = -EIO;
0403     }
0404 
0405     if (soc_type >= QCA_WCN3991)
0406         goto out;
0407 
0408     tlv_resp = (struct tlv_seg_resp *)(edl->data);
0409     if (tlv_resp->result) {
0410         bt_dev_err(hdev, "QCA TLV with error stat 0x%x rtype 0x%x (0x%x)",
0411                edl->cresp, edl->rtype, tlv_resp->result);
0412     }
0413 
0414 out:
0415     kfree_skb(skb);
0416 
0417     return err;
0418 }
0419 
0420 static int qca_inject_cmd_complete_event(struct hci_dev *hdev)
0421 {
0422     struct hci_event_hdr *hdr;
0423     struct hci_ev_cmd_complete *evt;
0424     struct sk_buff *skb;
0425 
0426     skb = bt_skb_alloc(sizeof(*hdr) + sizeof(*evt) + 1, GFP_KERNEL);
0427     if (!skb)
0428         return -ENOMEM;
0429 
0430     hdr = skb_put(skb, sizeof(*hdr));
0431     hdr->evt = HCI_EV_CMD_COMPLETE;
0432     hdr->plen = sizeof(*evt) + 1;
0433 
0434     evt = skb_put(skb, sizeof(*evt));
0435     evt->ncmd = 1;
0436     evt->opcode = cpu_to_le16(QCA_HCI_CC_OPCODE);
0437 
0438     skb_put_u8(skb, QCA_HCI_CC_SUCCESS);
0439 
0440     hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
0441 
0442     return hci_recv_frame(hdev, skb);
0443 }
0444 
0445 static int qca_download_firmware(struct hci_dev *hdev,
0446                  struct qca_fw_config *config,
0447                  enum qca_btsoc_type soc_type,
0448                  u8 rom_ver)
0449 {
0450     const struct firmware *fw;
0451     u8 *data;
0452     const u8 *segment;
0453     int ret, size, remain, i = 0;
0454 
0455     bt_dev_info(hdev, "QCA Downloading %s", config->fwname);
0456 
0457     ret = request_firmware(&fw, config->fwname, &hdev->dev);
0458     if (ret) {
0459         /* For WCN6750, if mbn file is not present then check for
0460          * tlv file.
0461          */
0462         if (soc_type == QCA_WCN6750 && config->type == ELF_TYPE_PATCH) {
0463             bt_dev_dbg(hdev, "QCA Failed to request file: %s (%d)",
0464                    config->fwname, ret);
0465             config->type = TLV_TYPE_PATCH;
0466             snprintf(config->fwname, sizeof(config->fwname),
0467                  "qca/msbtfw%02x.tlv", rom_ver);
0468             bt_dev_info(hdev, "QCA Downloading %s", config->fwname);
0469             ret = request_firmware(&fw, config->fwname, &hdev->dev);
0470             if (ret) {
0471                 bt_dev_err(hdev, "QCA Failed to request file: %s (%d)",
0472                        config->fwname, ret);
0473                 return ret;
0474             }
0475         } else {
0476             bt_dev_err(hdev, "QCA Failed to request file: %s (%d)",
0477                    config->fwname, ret);
0478             return ret;
0479         }
0480     }
0481 
0482     size = fw->size;
0483     data = vmalloc(fw->size);
0484     if (!data) {
0485         bt_dev_err(hdev, "QCA Failed to allocate memory for file: %s",
0486                config->fwname);
0487         release_firmware(fw);
0488         return -ENOMEM;
0489     }
0490 
0491     memcpy(data, fw->data, size);
0492     release_firmware(fw);
0493 
0494     qca_tlv_check_data(hdev, config, data, soc_type);
0495 
0496     segment = data;
0497     remain = size;
0498     while (remain > 0) {
0499         int segsize = min(MAX_SIZE_PER_TLV_SEGMENT, remain);
0500 
0501         bt_dev_dbg(hdev, "Send segment %d, size %d", i++, segsize);
0502 
0503         remain -= segsize;
0504         /* The last segment is always acked regardless download mode */
0505         if (!remain || segsize < MAX_SIZE_PER_TLV_SEGMENT)
0506             config->dnld_mode = QCA_SKIP_EVT_NONE;
0507 
0508         ret = qca_tlv_send_segment(hdev, segsize, segment,
0509                        config->dnld_mode, soc_type);
0510         if (ret)
0511             goto out;
0512 
0513         segment += segsize;
0514     }
0515 
0516     /* Latest qualcomm chipsets are not sending a command complete event
0517      * for every fw packet sent. They only respond with a vendor specific
0518      * event for the last packet. This optimization in the chip will
0519      * decrease the BT in initialization time. Here we will inject a command
0520      * complete event to avoid a command timeout error message.
0521      */
0522     if (config->dnld_type == QCA_SKIP_EVT_VSE_CC ||
0523         config->dnld_type == QCA_SKIP_EVT_VSE)
0524         ret = qca_inject_cmd_complete_event(hdev);
0525 
0526 out:
0527     vfree(data);
0528 
0529     return ret;
0530 }
0531 
0532 static int qca_disable_soc_logging(struct hci_dev *hdev)
0533 {
0534     struct sk_buff *skb;
0535     u8 cmd[2];
0536     int err;
0537 
0538     cmd[0] = QCA_DISABLE_LOGGING_SUB_OP;
0539     cmd[1] = 0x00;
0540     skb = __hci_cmd_sync_ev(hdev, QCA_DISABLE_LOGGING, sizeof(cmd), cmd,
0541                 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
0542     if (IS_ERR(skb)) {
0543         err = PTR_ERR(skb);
0544         bt_dev_err(hdev, "QCA Failed to disable soc logging(%d)", err);
0545         return err;
0546     }
0547 
0548     kfree_skb(skb);
0549 
0550     return 0;
0551 }
0552 
0553 int qca_set_bdaddr_rome(struct hci_dev *hdev, const bdaddr_t *bdaddr)
0554 {
0555     struct sk_buff *skb;
0556     u8 cmd[9];
0557     int err;
0558 
0559     cmd[0] = EDL_NVM_ACCESS_SET_REQ_CMD;
0560     cmd[1] = 0x02;          /* TAG ID */
0561     cmd[2] = sizeof(bdaddr_t);  /* size */
0562     memcpy(cmd + 3, bdaddr, sizeof(bdaddr_t));
0563     skb = __hci_cmd_sync_ev(hdev, EDL_NVM_ACCESS_OPCODE, sizeof(cmd), cmd,
0564                 HCI_EV_VENDOR, HCI_INIT_TIMEOUT);
0565     if (IS_ERR(skb)) {
0566         err = PTR_ERR(skb);
0567         bt_dev_err(hdev, "QCA Change address command failed (%d)", err);
0568         return err;
0569     }
0570 
0571     kfree_skb(skb);
0572 
0573     return 0;
0574 }
0575 EXPORT_SYMBOL_GPL(qca_set_bdaddr_rome);
0576 
0577 int qca_uart_setup(struct hci_dev *hdev, uint8_t baudrate,
0578            enum qca_btsoc_type soc_type, struct qca_btsoc_version ver,
0579            const char *firmware_name)
0580 {
0581     struct qca_fw_config config;
0582     int err;
0583     u8 rom_ver = 0;
0584     u32 soc_ver;
0585 
0586     bt_dev_dbg(hdev, "QCA setup on UART");
0587 
0588     soc_ver = get_soc_ver(ver.soc_id, ver.rom_ver);
0589 
0590     bt_dev_info(hdev, "QCA controller version 0x%08x", soc_ver);
0591 
0592     config.user_baud_rate = baudrate;
0593 
0594     /* Firmware files to download are based on ROM version.
0595      * ROM version is derived from last two bytes of soc_ver.
0596      */
0597     rom_ver = ((soc_ver & 0x00000f00) >> 0x04) | (soc_ver & 0x0000000f);
0598 
0599     if (soc_type == QCA_WCN6750)
0600         qca_send_patch_config_cmd(hdev);
0601 
0602     /* Download rampatch file */
0603     config.type = TLV_TYPE_PATCH;
0604     if (qca_is_wcn399x(soc_type)) {
0605         snprintf(config.fwname, sizeof(config.fwname),
0606              "qca/crbtfw%02x.tlv", rom_ver);
0607     } else if (soc_type == QCA_QCA6390) {
0608         snprintf(config.fwname, sizeof(config.fwname),
0609              "qca/htbtfw%02x.tlv", rom_ver);
0610     } else if (soc_type == QCA_WCN6750) {
0611         /* Choose mbn file by default.If mbn file is not found
0612          * then choose tlv file
0613          */
0614         config.type = ELF_TYPE_PATCH;
0615         snprintf(config.fwname, sizeof(config.fwname),
0616              "qca/msbtfw%02x.mbn", rom_ver);
0617     } else {
0618         snprintf(config.fwname, sizeof(config.fwname),
0619              "qca/rampatch_%08x.bin", soc_ver);
0620     }
0621 
0622     err = qca_download_firmware(hdev, &config, soc_type, rom_ver);
0623     if (err < 0) {
0624         bt_dev_err(hdev, "QCA Failed to download patch (%d)", err);
0625         return err;
0626     }
0627 
0628     /* Give the controller some time to get ready to receive the NVM */
0629     msleep(10);
0630 
0631     /* Download NVM configuration */
0632     config.type = TLV_TYPE_NVM;
0633     if (firmware_name)
0634         snprintf(config.fwname, sizeof(config.fwname),
0635              "qca/%s", firmware_name);
0636     else if (qca_is_wcn399x(soc_type)) {
0637         if (ver.soc_id == QCA_WCN3991_SOC_ID) {
0638             snprintf(config.fwname, sizeof(config.fwname),
0639                  "qca/crnv%02xu.bin", rom_ver);
0640         } else {
0641             snprintf(config.fwname, sizeof(config.fwname),
0642                  "qca/crnv%02x.bin", rom_ver);
0643         }
0644     }
0645     else if (soc_type == QCA_QCA6390)
0646         snprintf(config.fwname, sizeof(config.fwname),
0647              "qca/htnv%02x.bin", rom_ver);
0648     else if (soc_type == QCA_WCN6750)
0649         snprintf(config.fwname, sizeof(config.fwname),
0650              "qca/msnv%02x.bin", rom_ver);
0651     else
0652         snprintf(config.fwname, sizeof(config.fwname),
0653              "qca/nvm_%08x.bin", soc_ver);
0654 
0655     err = qca_download_firmware(hdev, &config, soc_type, rom_ver);
0656     if (err < 0) {
0657         bt_dev_err(hdev, "QCA Failed to download NVM (%d)", err);
0658         return err;
0659     }
0660 
0661     if (soc_type >= QCA_WCN3991) {
0662         err = qca_disable_soc_logging(hdev);
0663         if (err < 0)
0664             return err;
0665     }
0666 
0667     /* WCN399x and WCN6750 supports the Microsoft vendor extension with 0xFD70 as the
0668      * VsMsftOpCode.
0669      */
0670     switch (soc_type) {
0671     case QCA_WCN3990:
0672     case QCA_WCN3991:
0673     case QCA_WCN3998:
0674     case QCA_WCN6750:
0675         hci_set_msft_opcode(hdev, 0xFD70);
0676         break;
0677     default:
0678         break;
0679     }
0680 
0681     /* Perform HCI reset */
0682     err = qca_send_reset(hdev);
0683     if (err < 0) {
0684         bt_dev_err(hdev, "QCA Failed to run HCI_RESET (%d)", err);
0685         return err;
0686     }
0687 
0688     if (soc_type == QCA_WCN3991 || soc_type == QCA_WCN6750) {
0689         /* get fw build info */
0690         err = qca_read_fw_build_info(hdev);
0691         if (err < 0)
0692             return err;
0693     }
0694 
0695     bt_dev_info(hdev, "QCA setup on UART is completed");
0696 
0697     return 0;
0698 }
0699 EXPORT_SYMBOL_GPL(qca_uart_setup);
0700 
0701 int qca_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
0702 {
0703     struct sk_buff *skb;
0704     int err;
0705 
0706     skb = __hci_cmd_sync_ev(hdev, EDL_WRITE_BD_ADDR_OPCODE, 6, bdaddr,
0707                 HCI_EV_VENDOR, HCI_INIT_TIMEOUT);
0708     if (IS_ERR(skb)) {
0709         err = PTR_ERR(skb);
0710         bt_dev_err(hdev, "QCA Change address cmd failed (%d)", err);
0711         return err;
0712     }
0713 
0714     kfree_skb(skb);
0715 
0716     return 0;
0717 }
0718 EXPORT_SYMBOL_GPL(qca_set_bdaddr);
0719 
0720 
0721 MODULE_AUTHOR("Ben Young Tae Kim <ytkim@qca.qualcomm.com>");
0722 MODULE_DESCRIPTION("Bluetooth support for Qualcomm Atheros family ver " VERSION);
0723 MODULE_VERSION(VERSION);
0724 MODULE_LICENSE("GPL");
[ 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!