Merge "cnss2: Update driver to support multiple devices" (18b2685b) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/net/wireless/cnss2/bus.c

+49 −5

Original line number	Diff line number	Diff line
		@@ -19,18 +19,39 @@ enum cnss_dev_bus_type cnss_get_dev_bus_type(struct device *dev)
		return CNSS_BUS_NONE;
		}

		enum cnss_dev_bus_type cnss_get_bus_type(unsigned long device_id)
		{
		switch (device_id) {
		enum cnss_dev_bus_type cnss_get_bus_type(struct cnss_plat_data *plat_priv)
		{
		int ret;
		struct device *dev;
		enum cnss_dev_bus_type bus_type = CNSS_BUS_NONE;

		if (plat_priv->is_converged_dt) {
		dev = &plat_priv->plat_dev->dev;
		ret = of_property_read_u32(dev->of_node, "qcom,bus-type",
		&bus_type);
		if (!ret && bus_type <= CNSS_BUS_USB)
		cnss_pr_dbg("Got bus type[%u] from dt\n", bus_type);
		else
		cnss_pr_err("No bus type for converged dt\n");

		return bus_type;
		}

		/* Get bus type according to device id if it's not converged DT */
		switch (plat_priv->device_id) {
		case QCA6174_DEVICE_ID:
		case QCA6290_DEVICE_ID:
		case QCA6390_DEVICE_ID:
		case QCN7605_DEVICE_ID:
		case QCA6490_DEVICE_ID:
		return CNSS_BUS_PCI;
		bus_type = CNSS_BUS_PCI;
		break;
		default:
		cnss_pr_err("Unknown device_id: 0x%lx\n", device_id);
		return CNSS_BUS_NONE;
		cnss_pr_err("Unknown device: 0x%lx\n", plat_priv->device_id);
		break;
		}

		return bus_type;
		}

		void cnss_bus_dev_to_bus_priv(struct device dev)
		@@ -544,3 +565,26 @@ int cnss_bus_get_iova_ipa(struct cnss_plat_data plat_priv, u64 addr,
		return -EINVAL;
		}
		}

		int cnss_bus_get_msi_assignment(struct cnss_plat_data *plat_priv,
		char *msi_name,
		int *num_vectors,
		u32 *user_base_data,
		u32 *base_vector)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_get_user_msi_assignment(plat_priv->bus_priv,
		msi_name,
		num_vectors,
		user_base_data,
		base_vector);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

drivers/net/wireless/cnss2/bus.h

+8 −1

Original line number	Diff line number	Diff line
		@@ -15,13 +15,15 @@
		#define QCA6290_DEVICE_ID 0x1100
		#define QCA6390_VENDOR_ID 0x17CB
		#define QCA6390_DEVICE_ID 0x1101
		#define QCN7605_VENDOR_ID 0x17CB
		#define QCN7605_DEVICE_ID 0x1102
		#define QCA6490_VENDOR_ID 0x17CB
		#define QCA6490_DEVICE_ID 0x1103
		#define WCN7850_VENDOR_ID 0x17CB
		#define WCN7850_DEVICE_ID 0x1107

		enum cnss_dev_bus_type cnss_get_dev_bus_type(struct device *dev);
		enum cnss_dev_bus_type cnss_get_bus_type(unsigned long device_id);
		enum cnss_dev_bus_type cnss_get_bus_type(struct cnss_plat_data *plat_priv);
		void cnss_bus_dev_to_bus_priv(struct device dev);
		struct cnss_plat_data cnss_bus_dev_to_plat_priv(struct device dev);
		int cnss_bus_init(struct cnss_plat_data *plat_priv);
		@@ -62,4 +64,9 @@ int cnss_bus_debug_reg_write(struct cnss_plat_data *plat_priv, u32 offset,
		int cnss_bus_get_iova(struct cnss_plat_data plat_priv, u64 addr, u64 *size);
		int cnss_bus_get_iova_ipa(struct cnss_plat_data plat_priv, u64 addr,
		u64 *size);
		int cnss_bus_get_msi_assignment(struct cnss_plat_data *plat_priv,
		char *msi_name,
		int *num_vectors,
		u32 *user_base_data,
		u32 *base_vector);
		#endif /* _CNSS_BUS_H */

drivers/net/wireless/cnss2/main.c

+35 −7

Original line number	Diff line number	Diff line
		@@ -301,6 +301,9 @@ int cnss_wlan_enable(struct device *dev,
		if (mode == CNSS_WALTEST \|\| mode == CNSS_CCPM)
		goto skip_cfg;

		if (plat_priv->device_id == QCN7605_DEVICE_ID)
		config->send_msi_ce = true;

		ret = cnss_wlfw_wlan_cfg_send_sync(plat_priv, config, host_version);
		if (ret)
		goto out;
		@@ -435,11 +438,17 @@ static int cnss_fw_mem_ready_hdlr(struct cnss_plat_data *plat_priv)

		cnss_wlfw_bdf_dnld_send_sync(plat_priv, CNSS_BDF_REGDB);

		if (plat_priv->device_id == QCN7605_DEVICE_ID)
		plat_priv->ctrl_params.bdf_type = CNSS_BDF_BIN;

		ret = cnss_wlfw_bdf_dnld_send_sync(plat_priv,
		plat_priv->ctrl_params.bdf_type);
		if (ret)
		goto out;

		if (plat_priv->device_id == QCN7605_DEVICE_ID)
		return 0;

		ret = cnss_bus_load_m3(plat_priv);
		if (ret)
		goto out;
		@@ -1596,8 +1605,13 @@ static int cnss_cold_boot_cal_done_hdlr(struct cnss_plat_data *plat_priv,
		cnss_wlfw_wlan_mode_send_sync(plat_priv, CNSS_OFF);
		cnss_bus_free_qdss_mem(plat_priv);
		cnss_release_antenna_sharing(plat_priv);
		if (plat_priv->device_id == QCN7605_DEVICE_ID)
		goto skip_shutdown;

		cnss_bus_dev_shutdown(plat_priv);
		msleep(COLD_BOOT_CAL_SHUTDOWN_DELAY_MS);

		skip_shutdown:
		complete(&plat_priv->cal_complete);
		clear_bit(CNSS_IN_COLD_BOOT_CAL, &plat_priv->driver_state);
		set_bit(CNSS_COLD_BOOT_CAL_DONE, &plat_priv->driver_state);
		@@ -2183,7 +2197,7 @@ static int cnss_register_ramdump_v1(struct cnss_plat_data *plat_priv)
		dev = &plat_priv->plat_dev->dev;
		ramdump_info = &plat_priv->ramdump_info;

		if (of_property_read_u32(dev->of_node, "qcom,wlan-ramdump-dynamic",
		if (of_property_read_u32(plat_priv->dev_node, "qcom,wlan-ramdump-dynamic",
		&ramdump_size) == 0) {
		ramdump_info->ramdump_va =
		dma_alloc_coherent(dev, ramdump_size,
		@@ -2261,13 +2275,13 @@ static int cnss_register_ramdump_v2(struct cnss_plat_data *plat_priv)
		struct cnss_ramdump_info_v2 *info_v2;
		struct cnss_dump_data *dump_data;
		struct msm_dump_entry dump_entry;
		struct device *dev = &plat_priv->plat_dev->dev;
		u32 ramdump_size = 0;

		info_v2 = &plat_priv->ramdump_info_v2;
		dump_data = &info_v2->dump_data;

		if (of_property_read_u32(dev->of_node, "qcom,wlan-ramdump-dynamic",
		if (of_property_read_u32(plat_priv->dev_node,
		"qcom,wlan-ramdump-dynamic",
		&ramdump_size) == 0)
		info_v2->ramdump_size = ramdump_size;

		@@ -2334,6 +2348,7 @@ int cnss_register_ramdump(struct cnss_plat_data *plat_priv)
		break;
		case QCA6290_DEVICE_ID:
		case QCA6390_DEVICE_ID:
		case QCN7605_DEVICE_ID:
		case QCA6490_DEVICE_ID:
		case WCN7850_DEVICE_ID:
		ret = cnss_register_ramdump_v2(plat_priv);
		@@ -2354,6 +2369,7 @@ void cnss_unregister_ramdump(struct cnss_plat_data *plat_priv)
		break;
		case QCA6290_DEVICE_ID:
		case QCA6390_DEVICE_ID:
		case QCN7605_DEVICE_ID:
		case QCA6490_DEVICE_ID:
		case WCN7850_DEVICE_ID:
		cnss_unregister_ramdump_v2(plat_priv);
		@@ -2477,7 +2493,7 @@ int cnss_minidump_remove_region(struct cnss_plat_data *plat_priv,
		* For different interconnect path configured in device tree setup voting data
		* for list of bandwidth requirements.
		*
		* Result: 0 for success. -EINVAL if not configured
		* Result: 0 for success. -ENOMEM if cannot allocate memory
		*/
		static int cnss_register_bus_scale(struct cnss_plat_data *plat_priv)
		{
		@@ -2491,8 +2507,8 @@ static int cnss_register_bus_scale(struct cnss_plat_data *plat_priv)
		"qcom,icc-path-count",
		&plat_priv->icc.path_count);
		if (ret) {
		cnss_pr_err("Platform Bus Interconnect path not configured\n");
		return -EINVAL;
		cnss_pr_dbg("Platform Bus Interconnect path not configured\n");
		return 0;
		}
		ret = of_property_read_u32(plat_priv->plat_dev->dev.of_node,
		"qcom,bus-bw-cfg-count",
		@@ -2967,6 +2983,7 @@ static const struct platform_device_id cnss_platform_id_table[] = {
		{ .name = "qca6390", .driver_data = QCA6390_DEVICE_ID, },
		{ .name = "qca6490", .driver_data = QCA6490_DEVICE_ID, },
		{ .name = "wcn7850", .driver_data = WCN7850_DEVICE_ID, },
		{ .name = "qcaconv", .driver_data = 0},
		{ },
		};

		@@ -2986,6 +3003,9 @@ static const struct of_device_id cnss_of_match_table[] = {
		{
		.compatible = "qcom,cnss-wcn7850",
		.data = (void *)&cnss_platform_id_table[4]},
		{
		.compatible = "qcom,cnss-qca-converged",
		.data = (void *)&cnss_platform_id_table[5]},
		{ },
		};
		MODULE_DEVICE_TABLE(of, cnss_of_match_table);
		@@ -2997,6 +3017,12 @@ cnss_use_nv_mac(struct cnss_plat_data *plat_priv)
		"use-nv-mac");
		}

		static inline bool
		cnss_is_converged_dt(struct cnss_plat_data *plat_priv)
		{
		return of_property_read_bool(plat_priv->plat_dev->dev.of_node,
		"qcom,converged-dt");
		}
		static int cnss_probe(struct platform_device *plat_dev)
		{
		int ret = 0;
		@@ -3028,7 +3054,9 @@ static int cnss_probe(struct platform_device *plat_dev)

		plat_priv->plat_dev = plat_dev;
		plat_priv->device_id = device_id->driver_data;
		plat_priv->bus_type = cnss_get_bus_type(plat_priv->device_id);
		plat_priv->is_converged_dt = cnss_is_converged_dt(plat_priv);
		plat_priv->dev_node = plat_priv->plat_dev->dev.of_node;
		plat_priv->bus_type = cnss_get_bus_type(plat_priv);
		plat_priv->use_nv_mac = cnss_use_nv_mac(plat_priv);
		plat_priv->use_fw_path_with_prefix =
		cnss_use_fw_path_with_prefix(plat_priv);

drivers/net/wireless/cnss2/main.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -54,6 +54,7 @@
		enum cnss_dev_bus_type {
		CNSS_BUS_NONE = -1,
		CNSS_BUS_PCI,
		CNSS_BUS_USB,
		};

		struct cnss_vreg_cfg {
		@@ -493,6 +494,8 @@ struct cnss_plat_data {
		struct cnss_dms_data dms;
		int power_up_error;
		u32 hw_trc_override;
		u32 is_converged_dt;
		struct device_node *dev_node;
		};

		#ifdef CONFIG_ARCH_QCOM
		@@ -558,5 +561,5 @@ int cnss_enable_int_pow_amp_vreg(struct cnss_plat_data *plat_priv);
		int cnss_get_tcs_info(struct cnss_plat_data *plat_priv);
		unsigned int cnss_get_timeout(struct cnss_plat_data *plat_priv,
		enum cnss_timeout_type);

		int cnss_dev_specific_power_on(struct cnss_plat_data *plat_priv);
		#endif /* _CNSS_MAIN_H */

drivers/net/wireless/cnss2/pci.c

+126 −15

Original line number	Diff line number	Diff line
		@@ -7,6 +7,7 @@
		#include <linux/irq.h>
		#include <linux/module.h>
		#include <linux/msi.h>
		#include <linux/of_address.h>
		#include <linux/of.h>
		#include <linux/of_gpio.h>
		#include <linux/of_reserved_mem.h>
		@@ -43,6 +44,7 @@
		#define QCA6390_PATH_PREFIX "qca6390/"
		#define QCA6490_PATH_PREFIX "qca6490/"
		#define WCN7850_PATH_PREFIX "wcn7850/"
		#define QCN7605_PATH_PREFIX "qcn7605/"
		#define DEFAULT_M3_FILE_NAME "m3.bin"
		#define DEFAULT_FW_FILE_NAME "amss.bin"
		#define FW_V2_FILE_NAME "amss20.bin"
		@@ -2594,6 +2596,7 @@ int cnss_pci_dev_powerup(struct cnss_pci_data *pci_priv)
		break;
		case QCA6290_DEVICE_ID:
		case QCA6390_DEVICE_ID:
		case QCN7605_DEVICE_ID:
		case QCA6490_DEVICE_ID:
		case WCN7850_DEVICE_ID:
		ret = cnss_qca6290_powerup(pci_priv);
		@@ -2622,6 +2625,7 @@ int cnss_pci_dev_shutdown(struct cnss_pci_data *pci_priv)
		break;
		case QCA6290_DEVICE_ID:
		case QCA6390_DEVICE_ID:
		case QCN7605_DEVICE_ID:
		case QCA6490_DEVICE_ID:
		case WCN7850_DEVICE_ID:
		ret = cnss_qca6290_shutdown(pci_priv);
		@@ -2650,6 +2654,7 @@ int cnss_pci_dev_crash_shutdown(struct cnss_pci_data *pci_priv)
		break;
		case QCA6290_DEVICE_ID:
		case QCA6390_DEVICE_ID:
		case QCN7605_DEVICE_ID:
		case QCA6490_DEVICE_ID:
		case WCN7850_DEVICE_ID:
		cnss_qca6290_crash_shutdown(pci_priv);
		@@ -2678,6 +2683,7 @@ int cnss_pci_dev_ramdump(struct cnss_pci_data *pci_priv)
		break;
		case QCA6290_DEVICE_ID:
		case QCA6390_DEVICE_ID:
		case QCN7605_DEVICE_ID:
		case QCA6490_DEVICE_ID:
		case WCN7850_DEVICE_ID:
		ret = cnss_qca6290_ramdump(pci_priv);
		@@ -3980,18 +3986,24 @@ static int cnss_pci_init_smmu(struct cnss_pci_data *pci_priv)
		struct pci_dev *pci_dev = pci_priv->pci_dev;
		struct cnss_plat_data *plat_priv = pci_priv->plat_priv;
		struct device_node *of_node;
		struct resource res_tmp;
		struct resource *res;
		const char *iommu_dma_type;
		u32 addr_win[2];
		int ret = 0;
		int index;

		of_node = of_parse_phandle(pci_dev->dev.of_node, "qcom,iommu-group", 0);
		if (!of_node)
		if (!of_node) {
		cnss_pr_err("No iommu group configuration\n");
		return ret;
		}

		cnss_pr_dbg("Initializing SMMU\n");

		pci_priv->iommu_domain = iommu_get_domain_for_dev(&pci_dev->dev);
		if (!pci_priv->iommu_domain)
		cnss_pr_err("No iommu domain found\n");
		ret = of_property_read_string(of_node, "qcom,iommu-dma",
		&iommu_dma_type);
		if (!ret && !strcmp("fastmap", iommu_dma_type)) {
		@@ -4005,8 +4017,7 @@ static int cnss_pci_init_smmu(struct cnss_pci_data *pci_priv)
		addr_win, ARRAY_SIZE(addr_win));
		if (ret) {
		cnss_pr_err("Invalid SMMU size window, err = %d\n", ret);
		of_node_put(of_node);
		return ret;
		goto out;
		}

		pci_priv->smmu_iova_start = addr_win[0];
		@@ -4015,8 +4026,28 @@ static int cnss_pci_init_smmu(struct cnss_pci_data *pci_priv)
		&pci_priv->smmu_iova_start,
		pci_priv->smmu_iova_len);

		res = platform_get_resource_byname(plat_priv->plat_dev, IORESOURCE_MEM,
		if (plat_priv->is_converged_dt) {
		index = of_property_match_string(plat_priv->dev_node, "reg-names",
		"smmu_iova_ipa");
		if (index < 0) {
		cnss_pr_err("failed to find reg smmu_iova_ipa\n");
		ret = index;
		goto out;
		}

		ret = of_address_to_resource(plat_priv->dev_node, index, &res_tmp);
		if (ret) {
		cnss_pr_err("failed to get resource\n");
		goto out;
		}

		res = &res_tmp;
		} else {
		res = platform_get_resource_byname(plat_priv->plat_dev,
		IORESOURCE_MEM,
		"smmu_iova_ipa");
		}

		if (res) {
		pci_priv->smmu_iova_ipa_start = res->start;
		pci_priv->smmu_iova_ipa_current = res->start;
		@@ -4029,10 +4060,10 @@ static int cnss_pci_init_smmu(struct cnss_pci_data *pci_priv)
		pci_priv->iommu_geometry = of_property_read_bool(of_node,
		"qcom,iommu-geometry");
		cnss_pr_dbg("iommu_geometry: %d\n", pci_priv->iommu_geometry);

		out:
		of_node_put(of_node);

		return 0;
		return ret;
		}

		static void cnss_pci_deinit_smmu(struct cnss_pci_data *pci_priv)
		@@ -4299,6 +4330,19 @@ static void cnss_pci_disable_msi(struct cnss_pci_data *pci_priv)
		pci_free_irq_vectors(pci_priv->pci_dev);
		}

		int cnss_pci_get_user_msi_assignment(struct cnss_pci_data *pci_priv,
		char *user_name,
		int *num_vectors,
		u32 *user_base_data,
		u32 *base_vector)
		{
		return cnss_get_user_msi_assignment(&pci_priv->pci_dev->dev,
		user_name,
		num_vectors,
		user_base_data,
		base_vector);
		}

		int cnss_get_user_msi_assignment(struct device dev, char user_name,
		int num_vectors, u32 user_base_data,
		u32 *base_vector)
		@@ -4380,7 +4424,7 @@ u32 cnss_pci_get_wake_msi(struct cnss_pci_data *pci_priv)
		if (!pci_priv)
		return -ENODEV;

		ret = cnss_get_user_msi_assignment(&pci_priv->pci_dev->dev,
		ret = cnss_pci_get_user_msi_assignment(pci_priv,
		WAKE_MSI_NAME, &num_vectors,
		&user_base_data, &base_vector);
		if (ret) {
		@@ -4930,6 +4974,10 @@ void cnss_pci_add_fw_prefix_name(struct cnss_pci_data *pci_priv,
		}

		switch (pci_priv->device_id) {
		case QCN7605_DEVICE_ID:
		scnprintf(prefix_name, MAX_FIRMWARE_NAME_LEN,
		QCN7605_PATH_PREFIX "%s", name);
		break;
		case QCA6390_DEVICE_ID:
		scnprintf(prefix_name, MAX_FIRMWARE_NAME_LEN,
		QCA6390_PATH_PREFIX "%s", name);
		@@ -5129,7 +5177,7 @@ static int cnss_pci_get_mhi_msi(struct cnss_pci_data *pci_priv)
		u32 user_base_data, base_vector;
		int *irq;

		ret = cnss_get_user_msi_assignment(&pci_priv->pci_dev->dev,
		ret = cnss_pci_get_user_msi_assignment(pci_priv,
		MHI_MSI_NAME, &num_vectors,
		&user_base_data, &base_vector);
		if (ret)
		@@ -5245,7 +5293,7 @@ static int cnss_pci_register_mhi(struct cnss_pci_data *pci_priv)

		mhi_ctrl->priv_data = pci_priv;
		mhi_ctrl->dev = &pci_dev->dev;
		mhi_ctrl->of_node = (&plat_priv->plat_dev->dev)->of_node;
		mhi_ctrl->of_node = plat_priv->dev_node;
		mhi_ctrl->dev_id = pci_priv->device_id;
		mhi_ctrl->domain = pci_domain_nr(pci_dev->bus);
		mhi_ctrl->bus = pci_dev->bus->number;
		@@ -5284,7 +5332,12 @@ static int cnss_pci_register_mhi(struct cnss_pci_data *pci_priv)
		mhi_ctrl->rddm_size = pci_priv->plat_priv->ramdump_info_v2.ramdump_size;
		if (!mhi_ctrl->rddm_size)
		mhi_ctrl->rddm_size = RAMDUMP_SIZE_DEFAULT;

		if (pci_priv->device_id == QCN7605_DEVICE_ID)
		mhi_ctrl->sbl_size = SZ_256K;
		else
		mhi_ctrl->sbl_size = SZ_512K;

		mhi_ctrl->seg_len = SZ_512K;
		mhi_ctrl->fbc_download = true;
		mhi_ctrl->rddm_supported = true;
		@@ -5512,6 +5565,52 @@ static struct dev_pm_domain cnss_pm_domain = {
		}
		};

		static int cnss_pci_get_dev_cfg_node(struct cnss_plat_data *plat_priv)
		{
		struct device_node *child;
		u32 id, i;
		int id_n, ret;

		if (!plat_priv->is_converged_dt)
		return 0;

		if (!plat_priv->device_id) {
		cnss_pr_err("Invalid device id\n");
		return -EINVAL;
		}

		for_each_available_child_of_node(plat_priv->plat_dev->dev.of_node,
		child) {
		if (strcmp(child->name, "chip_cfg"))
		continue;

		id_n = of_property_count_u32_elems(child, "supported-ids");
		if (id_n <= 0) {
		cnss_pr_err("Device id is NOT set\n");
		return -EINVAL;
		}

		for (i = 0; i < id_n; i++) {
		ret = of_property_read_u32_index(child,
		"supported-ids",
		i, &id);
		if (ret) {
		cnss_pr_err("Failed to read supported ids\n");
		return -EINVAL;
		}

		if (id == plat_priv->device_id) {
		plat_priv->dev_node = child;
		cnss_pr_dbg("got node[%s@%d] for device[0x%x]\n",
		child->name, i, id);
		return 0;
		}
		}
		}

		return -EINVAL;
		}

		static int cnss_pci_probe(struct pci_dev *pci_dev,
		const struct pci_device_id *id)
		{
		@@ -5544,6 +5643,16 @@ static int cnss_pci_probe(struct pci_dev *pci_dev,
		if (plat_priv->use_pm_domain)
		dev->pm_domain = &cnss_pm_domain;

		ret = cnss_pci_get_dev_cfg_node(plat_priv);
		if (ret) {
		cnss_pr_err("Failed to get device cfg node, err = %d\n", ret);
		goto reset_ctx;
		}

		ret = cnss_dev_specific_power_on(plat_priv);
		if (ret)
		goto reset_ctx;

		cnss_pci_of_reserved_mem_device_init(pci_priv);

		ret = cnss_register_subsys(plat_priv);
		@@ -5583,6 +5692,7 @@ static int cnss_pci_probe(struct pci_dev *pci_dev,
		break;
		case QCA6290_DEVICE_ID:
		case QCA6390_DEVICE_ID:
		case QCN7605_DEVICE_ID:
		case QCA6490_DEVICE_ID:
		case WCN7850_DEVICE_ID:
		cnss_pci_set_wlaon_pwr_ctrl(pci_priv, false, false, false);
		@@ -5671,6 +5781,7 @@ static const struct pci_device_id cnss_pci_id_table[] = {
		{ QCA6174_VENDOR_ID, QCA6174_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID },
		{ QCA6290_VENDOR_ID, QCA6290_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID },
		{ QCA6390_VENDOR_ID, QCA6390_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID },
		{ QCN7605_VENDOR_ID, QCN7605_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID},
		{ QCA6490_VENDOR_ID, QCA6490_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID },
		{ WCN7850_VENDOR_ID, WCN7850_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID },
		{ 0 }