![Loic Poulain](/assets/img/avatar_default.png)
This patch adds rampatch download compatibility for ROME >= 3.2. Starting with ROME 3.2, the 'download mode' field of the rampatch header indicates if the controller acknowledges (or not) the received rampatch segments. If not, we need to send all the segments without expecting any event from the controller (except for the last segment). Goal is (I assume) to speed-up rampatch download. This fixes BT on Dragonboard-600c P2 which includes the following BT controller: hci0: ROME Patch Version Request hci0: Product:0x00000008 hci0: Patch :0x00000111 hci0: ROM :0x00000302 hci0: SOC :0x00000023 Signed-off-by: Loic Poulain <loic.poulain@linaro.org> Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
387 lines
9.8 KiB
C
387 lines
9.8 KiB
C
/*
|
|
* Bluetooth supports for Qualcomm Atheros chips
|
|
*
|
|
* Copyright (c) 2015 The Linux Foundation. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2
|
|
* as published by the Free Software Foundation
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
#include <linux/module.h>
|
|
#include <linux/firmware.h>
|
|
|
|
#include <net/bluetooth/bluetooth.h>
|
|
#include <net/bluetooth/hci_core.h>
|
|
|
|
#include "btqca.h"
|
|
|
|
#define VERSION "0.1"
|
|
|
|
static int rome_patch_ver_req(struct hci_dev *hdev, u32 *rome_version)
|
|
{
|
|
struct sk_buff *skb;
|
|
struct edl_event_hdr *edl;
|
|
struct rome_version *ver;
|
|
char cmd;
|
|
int err = 0;
|
|
|
|
BT_DBG("%s: ROME Patch Version Request", hdev->name);
|
|
|
|
cmd = EDL_PATCH_VER_REQ_CMD;
|
|
skb = __hci_cmd_sync_ev(hdev, EDL_PATCH_CMD_OPCODE, EDL_PATCH_CMD_LEN,
|
|
&cmd, HCI_VENDOR_PKT, HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
err = PTR_ERR(skb);
|
|
BT_ERR("%s: Failed to read version of ROME (%d)", hdev->name,
|
|
err);
|
|
return err;
|
|
}
|
|
|
|
if (skb->len != sizeof(*edl) + sizeof(*ver)) {
|
|
BT_ERR("%s: Version size mismatch len %d", hdev->name,
|
|
skb->len);
|
|
err = -EILSEQ;
|
|
goto out;
|
|
}
|
|
|
|
edl = (struct edl_event_hdr *)(skb->data);
|
|
if (!edl) {
|
|
BT_ERR("%s: TLV with no header", hdev->name);
|
|
err = -EILSEQ;
|
|
goto out;
|
|
}
|
|
|
|
if (edl->cresp != EDL_CMD_REQ_RES_EVT ||
|
|
edl->rtype != EDL_APP_VER_RES_EVT) {
|
|
BT_ERR("%s: Wrong packet received %d %d", hdev->name,
|
|
edl->cresp, edl->rtype);
|
|
err = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
ver = (struct rome_version *)(edl->data);
|
|
|
|
BT_DBG("%s: Product:0x%08x", hdev->name, le32_to_cpu(ver->product_id));
|
|
BT_DBG("%s: Patch :0x%08x", hdev->name, le16_to_cpu(ver->patch_ver));
|
|
BT_DBG("%s: ROM :0x%08x", hdev->name, le16_to_cpu(ver->rome_ver));
|
|
BT_DBG("%s: SOC :0x%08x", hdev->name, le32_to_cpu(ver->soc_id));
|
|
|
|
/* ROME chipset version can be decided by patch and SoC
|
|
* version, combination with upper 2 bytes from SoC
|
|
* and lower 2 bytes from patch will be used.
|
|
*/
|
|
*rome_version = (le32_to_cpu(ver->soc_id) << 16) |
|
|
(le16_to_cpu(ver->rome_ver) & 0x0000ffff);
|
|
|
|
out:
|
|
kfree_skb(skb);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int rome_reset(struct hci_dev *hdev)
|
|
{
|
|
struct sk_buff *skb;
|
|
int err;
|
|
|
|
BT_DBG("%s: ROME HCI_RESET", hdev->name);
|
|
|
|
skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
err = PTR_ERR(skb);
|
|
BT_ERR("%s: Reset failed (%d)", hdev->name, err);
|
|
return err;
|
|
}
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void rome_tlv_check_data(struct rome_config *config,
|
|
const struct firmware *fw)
|
|
{
|
|
const u8 *data;
|
|
u32 type_len;
|
|
u16 tag_id, tag_len;
|
|
int idx, length;
|
|
struct tlv_type_hdr *tlv;
|
|
struct tlv_type_patch *tlv_patch;
|
|
struct tlv_type_nvm *tlv_nvm;
|
|
|
|
tlv = (struct tlv_type_hdr *)fw->data;
|
|
|
|
type_len = le32_to_cpu(tlv->type_len);
|
|
length = (type_len >> 8) & 0x00ffffff;
|
|
|
|
BT_DBG("TLV Type\t\t : 0x%x", type_len & 0x000000ff);
|
|
BT_DBG("Length\t\t : %d bytes", length);
|
|
|
|
config->dnld_mode = ROME_SKIP_EVT_NONE;
|
|
|
|
switch (config->type) {
|
|
case TLV_TYPE_PATCH:
|
|
tlv_patch = (struct tlv_type_patch *)tlv->data;
|
|
|
|
/* For Rome version 1.1 to 3.1, all segment commands
|
|
* are acked by a vendor specific event (VSE).
|
|
* For Rome >= 3.2, the download mode field indicates
|
|
* if VSE is skipped by the controller.
|
|
* In case VSE is skipped, only the last segment is acked.
|
|
*/
|
|
config->dnld_mode = tlv_patch->download_mode;
|
|
|
|
BT_DBG("Total Length : %d bytes",
|
|
le32_to_cpu(tlv_patch->total_size));
|
|
BT_DBG("Patch Data Length : %d bytes",
|
|
le32_to_cpu(tlv_patch->data_length));
|
|
BT_DBG("Signing Format Version : 0x%x",
|
|
tlv_patch->format_version);
|
|
BT_DBG("Signature Algorithm : 0x%x",
|
|
tlv_patch->signature);
|
|
BT_DBG("Download mode : 0x%x",
|
|
tlv_patch->download_mode);
|
|
BT_DBG("Reserved : 0x%x",
|
|
tlv_patch->reserved1);
|
|
BT_DBG("Product ID : 0x%04x",
|
|
le16_to_cpu(tlv_patch->product_id));
|
|
BT_DBG("Rom Build Version : 0x%04x",
|
|
le16_to_cpu(tlv_patch->rom_build));
|
|
BT_DBG("Patch Version : 0x%04x",
|
|
le16_to_cpu(tlv_patch->patch_version));
|
|
BT_DBG("Reserved : 0x%x",
|
|
le16_to_cpu(tlv_patch->reserved2));
|
|
BT_DBG("Patch Entry Address : 0x%x",
|
|
le32_to_cpu(tlv_patch->entry));
|
|
break;
|
|
|
|
case TLV_TYPE_NVM:
|
|
idx = 0;
|
|
data = tlv->data;
|
|
while (idx < length) {
|
|
tlv_nvm = (struct tlv_type_nvm *)(data + idx);
|
|
|
|
tag_id = le16_to_cpu(tlv_nvm->tag_id);
|
|
tag_len = le16_to_cpu(tlv_nvm->tag_len);
|
|
|
|
/* Update NVM tags as needed */
|
|
switch (tag_id) {
|
|
case EDL_TAG_ID_HCI:
|
|
/* HCI transport layer parameters
|
|
* enabling software inband sleep
|
|
* onto controller side.
|
|
*/
|
|
tlv_nvm->data[0] |= 0x80;
|
|
|
|
/* UART Baud Rate */
|
|
tlv_nvm->data[2] = config->user_baud_rate;
|
|
|
|
break;
|
|
|
|
case EDL_TAG_ID_DEEP_SLEEP:
|
|
/* Sleep enable mask
|
|
* enabling deep sleep feature on controller.
|
|
*/
|
|
tlv_nvm->data[0] |= 0x01;
|
|
|
|
break;
|
|
}
|
|
|
|
idx += (sizeof(u16) + sizeof(u16) + 8 + tag_len);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
BT_ERR("Unknown TLV type %d", config->type);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int rome_tlv_send_segment(struct hci_dev *hdev, int seg_size,
|
|
const u8 *data, enum rome_tlv_dnld_mode mode)
|
|
{
|
|
struct sk_buff *skb;
|
|
struct edl_event_hdr *edl;
|
|
struct tlv_seg_resp *tlv_resp;
|
|
u8 cmd[MAX_SIZE_PER_TLV_SEGMENT + 2];
|
|
int err = 0;
|
|
|
|
cmd[0] = EDL_PATCH_TLV_REQ_CMD;
|
|
cmd[1] = seg_size;
|
|
memcpy(cmd + 2, data, seg_size);
|
|
|
|
if (mode == ROME_SKIP_EVT_VSE_CC || mode == ROME_SKIP_EVT_VSE)
|
|
return __hci_cmd_send(hdev, EDL_PATCH_CMD_OPCODE, seg_size + 2,
|
|
cmd);
|
|
|
|
skb = __hci_cmd_sync_ev(hdev, EDL_PATCH_CMD_OPCODE, seg_size + 2, cmd,
|
|
HCI_VENDOR_PKT, HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
err = PTR_ERR(skb);
|
|
BT_ERR("%s: Failed to send TLV segment (%d)", hdev->name, err);
|
|
return err;
|
|
}
|
|
|
|
if (skb->len != sizeof(*edl) + sizeof(*tlv_resp)) {
|
|
BT_ERR("%s: TLV response size mismatch", hdev->name);
|
|
err = -EILSEQ;
|
|
goto out;
|
|
}
|
|
|
|
edl = (struct edl_event_hdr *)(skb->data);
|
|
if (!edl) {
|
|
BT_ERR("%s: TLV with no header", hdev->name);
|
|
err = -EILSEQ;
|
|
goto out;
|
|
}
|
|
|
|
tlv_resp = (struct tlv_seg_resp *)(edl->data);
|
|
|
|
if (edl->cresp != EDL_CMD_REQ_RES_EVT ||
|
|
edl->rtype != EDL_TVL_DNLD_RES_EVT || tlv_resp->result != 0x00) {
|
|
BT_ERR("%s: TLV with error stat 0x%x rtype 0x%x (0x%x)",
|
|
hdev->name, edl->cresp, edl->rtype, tlv_resp->result);
|
|
err = -EIO;
|
|
}
|
|
|
|
out:
|
|
kfree_skb(skb);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int rome_download_firmware(struct hci_dev *hdev,
|
|
struct rome_config *config)
|
|
{
|
|
const struct firmware *fw;
|
|
const u8 *segment;
|
|
int ret, remain, i = 0;
|
|
|
|
bt_dev_info(hdev, "ROME Downloading %s", config->fwname);
|
|
|
|
ret = request_firmware(&fw, config->fwname, &hdev->dev);
|
|
if (ret) {
|
|
BT_ERR("%s: Failed to request file: %s (%d)", hdev->name,
|
|
config->fwname, ret);
|
|
return ret;
|
|
}
|
|
|
|
rome_tlv_check_data(config, fw);
|
|
|
|
segment = fw->data;
|
|
remain = fw->size;
|
|
while (remain > 0) {
|
|
int segsize = min(MAX_SIZE_PER_TLV_SEGMENT, remain);
|
|
|
|
bt_dev_dbg(hdev, "Send segment %d, size %d", i++, segsize);
|
|
|
|
remain -= segsize;
|
|
/* The last segment is always acked regardless download mode */
|
|
if (!remain || segsize < MAX_SIZE_PER_TLV_SEGMENT)
|
|
config->dnld_mode = ROME_SKIP_EVT_NONE;
|
|
|
|
ret = rome_tlv_send_segment(hdev, segsize, segment,
|
|
config->dnld_mode);
|
|
if (ret)
|
|
break;
|
|
|
|
segment += segsize;
|
|
}
|
|
|
|
release_firmware(fw);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int qca_set_bdaddr_rome(struct hci_dev *hdev, const bdaddr_t *bdaddr)
|
|
{
|
|
struct sk_buff *skb;
|
|
u8 cmd[9];
|
|
int err;
|
|
|
|
cmd[0] = EDL_NVM_ACCESS_SET_REQ_CMD;
|
|
cmd[1] = 0x02; /* TAG ID */
|
|
cmd[2] = sizeof(bdaddr_t); /* size */
|
|
memcpy(cmd + 3, bdaddr, sizeof(bdaddr_t));
|
|
skb = __hci_cmd_sync_ev(hdev, EDL_NVM_ACCESS_OPCODE, sizeof(cmd), cmd,
|
|
HCI_VENDOR_PKT, HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
err = PTR_ERR(skb);
|
|
BT_ERR("%s: Change address command failed (%d)",
|
|
hdev->name, err);
|
|
return err;
|
|
}
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(qca_set_bdaddr_rome);
|
|
|
|
int qca_uart_setup_rome(struct hci_dev *hdev, uint8_t baudrate)
|
|
{
|
|
u32 rome_ver = 0;
|
|
struct rome_config config;
|
|
int err;
|
|
|
|
BT_DBG("%s: ROME setup on UART", hdev->name);
|
|
|
|
config.user_baud_rate = baudrate;
|
|
|
|
/* Get ROME version information */
|
|
err = rome_patch_ver_req(hdev, &rome_ver);
|
|
if (err < 0 || rome_ver == 0) {
|
|
BT_ERR("%s: Failed to get version 0x%x", hdev->name, err);
|
|
return err;
|
|
}
|
|
|
|
bt_dev_info(hdev, "ROME controller version 0x%08x", rome_ver);
|
|
|
|
/* Download rampatch file */
|
|
config.type = TLV_TYPE_PATCH;
|
|
snprintf(config.fwname, sizeof(config.fwname), "qca/rampatch_%08x.bin",
|
|
rome_ver);
|
|
err = rome_download_firmware(hdev, &config);
|
|
if (err < 0) {
|
|
BT_ERR("%s: Failed to download patch (%d)", hdev->name, err);
|
|
return err;
|
|
}
|
|
|
|
/* Download NVM configuration */
|
|
config.type = TLV_TYPE_NVM;
|
|
snprintf(config.fwname, sizeof(config.fwname), "qca/nvm_%08x.bin",
|
|
rome_ver);
|
|
err = rome_download_firmware(hdev, &config);
|
|
if (err < 0) {
|
|
BT_ERR("%s: Failed to download NVM (%d)", hdev->name, err);
|
|
return err;
|
|
}
|
|
|
|
/* Perform HCI reset */
|
|
err = rome_reset(hdev);
|
|
if (err < 0) {
|
|
BT_ERR("%s: Failed to run HCI_RESET (%d)", hdev->name, err);
|
|
return err;
|
|
}
|
|
|
|
bt_dev_info(hdev, "ROME setup on UART is completed");
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(qca_uart_setup_rome);
|
|
|
|
MODULE_AUTHOR("Ben Young Tae Kim <ytkim@qca.qualcomm.com>");
|
|
MODULE_DESCRIPTION("Bluetooth support for Qualcomm Atheros family ver " VERSION);
|
|
MODULE_VERSION(VERSION);
|
|
MODULE_LICENSE("GPL");
|