Commit 2bd056f5 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'for-upstream' of... 

Merge branch 'for-upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next



Johan Hedberg says:

====================
pull request: bluetooth-next 2020-09-29

Here's the main bluetooth-next pull request for 5.10:

 - Multiple fixes to suspend/resume handling
 - Added mgmt events for controller suspend/resume state
 - Improved extended advertising support
 - btintel: Enhanced support for next generation controllers
 - Added Qualcomm Bluetooth SoC WCN6855 support
 - Several other smaller fixes & improvements
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents fe38d95b b40f58b9

drivers/bluetooth/btintel.c

+285 −6
Original line number Diff line number Diff line
@@ -19,6 +19,10 @@ 
#define VERSION "0.1"



#define BDADDR_INTEL		(&(bdaddr_t){{0x00, 0x8b, 0x9e, 0x19, 0x03, 0x00}})

#define RSA_HEADER_LEN		644

#define CSS_HEADER_OFFSET	8

#define ECDSA_OFFSET		644

#define ECDSA_HEADER_LEN	320



int btintel_check_bdaddr(struct hci_dev *hdev)

{
@@ -360,6 +364,144 @@ int btintel_read_version(struct hci_dev *hdev, struct intel_version *ver) 
}

EXPORT_SYMBOL_GPL(btintel_read_version);



void btintel_version_info_tlv(struct hci_dev *hdev, struct intel_version_tlv *version)

{

	const char *variant;



	switch (version->img_type) {

	case 0x01:

		variant = "Bootloader";

		bt_dev_info(hdev, "Device revision is %u", version->dev_rev_id);

		bt_dev_info(hdev, "Secure boot is %s",

			    version->secure_boot ? "enabled" : "disabled");

		bt_dev_info(hdev, "OTP lock is %s",

			    version->otp_lock ? "enabled" : "disabled");

		bt_dev_info(hdev, "API lock is %s",

			    version->api_lock ? "enabled" : "disabled");

		bt_dev_info(hdev, "Debug lock is %s",

			    version->debug_lock ? "enabled" : "disabled");

		bt_dev_info(hdev, "Minimum firmware build %u week %u %u",

			    version->min_fw_build_nn, version->min_fw_build_cw,

			    2000 + version->min_fw_build_yy);

		break;

	case 0x03:

		variant = "Firmware";

		break;

	default:

		bt_dev_err(hdev, "Unsupported image type(%02x)", version->img_type);

		goto done;

	}



	bt_dev_info(hdev, "%s timestamp %u.%u buildtype %u build %u", variant,

		    2000 + (version->timestamp >> 8), version->timestamp & 0xff,

		    version->build_type, version->build_num);



done:

	return;

}

EXPORT_SYMBOL_GPL(btintel_version_info_tlv);



int btintel_read_version_tlv(struct hci_dev *hdev, struct intel_version_tlv *version)

