Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 19c3f605 authored by Yuanyuan Liu's avatar Yuanyuan Liu
Browse files

cnss2: Remove module_param* APIs 



module_param* APIs don't scale well for multiple device instances
for one driver. Move module_param to debugfs.

CRs-Fixed: 2377009
Change-Id: Ibe556be202b28462908d12bba4dcedd12929dc42
Signed-off-by: default avatarYuanyuan Liu <yuanliu@codeaurora.org>
parent 0c098091

drivers/net/wireless/cnss2/debug.c

+139 −1
Original line number Diff line number Diff line 
/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.

/* Copyright (c) 2016-2019, 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 and
@@ -504,6 +504,142 @@ static const struct file_operations cnss_runtime_pm_debug_fops = { 
	.llseek		= seq_lseek,

};



static ssize_t cnss_control_params_debug_write(struct file *fp,

					       const char __user *user_buf,

					       size_t count, loff_t *off)

{

	struct cnss_plat_data *plat_priv =

		((struct seq_file *)fp->private_data)->private;

	char buf[64];

	char *sptr, *token;

	char *cmd;

	u32 val;

	unsigned int len = 0;

	const char *delim = " ";



	if (!plat_priv)

		return -ENODEV;



	len = min(count, sizeof(buf) - 1);

	if (copy_from_user(buf, user_buf, len))

		return -EFAULT;



	buf[len] = '\0';

	sptr = buf;



	token = strsep(&sptr, delim);

	if (!token)

		return -EINVAL;

	if (!sptr)

		return -EINVAL;

	cmd = token;



	token = strsep(&sptr, delim);

	if (!token)

		return -EINVAL;

	if (kstrtou32(token, 0, &val))

		return -EINVAL;



	if (strcmp(cmd, "quirks") == 0)

		plat_priv->ctrl_params.quirks = val;

	else if (strcmp(cmd, "mhi_timeout") == 0)

		plat_priv->ctrl_params.mhi_timeout = val;

	else if (strcmp(cmd, "qmi_timeout") == 0)

		plat_priv->ctrl_params.qmi_timeout = val;

	else if (strcmp(cmd, "bdf_type") == 0)

		plat_priv->ctrl_params.bdf_type = val;

	else

		return -EINVAL;



	return count;

}



static int cnss_show_quirks_state(struct seq_file *s,

				  struct cnss_plat_data *plat_priv)

{

	enum cnss_debug_quirks i;

	int skip = 0;

	unsigned long state;



	seq_printf(s, "quirks: 0x%lx (", plat_priv->ctrl_params.quirks);

	for (i = 0, state = plat_priv->ctrl_params.quirks;

	     state != 0; state >>= 1, i++) {

		if (!(state & 0x1))

			continue;

		if (skip++)

			seq_puts(s, " | ");



		switch (i) {

		case LINK_DOWN_SELF_RECOVERY:

			seq_puts(s, "LINK_DOWN_SELF_RECOVERY");

			continue;

		case SKIP_DEVICE_BOOT:

			seq_puts(s, "SKIP_DEVICE_BOOT");

			continue;

		case USE_CORE_ONLY_FW:

			seq_puts(s, "USE_CORE_ONLY_FW");

			continue;

		case SKIP_RECOVERY:

			seq_puts(s, "SKIP_RECOVERY");

			continue;

		case QMI_BYPASS:

			seq_puts(s, "QMI_BYPASS");

			continue;

		case ENABLE_WALTEST:

			seq_puts(s, "WALTEST");

			continue;

		case ENABLE_PCI_LINK_DOWN_PANIC:

			seq_puts(s, "PCI_LINK_DOWN_PANIC");

			continue;

		case FBC_BYPASS:

			seq_puts(s, "FBC_BYPASS");

			continue;

		case ENABLE_DAEMON_SUPPORT:

			seq_puts(s, "DAEMON_SUPPORT");

			continue;

		}



		seq_printf(s, "UNKNOWN-%d", i);

	}

	seq_puts(s, ")\n");

	return 0;

}



static int cnss_control_params_debug_show(struct seq_file *s, void *data)

{

	struct cnss_plat_data *cnss_priv = s->private;



	seq_puts(s, "\nUsage: echo <params_name> <value> > <debugfs_path>/cnss/control_params\n");

	seq_puts(s, "<params_name> can be one of below:\n");

	seq_puts(s, "quirks: Debug quirks for driver\n");

	seq_puts(s, "mhi_timeout: Timeout for MHI operation in milliseconds\n");

	seq_puts(s, "qmi_timeout: Timeout for QMI message in milliseconds\n");

	seq_puts(s, "bdf_type: Type of board data file to be downloaded\n");



	seq_puts(s, "\nCurrent value:\n");

	cnss_show_quirks_state(s, cnss_priv);

	seq_printf(s, "mhi_timeout: %u\n", cnss_priv->ctrl_params.mhi_timeout);

	seq_printf(s, "qmi_timeout: %u\n", cnss_priv->ctrl_params.qmi_timeout);

	seq_printf(s, "bdf_type: %u\n", cnss_priv->ctrl_params.bdf_type);



	return 0;

}



static int cnss_control_params_debug_open(struct inode *inode,

					  struct file *file)

{

	return single_open(file, cnss_control_params_debug_show,

			   inode->i_private);

}



static const struct file_operations cnss_control_params_debug_fops = {

	.read = seq_read,

	.write = cnss_control_params_debug_write,

	.open = cnss_control_params_debug_open,

	.owner = THIS_MODULE,

	.llseek = seq_lseek,

};



#ifdef CONFIG_CNSS2_DEBUG

static int cnss_create_debug_only_node(struct cnss_plat_data *plat_priv)

{
@@ -517,6 +653,8 @@ static int cnss_create_debug_only_node(struct cnss_plat_data *plat_priv) 
			    &cnss_reg_write_debug_fops);

	debugfs_create_file("runtime_pm", 0600, root_dentry, plat_priv,

			    &cnss_runtime_pm_debug_fops);

	debugfs_create_file("control_params", 0600, root_dentry, plat_priv,

			    &cnss_control_params_debug_fops);



	return 0;

}

drivers/net/wireless/cnss2/main.c

+38 −39
Original line number Diff line number Diff line 
/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.

/* Copyright (c) 2016-2019, 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 and
@@ -38,27 +38,18 @@ 
#define FW_ASSERT_TIMEOUT		5000

#define CNSS_EVENT_PENDING		2989



static struct cnss_plat_data *plat_env;



static DECLARE_RWSEM(cnss_pm_sem);



static bool qmi_bypass;

#ifdef CONFIG_CNSS2_DEBUG

module_param(qmi_bypass, bool, 0600);

MODULE_PARM_DESC(qmi_bypass, "Bypass QMI from platform driver");

#define CNSS_QUIRKS_DEFAULT		BIT(ENABLE_DAEMON_SUPPORT)

#ifdef CONFIG_CNSS_EMULATION

#define CNSS_MHI_TIMEOUT_DEFAULT	90000

#else

#define CNSS_MHI_TIMEOUT_DEFAULT	0

#endif

#define CNSS_QMI_TIMEOUT_DEFAULT	10000

#define CNSS_BDF_TYPE_DEFAULT		CNSS_BDF_ELF



static bool enable_waltest;

#ifdef CONFIG_CNSS2_DEBUG

module_param(enable_waltest, bool, 0600);

MODULE_PARM_DESC(enable_waltest, "Enable to handle firmware waltest");

#endif

static struct cnss_plat_data *plat_env;



unsigned long quirks;

#ifdef CONFIG_CNSS2_DEBUG

module_param(quirks, ulong, 0600);

MODULE_PARM_DESC(quirks, "Debug quirks for the driver");

#endif

static DECLARE_RWSEM(cnss_pm_sem);



static struct cnss_fw_files FW_FILES_QCA6174_FW_3_0 = {

	"qwlan30.bin", "bdwlan30.bin", "otp30.bin", "utf30.bin",
@@ -253,7 +244,7 @@ int cnss_wlan_enable(struct device *dev, 
	if (plat_priv->device_id == QCA6174_DEVICE_ID)

		return 0;



	if (qmi_bypass)

	if (test_bit(QMI_BYPASS, &plat_priv->ctrl_params.quirks))

		return 0;



	if (!config || !host_version) {
@@ -285,7 +276,7 @@ int cnss_wlan_disable(struct device *dev, enum cnss_driver_mode mode) 
	if (plat_priv->device_id == QCA6174_DEVICE_ID)

		return 0;



	if (qmi_bypass)

	if (test_bit(QMI_BYPASS, &plat_priv->ctrl_params.quirks))

		return 0;



	return cnss_wlfw_wlan_mode_send_sync(plat_priv, CNSS_OFF);
@@ -377,16 +368,6 @@ int cnss_set_fw_log_mode(struct device *dev, u8 fw_log_mode) 
}

EXPORT_SYMBOL(cnss_set_fw_log_mode);



bool *cnss_get_qmi_bypass(void)

{

	return &qmi_bypass;

}



unsigned long *cnss_get_debug_quirks(void)

{

	return &quirks;

}



static int cnss_fw_mem_ready_hdlr(struct cnss_plat_data *plat_priv)

{

	int ret = 0;
@@ -433,7 +414,7 @@ static int cnss_fw_ready_hdlr(struct cnss_plat_data *plat_priv) 
		clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);

	}



	if (enable_waltest) {

	if (test_bit(ENABLE_WALTEST, &plat_priv->ctrl_params.quirks)) {

		ret = cnss_wlfw_wlan_mode_send_sync(plat_priv,

						    CNSS_WALTEST);

	} else if (test_bit(CNSS_COLD_BOOT_CAL, &plat_priv->driver_state)) {
@@ -571,7 +552,14 @@ int cnss_driver_event_post(struct cnss_plat_data *plat_priv, 


unsigned int cnss_get_boot_timeout(struct device *dev)

{

	return cnss_get_qmi_timeout();

	struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);



	if (!plat_priv) {

		cnss_pr_err("plat_priv is NULL\n");

		return 0;

	}



	return cnss_get_qmi_timeout(plat_priv);

}

EXPORT_SYMBOL(cnss_get_boot_timeout);
@@ -890,14 +878,15 @@ static int cnss_do_recovery(struct cnss_plat_data *plat_priv, 
	if (plat_priv->device_id == QCA6174_DEVICE_ID)

		goto self_recovery;



	if (test_bit(SKIP_RECOVERY, &quirks)) {

	if (test_bit(SKIP_RECOVERY, &plat_priv->ctrl_params.quirks)) {

		cnss_pr_dbg("Skip device recovery\n");

		return 0;

	}



	switch (reason) {

	case CNSS_REASON_LINK_DOWN:

		if (test_bit(LINK_DOWN_SELF_RECOVERY, &quirks))

		if (test_bit(LINK_DOWN_SELF_RECOVERY,

			     &plat_priv->ctrl_params.quirks))

			goto self_recovery;

		break;

	case CNSS_REASON_RDDM:
@@ -1513,7 +1502,7 @@ static ssize_t cnss_fs_ready_store(struct device *dev, 
	cnss_pr_dbg("File system is ready, fs_ready is %d, count is %zu\n",

		    fs_ready, count);



	if (qmi_bypass) {

	if (test_bit(QMI_BYPASS, &plat_priv->ctrl_params.quirks)) {

		cnss_pr_dbg("QMI is bypassed.\n");

		return count;

	}
@@ -1617,6 +1606,14 @@ static void cnss_misc_deinit(struct cnss_plat_data *plat_priv) 
	del_timer(&plat_priv->fw_boot_timer);

}



static void cnss_init_control_params(struct cnss_plat_data *plat_priv)

{

	plat_priv->ctrl_params.quirks = CNSS_QUIRKS_DEFAULT;

	plat_priv->ctrl_params.mhi_timeout = CNSS_MHI_TIMEOUT_DEFAULT;

	plat_priv->ctrl_params.qmi_timeout = CNSS_QMI_TIMEOUT_DEFAULT;

	plat_priv->ctrl_params.bdf_type = CNSS_BDF_TYPE_DEFAULT;

}



static const struct platform_device_id cnss_platform_id_table[] = {

	{ .name = "qca6174", .driver_data = QCA6174_DEVICE_ID, },

	{ .name = "qca6290", .driver_data = QCA6290_DEVICE_ID, },
@@ -1672,11 +1669,13 @@ static int cnss_probe(struct platform_device *plat_dev) 
	cnss_set_plat_priv(plat_dev, plat_priv);

	platform_set_drvdata(plat_dev, plat_priv);



	cnss_init_control_params(plat_priv);



	ret = cnss_get_resources(plat_priv);

	if (ret)

		goto reset_ctx;



	if (!test_bit(SKIP_DEVICE_BOOT, &quirks)) {

	if (!test_bit(SKIP_DEVICE_BOOT, &plat_priv->ctrl_params.quirks)) {

		ret = cnss_power_on_device(plat_priv);

		if (ret)

			goto free_res;
@@ -1731,10 +1730,10 @@ static int cnss_probe(struct platform_device *plat_dev) 
unreg_esoc:

	cnss_unregister_esoc(plat_priv);

deinit_bus:

	if (!test_bit(SKIP_DEVICE_BOOT, &quirks))

	if (!test_bit(SKIP_DEVICE_BOOT, &plat_priv->ctrl_params.quirks))

		cnss_bus_deinit(plat_priv);

power_off:

	if (!test_bit(SKIP_DEVICE_BOOT, &quirks))

	if (!test_bit(SKIP_DEVICE_BOOT, &plat_priv->ctrl_params.quirks))

		cnss_power_off_device(plat_priv);

free_res:

	cnss_put_resources(plat_priv);

drivers/net/wireless/cnss2/main.h

+20 −3
Original line number Diff line number Diff line 
/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.

/* Copyright (c) 2016-2019, 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 and
@@ -205,6 +205,24 @@ enum cnss_debug_quirks { 
	SKIP_DEVICE_BOOT,

	USE_CORE_ONLY_FW,

	SKIP_RECOVERY,

	QMI_BYPASS,

	ENABLE_WALTEST,

	ENABLE_PCI_LINK_DOWN_PANIC,

	FBC_BYPASS,

	ENABLE_DAEMON_SUPPORT,

};



enum cnss_bdf_type {

	CNSS_BDF_BIN,

	CNSS_BDF_ELF,

	CNSS_BDF_DUMMY = 255,

};



struct cnss_control_params {

	unsigned long quirks;

	unsigned int mhi_timeout;

	unsigned int qmi_timeout;

	unsigned int bdf_type;

};



struct cnss_plat_data {
@@ -252,11 +270,10 @@ struct cnss_plat_data { 
	bool powered_on;

	char firmware_name[13];

	struct completion rddm_complete;

	struct cnss_control_params ctrl_params;

};



struct cnss_plat_data *cnss_get_plat_priv(struct platform_device *plat_dev);

bool *cnss_get_qmi_bypass(void);

unsigned long *cnss_get_debug_quirks(void);

int cnss_driver_event_post(struct cnss_plat_data *plat_priv,

			   enum cnss_driver_event_type type,

			   u32 flags, void *data);

drivers/net/wireless/cnss2/pci.c

+16 −34
Original line number Diff line number Diff line
@@ -59,32 +59,7 @@ 


static DEFINE_SPINLOCK(pci_link_down_lock);



static unsigned int pci_link_down_panic;

module_param(pci_link_down_panic, uint, 0600);

MODULE_PARM_DESC(pci_link_down_panic,

		 "Trigger kernel panic when PCI link down is detected");



static bool fbc_bypass;

#ifdef CONFIG_CNSS2_DEBUG

module_param(fbc_bypass, bool, 0600);

MODULE_PARM_DESC(fbc_bypass,

		 "Bypass firmware download when loading WLAN driver");

#endif



#ifdef CONFIG_CNSS2_DEBUG

#ifdef CONFIG_CNSS_EMULATION

static unsigned int mhi_timeout = 90000;

#else

static unsigned int mhi_timeout;

#endif

module_param(mhi_timeout, uint, 0600);

MODULE_PARM_DESC(mhi_timeout,

		 "Timeout for MHI operation in milliseconds");



#define MHI_TIMEOUT_OVERWRITE_MS	mhi_timeout

#else

#define MHI_TIMEOUT_OVERWRITE_MS	0

#endif

#define MHI_TIMEOUT_OVERWRITE_MS	(plat_priv->ctrl_params.mhi_timeout)



static int cnss_set_pci_config_space(struct cnss_pci_data *pci_priv, bool save)

{
@@ -227,13 +202,16 @@ int cnss_pci_link_down(struct device *dev) 
	unsigned long flags;

	struct pci_dev *pci_dev = to_pci_dev(dev);

	struct cnss_pci_data *pci_priv = cnss_get_pci_priv(pci_dev);

	struct cnss_plat_data *plat_priv;



	if (!pci_priv) {

		cnss_pr_err("pci_priv is NULL!\n");

		return -EINVAL;

	}



	if (pci_link_down_panic)

	plat_priv = pci_priv->plat_priv;

	if (test_bit(ENABLE_PCI_LINK_DOWN_PANIC,

		     &plat_priv->ctrl_params.quirks))

		panic("cnss: PCI link is down!\n");



	spin_lock_irqsave(&pci_link_down_lock, flags);
@@ -510,7 +488,7 @@ static int cnss_qca6290_powerup(struct cnss_pci_data *pci_priv) 
		return 0;

	}



	if (test_bit(USE_CORE_ONLY_FW, cnss_get_debug_quirks())) {

	if (test_bit(USE_CORE_ONLY_FW, &plat_priv->ctrl_params.quirks)) {

		clear_bit(CNSS_FW_BOOT_RECOVERY, &plat_priv->driver_state);

		clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);

		return 0;
@@ -518,7 +496,7 @@ static int cnss_qca6290_powerup(struct cnss_pci_data *pci_priv) 


	cnss_set_pin_connect_status(plat_priv);



	if (*cnss_get_qmi_bypass()) {

	if (test_bit(QMI_BYPASS, &plat_priv->ctrl_params.quirks)) {

		ret = cnss_pci_call_driver_probe(pci_priv);

		if (ret)

			goto stop_mhi;
@@ -919,6 +897,7 @@ static void cnss_pci_event_cb(struct msm_pcie_notify *notify) 
	unsigned long flags;

	struct pci_dev *pci_dev;

	struct cnss_pci_data *pci_priv;

	struct cnss_plat_data *plat_priv;



	if (!notify)

		return;
@@ -931,9 +910,11 @@ static void cnss_pci_event_cb(struct msm_pcie_notify *notify) 
	if (!pci_priv)

		return;



	plat_priv = pci_priv->plat_priv;

	switch (notify->event) {

	case MSM_PCIE_EVENT_LINKDOWN:

		if (pci_link_down_panic)

		if (test_bit(ENABLE_PCI_LINK_DOWN_PANIC,

			     &plat_priv->ctrl_params.quirks))

			panic("cnss: PCI link is down!\n");



		spin_lock_irqsave(&pci_link_down_lock, flags);
@@ -2346,13 +2327,15 @@ int cnss_pci_set_mhi_state(struct cnss_pci_data *pci_priv, 
int cnss_pci_start_mhi(struct cnss_pci_data *pci_priv)

{

	int ret = 0;

	struct cnss_plat_data *plat_priv;



	if (!pci_priv) {

		cnss_pr_err("pci_priv is NULL!\n");

		return -ENODEV;

	}



	if (fbc_bypass)

	plat_priv = pci_priv->plat_priv;

	if (test_bit(FBC_BYPASS, &plat_priv->ctrl_params.quirks))

		return 0;



	if (MHI_TIMEOUT_OVERWRITE_MS)
@@ -2381,10 +2364,9 @@ void cnss_pci_stop_mhi(struct cnss_pci_data *pci_priv) 
		return;

	}



	if (fbc_bypass)

		return;



	plat_priv = pci_priv->plat_priv;

	if (test_bit(FBC_BYPASS, &plat_priv->ctrl_params.quirks))

		return;



	cnss_pci_set_mhi_state_bit(pci_priv, CNSS_MHI_RESUME);

	if (!pci_priv->pci_link_down_ind)

drivers/net/wireless/cnss2/qmi.c

+13 −32
Original line number Diff line number Diff line 
/* Copyright (c) 2015-2018, The Linux Foundation. All rights reserved.

/* Copyright (c) 2015-2019, 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 and
@@ -28,35 +28,11 @@ 
#define BIN_BDF_FILE_NAME_PREFIX	"bdwlan.b"

#define DUMMY_BDF_FILE_NAME		"bdwlan.dmy"



enum cnss_bdf_type {

	CNSS_BDF_BIN,

	CNSS_BDF_ELF,

	CNSS_BDF_DUMMY = 255,

};



#ifdef CONFIG_CNSS2_DEBUG

static unsigned int qmi_timeout = 10000;

module_param(qmi_timeout, uint, 0600);

MODULE_PARM_DESC(qmi_timeout, "Timeout for QMI message in milliseconds");



#define QMI_WLFW_TIMEOUT_MS		qmi_timeout

#else

#define QMI_WLFW_TIMEOUT_MS		10000

#endif

#define QMI_WLFW_TIMEOUT_MS		(plat_priv->ctrl_params.qmi_timeout)

#define QMI_WLFW_TIMEOUT_JF		msecs_to_jiffies(QMI_WLFW_TIMEOUT_MS)



#define QMI_WLFW_MAX_RECV_BUF_SIZE	SZ_8K



static bool daemon_support = true;

module_param(daemon_support, bool, 0600);

MODULE_PARM_DESC(daemon_support, "User space has cnss-daemon support or not");



static unsigned int bdf_type = CNSS_BDF_ELF;

#ifdef CONFIG_CNSS2_DEBUG

module_param(bdf_type, uint, 0600);

MODULE_PARM_DESC(bdf_type, "Type of board data file to be downloaded");

#endif



static char *cnss_qmi_mode_to_str(enum cnss_driver_mode mode)

{

	switch (mode) {
@@ -181,7 +157,11 @@ static int cnss_wlfw_host_cap_send_sync(struct cnss_plat_data *plat_priv) 
	}



	req->num_clients_valid = 1;

	req->num_clients = daemon_support ? 2 : 1;

	if (test_bit(ENABLE_DAEMON_SUPPORT,

		     &plat_priv->ctrl_params.quirks))

		req->num_clients = 2;

	else

		req->num_clients = 1;

	cnss_pr_dbg("Number of clients is %d\n", req->num_clients);



	req->wake_msi = cnss_bus_get_wake_irq(plat_priv);
@@ -449,7 +429,7 @@ int cnss_wlfw_bdf_dnld_send_sync(struct cnss_plat_data *plat_priv) 
		return -ENOMEM;

	}



	switch (bdf_type) {

	switch (plat_priv->ctrl_params.bdf_type) {

	case CNSS_BDF_ELF:

		if (plat_priv->board_info.board_id == 0xFF)

			snprintf(filename, sizeof(filename), ELF_BDF_FILE_NAME);
@@ -473,7 +453,8 @@ int cnss_wlfw_bdf_dnld_send_sync(struct cnss_plat_data *plat_priv) 
		remaining = MAX_BDF_FILE_NAME;

		goto bypass_bdf;

	default:

		cnss_pr_err("Invalid BDF type: %d\n", bdf_type);

		cnss_pr_err("Invalid BDF type: %d\n",

			    plat_priv->ctrl_params.bdf_type);

		ret = -EINVAL;

		goto err_req_fw;

	}
@@ -500,7 +481,7 @@ int cnss_wlfw_bdf_dnld_send_sync(struct cnss_plat_data *plat_priv) 
		req->data_valid = 1;

		req->end_valid = 1;

		req->bdf_type_valid = 1;

		req->bdf_type = bdf_type;

		req->bdf_type = plat_priv->ctrl_params.bdf_type;



		if (remaining > QMI_WLFW_MAX_DATA_SIZE_V01) {

			req->data_len = QMI_WLFW_MAX_DATA_SIZE_V01;
@@ -555,7 +536,7 @@ int cnss_wlfw_bdf_dnld_send_sync(struct cnss_plat_data *plat_priv) 
	return 0;



err_send:

	if (bdf_type != CNSS_BDF_DUMMY)

	if (plat_priv->ctrl_params.bdf_type != CNSS_BDF_DUMMY)

		release_firmware(fw_entry);

err_req_fw:

	CNSS_ASSERT(0);
@@ -1070,7 +1051,7 @@ int cnss_wlfw_ini_send_sync(struct cnss_plat_data *plat_priv, 
	return ret;

}



unsigned int cnss_get_qmi_timeout(void)

unsigned int cnss_get_qmi_timeout(struct cnss_plat_data *plat_priv)

{

	cnss_pr_dbg("QMI timeout is %u ms\n", QMI_WLFW_TIMEOUT_MS);