{

	struct sk_buff *skb;

	const u8 param[1] = { 0xFF };



	if (!version)

		return -EINVAL;



	skb = __hci_cmd_sync(hdev, 0xfc05, 1, param, HCI_CMD_TIMEOUT);

	if (IS_ERR(skb)) {

		bt_dev_err(hdev, "Reading Intel version information failed (%ld)",

			   PTR_ERR(skb));

		return PTR_ERR(skb);

	}



	if (skb->data[0]) {

		bt_dev_err(hdev, "Intel Read Version command failed (%02x)",

			   skb->data[0]);

		kfree_skb(skb);

		return -EIO;

	}



	/* Consume Command Complete Status field */

	skb_pull(skb, 1);



	/* Event parameters contatin multiple TLVs. Read each of them

	 * and only keep the required data. Also, it use existing legacy

	 * version field like hw_platform, hw_variant, and fw_variant

	 * to keep the existing setup flow

	 */

	while (skb->len) {

		struct intel_tlv *tlv;



		tlv = (struct intel_tlv *)skb->data;

		switch (tlv->type) {

		case INTEL_TLV_CNVI_TOP:

			version->cnvi_top = get_unaligned_le32(tlv->val);

			break;

		case INTEL_TLV_CNVR_TOP:

			version->cnvr_top = get_unaligned_le32(tlv->val);

			break;

		case INTEL_TLV_CNVI_BT:

			version->cnvi_bt = get_unaligned_le32(tlv->val);

			break;

		case INTEL_TLV_CNVR_BT:

			version->cnvr_bt = get_unaligned_le32(tlv->val);

			break;

		case INTEL_TLV_DEV_REV_ID:

			version->dev_rev_id = get_unaligned_le16(tlv->val);

			break;

		case INTEL_TLV_IMAGE_TYPE:

			version->img_type = tlv->val[0];

			break;

		case INTEL_TLV_TIME_STAMP:

			version->timestamp = get_unaligned_le16(tlv->val);

			break;

		case INTEL_TLV_BUILD_TYPE:

			version->build_type = tlv->val[0];

			break;

		case INTEL_TLV_BUILD_NUM:

			version->build_num = get_unaligned_le32(tlv->val);

			break;

		case INTEL_TLV_SECURE_BOOT:

			version->secure_boot = tlv->val[0];

			break;

		case INTEL_TLV_OTP_LOCK:

			version->otp_lock = tlv->val[0];

			break;

		case INTEL_TLV_API_LOCK:

			version->api_lock = tlv->val[0];

			break;

		case INTEL_TLV_DEBUG_LOCK:

			version->debug_lock = tlv->val[0];

			break;

		case INTEL_TLV_MIN_FW:

			version->min_fw_build_nn = tlv->val[0];

			version->min_fw_build_cw = tlv->val[1];

			version->min_fw_build_yy = tlv->val[2];

			break;

		case INTEL_TLV_LIMITED_CCE:

			version->limited_cce = tlv->val[0];

			break;

		case INTEL_TLV_SBE_TYPE:

			version->sbe_type = tlv->val[0];

			break;

		case INTEL_TLV_OTP_BDADDR:

			memcpy(&version->otp_bd_addr, tlv->val, tlv->len);

			break;

		default:

			/* Ignore rest of information */

			break;

		}

		/* consume the current tlv and move to next*/

		skb_pull(skb, tlv->len + sizeof(*tlv));

	}



	kfree_skb(skb);

	return 0;

}

EXPORT_SYMBOL_GPL(btintel_read_version_tlv);



/* ------- REGMAP IBT SUPPORT ------- */



#define IBT_REG_MODE_8BIT  0x00
@@ -626,12 +768,10 @@ int btintel_read_boot_params(struct hci_dev *hdev, 
}

EXPORT_SYMBOL_GPL(btintel_read_boot_params);



int btintel_download_firmware(struct hci_dev *hdev, const struct firmware *fw,

			      u32 *boot_param)

static int btintel_sfi_rsa_header_secure_send(struct hci_dev *hdev,

					      const struct firmware *fw)

{

	int err;

	const u8 *fw_ptr;

	u32 frag_len;



	/* Start the firmware download transaction with the Init fragment

	 * represented by the 128 bytes of CSS header.
@@ -660,8 +800,56 @@ int btintel_download_firmware(struct hci_dev *hdev, const struct firmware *fw, 
		goto done;

	}



	fw_ptr = fw->data + 644;

done:

	return err;

}



static int btintel_sfi_ecdsa_header_secure_send(struct hci_dev *hdev,

						const struct firmware *fw)

{

	int err;



	/* Start the firmware download transaction with the Init fragment

	 * represented by the 128 bytes of CSS header.

	 */

	err = btintel_secure_send(hdev, 0x00, 128, fw->data + 644);

	if (err < 0) {

		bt_dev_err(hdev, "Failed to send firmware header (%d)", err);

		return err;

	}



	/* Send the 96 bytes of public key information from the firmware

	 * as the PKey fragment.

	 */

	err = btintel_secure_send(hdev, 0x03, 96, fw->data + 644 + 128);

	if (err < 0) {

		bt_dev_err(hdev, "Failed to send firmware pkey (%d)", err);

		return err;

	}



	/* Send the 96 bytes of signature information from the firmware

	 * as the Sign fragment

	 */

	err = btintel_secure_send(hdev, 0x02, 96, fw->data + 644 + 224);

	if (err < 0) {

		bt_dev_err(hdev, "Failed to send firmware signature (%d)",

			   err);

		return err;

	}

	return 0;

}



static int btintel_download_firmware_payload(struct hci_dev *hdev,

					     const struct firmware *fw,

					     u32 *boot_param, size_t offset)

{

	int err;

	const u8 *fw_ptr;

	u32 frag_len;



	fw_ptr = fw->data + offset;

	frag_len = 0;

	err = -EINVAL;



	while (fw_ptr - fw->data < fw->size) {

		struct hci_command_hdr *cmd = (void *)(fw_ptr + frag_len);
@@ -707,8 +895,99 @@ int btintel_download_firmware(struct hci_dev *hdev, const struct firmware *fw, 
done:

	return err;

}



int btintel_download_firmware(struct hci_dev *hdev,

			      const struct firmware *fw,

			      u32 *boot_param)

{

	int err;



	err = btintel_sfi_rsa_header_secure_send(hdev, fw);

	if (err)

		return err;



	return btintel_download_firmware_payload(hdev, fw, boot_param,

						 RSA_HEADER_LEN);

}

EXPORT_SYMBOL_GPL(btintel_download_firmware);



int btintel_download_firmware_newgen(struct hci_dev *hdev,

				     const struct firmware *fw, u32 *boot_param,

				     u8 hw_variant, u8 sbe_type)

{

	int err;

	u32 css_header_ver;



	/* iBT hardware variants 0x0b, 0x0c, 0x11, 0x12, 0x13, 0x14 support

	 * only RSA secure boot engine. Hence, the corresponding sfi file will

	 * have RSA header of 644 bytes followed by Command Buffer.

	 *

	 * iBT hardware variants 0x17, 0x18 onwards support both RSA and ECDSA

	 * secure boot engine. As a result, the corresponding sfi file will

	 * have RSA header of 644, ECDSA header of 320 bytes followed by

	 * Command Buffer.

	 *

	 * CSS Header byte positions 0x08 to 0x0B represent the CSS Header

	 * version: RSA(0x00010000) , ECDSA (0x00020000)

	 */

	css_header_ver = get_unaligned_le32(fw->data + CSS_HEADER_OFFSET);

	if (css_header_ver != 0x00010000) {

		bt_dev_err(hdev, "Invalid CSS Header version");

		return -EINVAL;

	}



	if (hw_variant <= 0x14) {

		if (sbe_type != 0x00) {

			bt_dev_err(hdev, "Invalid SBE type for hardware variant (%d)",

				   hw_variant);

			return -EINVAL;

		}



		err = btintel_sfi_rsa_header_secure_send(hdev, fw);

		if (err)

			return err;



		err = btintel_download_firmware_payload(hdev, fw, boot_param, RSA_HEADER_LEN);

		if (err)

			return err;

	} else if (hw_variant >= 0x17) {

		/* Check if CSS header for ECDSA follows the RSA header */

		if (fw->data[ECDSA_OFFSET] != 0x06)

			return -EINVAL;



		/* Check if the CSS Header version is ECDSA(0x00020000) */

		css_header_ver = get_unaligned_le32(fw->data + ECDSA_OFFSET + CSS_HEADER_OFFSET);

		if (css_header_ver != 0x00020000) {

			bt_dev_err(hdev, "Invalid CSS Header version");

			return -EINVAL;

		}



		if (sbe_type == 0x00) {

			err = btintel_sfi_rsa_header_secure_send(hdev, fw);

			if (err)

				return err;



			err = btintel_download_firmware_payload(hdev, fw,

								boot_param,

								RSA_HEADER_LEN + ECDSA_HEADER_LEN);

			if (err)

				return err;

		} else if (sbe_type == 0x01) {

			err = btintel_sfi_ecdsa_header_secure_send(hdev, fw);

			if (err)

				return err;



			err = btintel_download_firmware_payload(hdev, fw,

								boot_param,

								RSA_HEADER_LEN + ECDSA_HEADER_LEN);

			if (err)

				return err;

		}

	}

	return 0;

}

EXPORT_SYMBOL_GPL(btintel_download_firmware_newgen);



void btintel_reset_to_bootloader(struct hci_dev *hdev)

{

	struct intel_reset params;

drivers/bluetooth/btintel.h

+91 −0
Original line number Diff line number Diff line
@@ -6,6 +6,72 @@ 
 *  Copyright (C) 2015  Intel Corporation

 */



/* List of tlv type */

enum {

	INTEL_TLV_CNVI_TOP = 0x10,

	INTEL_TLV_CNVR_TOP,

	INTEL_TLV_CNVI_BT,

	INTEL_TLV_CNVR_BT,

	INTEL_TLV_CNVI_OTP,

	INTEL_TLV_CNVR_OTP,

	INTEL_TLV_DEV_REV_ID,

	INTEL_TLV_USB_VENDOR_ID,

	INTEL_TLV_USB_PRODUCT_ID,

	INTEL_TLV_PCIE_VENDOR_ID,

	INTEL_TLV_PCIE_DEVICE_ID,

	INTEL_TLV_PCIE_SUBSYSTEM_ID,

	INTEL_TLV_IMAGE_TYPE,

	INTEL_TLV_TIME_STAMP,

	INTEL_TLV_BUILD_TYPE,

	INTEL_TLV_BUILD_NUM,

	INTEL_TLV_FW_BUILD_PRODUCT,

	INTEL_TLV_FW_BUILD_HW,

	INTEL_TLV_FW_STEP,

	INTEL_TLV_BT_SPEC,

	INTEL_TLV_MFG_NAME,

	INTEL_TLV_HCI_REV,

	INTEL_TLV_LMP_SUBVER,

	INTEL_TLV_OTP_PATCH_VER,

	INTEL_TLV_SECURE_BOOT,

	INTEL_TLV_KEY_FROM_HDR,

	INTEL_TLV_OTP_LOCK,

	INTEL_TLV_API_LOCK,

	INTEL_TLV_DEBUG_LOCK,

	INTEL_TLV_MIN_FW,

	INTEL_TLV_LIMITED_CCE,

	INTEL_TLV_SBE_TYPE,

	INTEL_TLV_OTP_BDADDR,

	INTEL_TLV_UNLOCKED_STATE

};



struct intel_tlv {

	u8 type;

	u8 len;

	u8 val[0];

} __packed;



struct intel_version_tlv {

	u32	cnvi_top;

	u32	cnvr_top;

	u32	cnvi_bt;

	u32	cnvr_bt;

	u16	dev_rev_id;

	u8	img_type;

	u16	timestamp;

	u8	build_type;

	u32	build_num;

	u8	secure_boot;

	u8	otp_lock;

	u8	api_lock;

	u8	debug_lock;

	u8	min_fw_build_nn;

	u8	min_fw_build_cw;

	u8	min_fw_build_yy;

	u8	limited_cce;

	u8	sbe_type;

	bdaddr_t otp_bd_addr;

};



struct intel_version {

	u8 status;

	u8 hw_platform;
@@ -77,12 +143,14 @@ int btintel_set_diag_mfg(struct hci_dev *hdev, bool enable); 
void btintel_hw_error(struct hci_dev *hdev, u8 code);



void btintel_version_info(struct hci_dev *hdev, struct intel_version *ver);

void btintel_version_info_tlv(struct hci_dev *hdev, struct intel_version_tlv *version);

int btintel_secure_send(struct hci_dev *hdev, u8 fragment_type, u32 plen,

			const void *param);

int btintel_load_ddc_config(struct hci_dev *hdev, const char *ddc_name);

int btintel_set_event_mask(struct hci_dev *hdev, bool debug);

int btintel_set_event_mask_mfg(struct hci_dev *hdev, bool debug);

int btintel_read_version(struct hci_dev *hdev, struct intel_version *ver);

int btintel_read_version_tlv(struct hci_dev *hdev, struct intel_version_tlv *ver);



struct regmap *btintel_regmap_init(struct hci_dev *hdev, u16 opcode_read,

				   u16 opcode_write);
@@ -91,6 +159,10 @@ int btintel_read_boot_params(struct hci_dev *hdev, 
			     struct intel_boot_params *params);

int btintel_download_firmware(struct hci_dev *dev, const struct firmware *fw,

			      u32 *boot_param);

int btintel_download_firmware_newgen(struct hci_dev *hdev,

				     const struct firmware *fw,

				     u32 *boot_param, u8 hw_variant,

				     u8 sbe_type);

void btintel_reset_to_bootloader(struct hci_dev *hdev);

int btintel_read_debug_features(struct hci_dev *hdev,

				struct intel_debug_features *features);
@@ -137,6 +209,11 @@ static inline void btintel_version_info(struct hci_dev *hdev, 
{

}



static inline void btintel_version_info_tlv(struct hci_dev *hdev,

					    struct intel_version_tlv *version)

{

}



static inline int btintel_secure_send(struct hci_dev *hdev, u8 fragment_type,

				      u32 plen, const void *param)

{
@@ -165,6 +242,12 @@ static inline int btintel_read_version(struct hci_dev *hdev, 
	return -EOPNOTSUPP;

}



static inline int btintel_read_version_tlv(struct hci_dev *hdev,

					   struct intel_version_tlv *ver)

{

	return -EOPNOTSUPP;

}



static inline struct regmap *btintel_regmap_init(struct hci_dev *hdev,

						 u16 opcode_read,

						 u16 opcode_write)
@@ -191,6 +274,14 @@ static inline int btintel_download_firmware(struct hci_dev *dev, 
	return -EOPNOTSUPP;

}



static inline int btintel_download_firmware_newgen(struct hci_dev *hdev,

						   const struct firmware *fw,

						   u32 *boot_param,

						   u8 hw_variant, u8 sbe_type)

{

	return -EOPNOTSUPP;

}



static inline void btintel_reset_to_bootloader(struct hci_dev *hdev)

{

}

drivers/bluetooth/btmrvl_sdio.c

+4 −50
Original line number Diff line number Diff line
@@ -215,30 +215,7 @@ static const struct btmrvl_sdio_card_reg btmrvl_reg_8897 = { 
	.fw_dump_end = 0xea,

};



static const struct btmrvl_sdio_card_reg btmrvl_reg_8977 = {

	.cfg = 0x00,

	.host_int_mask = 0x08,

	.host_intstatus = 0x0c,

	.card_status = 0x5c,

	.sq_read_base_addr_a0 = 0xf8,

	.sq_read_base_addr_a1 = 0xf9,

	.card_revision = 0xc8,

	.card_fw_status0 = 0xe8,

	.card_fw_status1 = 0xe9,

	.card_rx_len = 0xea,

	.card_rx_unit = 0xeb,

	.io_port_0 = 0xe4,

	.io_port_1 = 0xe5,

	.io_port_2 = 0xe6,

	.int_read_to_clear = true,

	.host_int_rsr = 0x04,

	.card_misc_cfg = 0xD8,

	.fw_dump_ctrl = 0xf0,

	.fw_dump_start = 0xf1,

	.fw_dump_end = 0xf8,

};



static const struct btmrvl_sdio_card_reg btmrvl_reg_8987 = {

static const struct btmrvl_sdio_card_reg btmrvl_reg_89xx = {

	.cfg = 0x00,

	.host_int_mask = 0x08,

	.host_intstatus = 0x0c,
@@ -261,29 +238,6 @@ static const struct btmrvl_sdio_card_reg btmrvl_reg_8987 = { 
	.fw_dump_end = 0xf8,

};



static const struct btmrvl_sdio_card_reg btmrvl_reg_8997 = {

	.cfg = 0x00,

	.host_int_mask = 0x08,

	.host_intstatus = 0x0c,

	.card_status = 0x5c,

	.sq_read_base_addr_a0 = 0xf8,

	.sq_read_base_addr_a1 = 0xf9,

	.card_revision = 0xc8,

	.card_fw_status0 = 0xe8,

	.card_fw_status1 = 0xe9,

	.card_rx_len = 0xea,

	.card_rx_unit = 0xeb,

	.io_port_0 = 0xe4,

	.io_port_1 = 0xe5,

	.io_port_2 = 0xe6,

	.int_read_to_clear = true,

	.host_int_rsr = 0x04,

	.card_misc_cfg = 0xD8,

	.fw_dump_ctrl = 0xf0,

	.fw_dump_start = 0xf1,

	.fw_dump_end = 0xf8,

};



static const struct btmrvl_sdio_device btmrvl_sdio_sd8688 = {

	.helper		= "mrvl/sd8688_helper.bin",

	.firmware	= "mrvl/sd8688.bin",
@@ -332,7 +286,7 @@ static const struct btmrvl_sdio_device btmrvl_sdio_sd8897 = { 
static const struct btmrvl_sdio_device btmrvl_sdio_sd8977 = {

	.helper         = NULL,

	.firmware       = "mrvl/sdsd8977_combo_v2.bin",

	.reg            = &btmrvl_reg_8977,

	.reg            = &btmrvl_reg_89xx,

	.support_pscan_win_report = true,

	.sd_blksz_fw_dl = 256,

	.supports_fw_dump = true,
@@ -341,7 +295,7 @@ static const struct btmrvl_sdio_device btmrvl_sdio_sd8977 = { 
static const struct btmrvl_sdio_device btmrvl_sdio_sd8987 = {

	.helper		= NULL,

	.firmware	= "mrvl/sd8987_uapsta.bin",

	.reg		= &btmrvl_reg_8987,

	.reg		= &btmrvl_reg_89xx,

	.support_pscan_win_report = true,

	.sd_blksz_fw_dl	= 256,

	.supports_fw_dump = true,
@@ -350,7 +304,7 @@ static const struct btmrvl_sdio_device btmrvl_sdio_sd8987 = { 
static const struct btmrvl_sdio_device btmrvl_sdio_sd8997 = {

	.helper         = NULL,

	.firmware       = "mrvl/sdsd8997_combo_v4.bin",

	.reg            = &btmrvl_reg_8997,

	.reg            = &btmrvl_reg_89xx,

	.support_pscan_win_report = true,

	.sd_blksz_fw_dl = 256,

	.supports_fw_dump = true,

drivers/bluetooth/btmtksdio.c

+2 −2
Original line number Diff line number Diff line
@@ -496,7 +496,7 @@ static void btmtksdio_interrupt(struct sdio_func *func) 
	sdio_claim_host(bdev->func);



	/* Disable interrupt */

	sdio_writel(func, C_INT_EN_CLR, MTK_REG_CHLPCR, 0);

	sdio_writel(func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);



	int_status = sdio_readl(func, MTK_REG_CHISR, NULL);
@@ -530,7 +530,7 @@ static void btmtksdio_interrupt(struct sdio_func *func) 
	}



	/* Enable interrupt */

	sdio_writel(func, C_INT_EN_SET, MTK_REG_CHLPCR, 0);

	sdio_writel(func, C_INT_EN_SET, MTK_REG_CHLPCR, NULL);



	pm_runtime_mark_last_busy(bdev->dev);

	pm_runtime_put_autosuspend(bdev->dev);

drivers/bluetooth/btusb.c

+94 −35
Original line number Diff line number Diff line
@@ -59,6 +59,7 @@ static struct usb_driver btusb_driver; 
#define BTUSB_MEDIATEK		0x200000

#define BTUSB_WIDEBAND_SPEECH	0x400000

#define BTUSB_VALID_LE_STATES   0x800000

#define BTUSB_QCA_WCN6855	0x1000000



static const struct usb_device_id btusb_table[] = {

	/* Generic Bluetooth USB device */
@@ -254,24 +255,46 @@ static const struct usb_device_id blacklist_table[] = { 
	{ USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 },



	/* QCA ROME chipset */

	{ USB_DEVICE(0x0cf3, 0x535b), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x0cf3, 0xe007), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x0cf3, 0xe009), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x0cf3, 0xe010), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x0cf3, 0xe300), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x0cf3, 0xe301), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x0cf3, 0xe360), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x0489, 0xe092), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x0489, 0xe09f), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x0489, 0xe0a2), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x04ca, 0x3011), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x04ca, 0x3015), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x04ca, 0x3016), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x04ca, 0x301a), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x04ca, 0x3021), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x13d3, 0x3491), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x13d3, 0x3496), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x13d3, 0x3501), .driver_info = BTUSB_QCA_ROME },

	{ USB_DEVICE(0x0cf3, 0x535b), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x0cf3, 0xe007), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x0cf3, 0xe009), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x0cf3, 0xe010), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x0cf3, 0xe300), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x0cf3, 0xe301), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x0cf3, 0xe360), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x0489, 0xe092), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x0489, 0xe09f), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x0489, 0xe0a2), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x04ca, 0x3011), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x04ca, 0x3015), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x04ca, 0x3016), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x04ca, 0x301a), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x04ca, 0x3021), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x13d3, 0x3491), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x13d3, 0x3496), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x13d3, 0x3501), .driver_info = BTUSB_QCA_ROME |

						     BTUSB_WIDEBAND_SPEECH },



	/* QCA WCN6855 chipset */

	{ USB_DEVICE(0x0cf3, 0xe600), .driver_info = BTUSB_QCA_WCN6855 |

						     BTUSB_WIDEBAND_SPEECH },



	/* Broadcom BCM2035 */

	{ USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },
@@ -2338,10 +2361,10 @@ static bool btusb_setup_intel_new_get_fw_name(struct intel_version *ver, 


static int btusb_intel_download_firmware(struct hci_dev *hdev,

					 struct intel_version *ver,

					 struct intel_boot_params *params)

					 struct intel_boot_params *params,

					 u32 *boot_param)

{

	const struct firmware *fw;

	u32 boot_param;

	char fwname[64];

	int err;

	struct btusb_data *data = hci_get_drvdata(hdev);
@@ -2479,7 +2502,7 @@ static int btusb_intel_download_firmware(struct hci_dev *hdev, 
	set_bit(BTUSB_DOWNLOADING, &data->flags);



	/* Start firmware downloading and get boot parameter */

	err = btintel_download_firmware(hdev, fw, &boot_param);

	err = btintel_download_firmware(hdev, fw, boot_param);

	if (err < 0) {

		/* When FW download fails, send Intel Reset to retry

		 * FW download.
@@ -2561,7 +2584,7 @@ static int btusb_setup_intel_new(struct hci_dev *hdev) 
		return err;

	}



	err = btusb_intel_download_firmware(hdev, &ver, &params);

	err = btusb_intel_download_firmware(hdev, &ver, &params, &boot_param);

	if (err)

		return err;
@@ -2896,6 +2919,7 @@ static int btusb_mtk_submit_wmt_recv_urb(struct hci_dev *hdev) 
	buf = kmalloc(size, GFP_KERNEL);

	if (!buf) {

		kfree(dr);

		usb_free_urb(urb);

		return -ENOMEM;

	}
@@ -3390,6 +3414,27 @@ static int btusb_set_bdaddr_ath3012(struct hci_dev *hdev, 
	return 0;

}



static int btusb_set_bdaddr_wcn6855(struct hci_dev *hdev,

				const bdaddr_t *bdaddr)

{

	struct sk_buff *skb;

	u8 buf[6];

	long ret;



	memcpy(buf, bdaddr, sizeof(bdaddr_t));



	skb = __hci_cmd_sync_ev(hdev, 0xfc14, sizeof(buf), buf,

				HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);

	if (IS_ERR(skb)) {

		ret = PTR_ERR(skb);

		bt_dev_err(hdev, "Change address command failed (%ld)", ret);

		return ret;

	}

	kfree_skb(skb);



	return 0;

}



#define QCA_DFU_PACKET_LEN	4096



#define QCA_GET_TARGET_VERSION	0x09
@@ -3409,7 +3454,8 @@ struct qca_version { 
} __packed;



struct qca_rampatch_version {

	__le16	rom_version;

	__le16	rom_version_high;

	__le16  rom_version_low;

	__le16	patch_version;

} __packed;
@@ -3421,12 +3467,14 @@ struct qca_device_info { 
};



static const struct qca_device_info qca_devices_table[] = {

	{ 0x00000100, 20, 4, 10 }, /* Rome 1.0 */

	{ 0x00000101, 20, 4, 10 }, /* Rome 1.1 */

	{ 0x00000200, 28, 4, 18 }, /* Rome 2.0 */

	{ 0x00000201, 28, 4, 18 }, /* Rome 2.1 */

	{ 0x00000300, 28, 4, 18 }, /* Rome 3.0 */

	{ 0x00000302, 28, 4, 18 }, /* Rome 3.2 */

	{ 0x00000100, 20, 4,  8 }, /* Rome 1.0 */

	{ 0x00000101, 20, 4,  8 }, /* Rome 1.1 */

	{ 0x00000200, 28, 4, 16 }, /* Rome 2.0 */

	{ 0x00000201, 28, 4, 16 }, /* Rome 2.1 */

	{ 0x00000300, 28, 4, 16 }, /* Rome 3.0 */

	{ 0x00000302, 28, 4, 16 }, /* Rome 3.2 */

	{ 0x00130100, 40, 4, 16 }, /* WCN6855 1.0 */

	{ 0x00130200, 40, 4, 16 }, /* WCN6855 2.0 */

};



static int btusb_qca_send_vendor_req(struct usb_device *udev, u8 request,
@@ -3528,8 +3576,8 @@ static int btusb_setup_qca_load_rampatch(struct hci_dev *hdev, 
{

	struct qca_rampatch_version *rver;

	const struct firmware *fw;

	u32 ver_rom, ver_patch;

	u16 rver_rom, rver_patch;

	u32 ver_rom, ver_patch, rver_rom;

	u16 rver_rom_low, rver_rom_high, rver_patch;

	char fwname[64];

	int err;
@@ -3548,9 +3596,16 @@ static int btusb_setup_qca_load_rampatch(struct hci_dev *hdev, 
	bt_dev_info(hdev, "using rampatch file: %s", fwname);



	rver = (struct qca_rampatch_version *)(fw->data + info->ver_offset);

	rver_rom = le16_to_cpu(rver->rom_version);

	rver_rom_low = le16_to_cpu(rver->rom_version_low);

	rver_patch = le16_to_cpu(rver->patch_version);



	if (ver_rom & ~0xffffU) {

		rver_rom_high = le16_to_cpu(rver->rom_version_high);

		rver_rom = le32_to_cpu(rver_rom_high << 16 | rver_rom_low);

	} else {

		rver_rom = rver_rom_low;

	}



	bt_dev_info(hdev, "QCA: patch rome 0x%x build 0x%x, "

		    "firmware rome 0x%x build 0x%x",

		    rver_rom, rver_patch, ver_rom, ver_patch);
@@ -3624,9 +3679,6 @@ static int btusb_setup_qca(struct hci_dev *hdev) 
		return err;



	ver_rom = le32_to_cpu(ver.rom_version);

	/* Don't care about high ROM versions */

	if (ver_rom & ~0xffffU)

		return 0;



	for (i = 0; i < ARRAY_SIZE(qca_devices_table); i++) {

		if (ver_rom == qca_devices_table[i].rom_version)
@@ -4062,6 +4114,13 @@ static int btusb_probe(struct usb_interface *intf, 
		btusb_check_needs_reset_resume(intf);

	}



	if (id->driver_info & BTUSB_QCA_WCN6855) {

		data->setup_on_usb = btusb_setup_qca;

		hdev->set_bdaddr = btusb_set_bdaddr_wcn6855;

		hdev->cmd_timeout = btusb_qca_cmd_timeout;

		set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);

	}



	if (id->driver_info & BTUSB_AMP) {

		/* AMP controllers do not support SCO packets */

		data->isoc = NULL;

CRA Git | Maintained and supported by SUSTech CRA and CCSE