android_kernel_samsung_sm8650-modules/icnss2/qmi.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
 * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved.
 */

#define pr_fmt(fmt) "icnss2_qmi: " fmt

#include <linux/export.h>
#include <linux/err.h>
#include <linux/of.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/etherdevice.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/ipc_logging.h>
#include <linux/thread_info.h>
#include <linux/firmware.h>
#include <linux/soc/qcom/qmi.h>
#include <linux/platform_device.h>
#ifdef CONFIG_CNSS_OUT_OF_TREE
#include "icnss2.h"
#else
#include <soc/qcom/icnss2.h>
#endif
#include <soc/qcom/of_common.h>
#include "wlan_firmware_service_v01.h"
#include "main.h"
#include "qmi.h"
#include "debug.h"
#include "genl.h"

#define WLFW_SERVICE_WCN_INS_ID_V01	3
#define WLFW_SERVICE_INS_ID_V01		0
#define WLFW_CLIENT_ID			0x4b4e454c
#define QMI_ERR_PLAT_CCPM_CLK_INIT_FAILED	0x77

#define BDF_FILE_NAME_PREFIX		"bdwlan"
#define ELF_BDF_FILE_NAME		"bdwlan.elf"
#define ELF_BDF_FILE_NAME_PREFIX	"bdwlan.e"
#define BIN_BDF_FILE_NAME		"bdwlan.bin"
#define BIN_BDF_FILE_NAME_PREFIX	"bdwlan."
#define REGDB_FILE_NAME			"regdb.bin"

#define QDSS_TRACE_CONFIG_FILE "qdss_trace_config.cfg"

#define WLAN_BOARD_ID_INDEX		0x100
#define DEVICE_BAR_SIZE			0x200000
#define M3_SEGMENT_ADDR_MASK		0xFFFFFFFF
#define DMS_QMI_MAX_MSG_LEN		SZ_256
#define DMS_MAC_NOT_PROVISIONED		16
#define BDWLAN_SIZE			6
#define UMC_CHIP_ID                    0x4320
#define MAX_SHADOW_REG_RESERVED		2
#define MAX_NUM_SHADOW_REG_V3		(QMI_WLFW_MAX_NUM_SHADOW_REG_V3_USAGE_V01 - \
					MAX_SHADOW_REG_RESERVED)
#define IMSPRIVATE_SERVICE_MAX_MSG_LEN  SZ_8K

#ifdef CONFIG_ICNSS2_DEBUG
bool ignore_fw_timeout;
#define ICNSS_QMI_ASSERT() ICNSS_ASSERT(ignore_fw_timeout)
#else
#define ICNSS_QMI_ASSERT() do { } while (0)
#endif

#ifdef CONFIG_ICNSS2_DEBUG
void icnss_ignore_fw_timeout(bool ignore)
{
	ignore_fw_timeout = ignore;
}
#else
void icnss_ignore_fw_timeout(bool ignore) { }
#endif

#define icnss_qmi_fatal_err(_fmt, ...) do {		\
	icnss_pr_err("fatal: "_fmt, ##__VA_ARGS__);	\
	ICNSS_QMI_ASSERT();				\
	} while (0)

int wlfw_msa_mem_info_send_sync_msg(struct icnss_priv *priv)
{
	int ret;
	int i;
	struct wlfw_msa_info_req_msg_v01 *req;
	struct wlfw_msa_info_resp_msg_v01 *resp;
	struct qmi_txn txn;
	uint64_t max_mapped_addr;

	if (!priv)
		return -ENODEV;

	icnss_pr_dbg("Sending MSA mem info, state: 0x%lx\n", priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->msa_addr = priv->msa_pa;
	req->size = priv->msa_mem_size;

	priv->stats.msa_info_req++;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_msa_info_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_qmi_fatal_err(
				"Fail to init txn for MSA Mem info resp %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_MSA_INFO_REQ_V01,
			       WLFW_MSA_INFO_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_msa_info_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send MSA Mem info req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_qmi_fatal_err("MSA Mem info resp wait failed ret %d\n",
				    ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_qmi_fatal_err(
		"QMI MSA Mem info request rejected, result:%d error:%d\n",
			resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	icnss_pr_dbg("Receive mem_region_info_len: %d\n",
		     resp->mem_region_info_len);

	if (resp->mem_region_info_len > QMI_WLFW_MAX_NUM_MEMORY_REGIONS_V01) {
		icnss_qmi_fatal_err(
			"Invalid memory region length received: %d\n",
			 resp->mem_region_info_len);
		ret = -EINVAL;
		goto out;
	}

	max_mapped_addr = priv->msa_pa + priv->msa_mem_size;
	priv->stats.msa_info_resp++;
	priv->nr_mem_region = resp->mem_region_info_len;
	for (i = 0; i < resp->mem_region_info_len; i++) {

		if (resp->mem_region_info[i].size > priv->msa_mem_size ||
		    resp->mem_region_info[i].region_addr >= max_mapped_addr ||
		    resp->mem_region_info[i].region_addr < priv->msa_pa ||
		    resp->mem_region_info[i].size +
		    resp->mem_region_info[i].region_addr > max_mapped_addr) {
			icnss_pr_dbg("Received out of range Addr: 0x%llx Size: 0x%x\n",
					resp->mem_region_info[i].region_addr,
					resp->mem_region_info[i].size);
			ret = -EINVAL;
			goto fail_unwind;
		}

		priv->mem_region[i].reg_addr =
			resp->mem_region_info[i].region_addr;
		priv->mem_region[i].size =
			resp->mem_region_info[i].size;
		priv->mem_region[i].secure_flag =
			resp->mem_region_info[i].secure_flag;
		icnss_pr_dbg("Memory Region: %d Addr: 0x%llx Size: 0x%x Flag: 0x%08x\n",
			     i, priv->mem_region[i].reg_addr,
			     priv->mem_region[i].size,
			     priv->mem_region[i].secure_flag);
	}

	kfree(resp);
	kfree(req);
	return 0;

fail_unwind:
	memset(&priv->mem_region[0], 0, sizeof(priv->mem_region[0]) * i);
out:
	kfree(resp);
	kfree(req);
	priv->stats.msa_info_err++;
	return ret;
}

int wlfw_msa_ready_send_sync_msg(struct icnss_priv *priv)
{
	int ret;
	struct wlfw_msa_ready_req_msg_v01 *req;
	struct wlfw_msa_ready_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	icnss_pr_dbg("Sending MSA ready request message, state: 0x%lx\n",
		     priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	priv->stats.msa_ready_req++;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_msa_ready_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_qmi_fatal_err(
				"Fail to init txn for MSA Mem Ready resp %d\n",
				ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_MSA_READY_REQ_V01,
			       WLFW_MSA_READY_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_msa_ready_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send MSA Mem Ready req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_qmi_fatal_err(
				"MSA Mem Ready resp wait failed with ret %d\n",
				ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_qmi_fatal_err(
		   "QMI MSA Mem Ready request rejected, result:%d error:%d\n",
		   resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	priv->stats.msa_ready_resp++;

	kfree(resp);
	kfree(req);
	return 0;

out:
	kfree(resp);
	kfree(req);
	priv->stats.msa_ready_err++;
	return ret;
}

int wlfw_device_info_send_msg(struct icnss_priv *priv)
{
	int ret;
	struct wlfw_device_info_req_msg_v01 *req;
	struct wlfw_device_info_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	icnss_pr_dbg("Sending Device Info request message, state: 0x%lx\n",
		     priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	priv->stats.device_info_req++;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_device_info_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_qmi_fatal_err(
				"Fail to init txn for Device Info resp %d\n",
				ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_DEVICE_INFO_REQ_V01,
			       WLFW_DEVICE_INFO_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_device_info_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send device info req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_qmi_fatal_err(
				"Device Info resp wait failed with ret %d\n",
				ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_qmi_fatal_err(
		   "QMI Device info request rejected, result:%d error:%d\n",
		   resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	priv->stats.device_info_resp++;

	if (resp->bar_addr_valid)
		priv->mem_base_pa = resp->bar_addr;

	if (resp->bar_size_valid)
		priv->mem_base_size = resp->bar_size;

	if (!priv->mem_base_pa) {
		ret = -EINVAL;
		icnss_qmi_fatal_err("Fail to get bar address\n");
		goto out;
	}

	if (priv->mem_base_size <  DEVICE_BAR_SIZE) {
		ret = -EINVAL;
		icnss_qmi_fatal_err("Bar size is not proper 0x%x\n",
				    priv->mem_base_size);
		goto out;
	}

	if (resp->mhi_state_info_addr_valid)
		priv->mhi_state_info_pa = resp->mhi_state_info_addr;

	if (resp->mhi_state_info_size_valid)
		priv->mhi_state_info_size = resp->mhi_state_info_size;

	if (!priv->mhi_state_info_pa)
		icnss_pr_err("Fail to get MHI info address\n");

	kfree(resp);
	kfree(req);
	return 0;

out:
	kfree(resp);
	kfree(req);
	priv->stats.device_info_err++;
	return ret;
}

int wlfw_power_save_send_msg(struct icnss_priv *priv,
			     enum wlfw_power_save_mode_v01 mode)
{
	int ret;
	struct wlfw_power_save_req_msg_v01 *req;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	if (test_bit(ICNSS_FW_DOWN, &priv->state))
		return -EINVAL;

	if (test_bit(ICNSS_PD_RESTART, &priv->state) ||
	    !test_bit(ICNSS_MODE_ON, &priv->state))
		return 0;

	icnss_pr_dbg("Sending power save mode: %d, state: 0x%lx\n",
		     mode, priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	req->power_save_mode_valid = 1;
	req->power_save_mode = mode;

	if (mode == WLFW_POWER_SAVE_EXIT_V01)
		priv->stats.exit_power_save_req++;
	else
		priv->stats.enter_power_save_req++;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   NULL, NULL);
	if (ret < 0) {
		icnss_qmi_fatal_err("Fail to init txn for exit power save%d\n",
				    ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_POWER_SAVE_REQ_V01,
			       WLFW_POWER_SAVE_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_power_save_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send exit power save req %d\n",
				    ret);
		goto out;
	}

	qmi_txn_cancel(&txn);

	if (mode == WLFW_POWER_SAVE_EXIT_V01)
		priv->stats.exit_power_save_resp++;
	else
		priv->stats.enter_power_save_resp++;

	kfree(req);
	return 0;

out:
	kfree(req);

	if (mode == WLFW_POWER_SAVE_EXIT_V01)
		priv->stats.exit_power_save_err++;
	else
		priv->stats.enter_power_save_err++;
	return ret;
}

int wlfw_send_soc_wake_msg(struct icnss_priv *priv,
			   enum wlfw_soc_wake_enum_v01 type)
{
	int ret;
	struct wlfw_soc_wake_req_msg_v01 *req;
	struct wlfw_soc_wake_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	if (test_bit(ICNSS_FW_DOWN, &priv->state))
		return -EINVAL;

	icnss_pr_soc_wake("Sending soc wake msg, type: 0x%x\n",
		     type);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}
	req->wake_valid = 1;
	req->wake = type;

	priv->stats.soc_wake_req++;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_soc_wake_resp_msg_v01_ei, resp);

	if (ret < 0) {
		icnss_pr_err("Fail to init txn for wake msg resp %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_SOC_WAKE_REQ_V01,
			       WLFW_SOC_WAKE_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_soc_wake_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Fail to send soc wake msg %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_qmi_fatal_err("SOC wake timed out with ret %d\n",
				    ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_qmi_fatal_err(
			"SOC wake request rejected,result:%d error:%d\n",
			resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	priv->stats.soc_wake_resp++;

	kfree(resp);
	kfree(req);
	return 0;

out:
	kfree(req);
	kfree(resp);
	priv->stats.soc_wake_err++;
	return ret;
}

int wlfw_ind_register_send_sync_msg(struct icnss_priv *priv)
{
	int ret;
	struct wlfw_ind_register_req_msg_v01 *req;
	struct wlfw_ind_register_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	icnss_pr_dbg("Sending indication register message, state: 0x%lx\n",
		     priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->client_id_valid = 1;
	req->client_id = WLFW_CLIENT_ID;
	req->fw_ready_enable_valid = 1;
	req->fw_ready_enable = 1;
	req->pin_connect_result_enable_valid = 1;
	req->pin_connect_result_enable = 1;

	if (priv->device_id == ADRASTEA_DEVICE_ID) {
		req->msa_ready_enable_valid = 1;
		req->msa_ready_enable = 1;
		if (test_bit(FW_REJUVENATE_ENABLE,
			 &priv->ctrl_params.quirks)) {
			req->rejuvenate_enable_valid = 1;
			req->rejuvenate_enable = 1;
		}
	} else if (priv->device_id == WCN6750_DEVICE_ID ||
		   priv->device_id == WCN6450_DEVICE_ID) {
		req->fw_init_done_enable_valid = 1;
		req->fw_init_done_enable = 1;
		req->cal_done_enable_valid = 1;
		req->cal_done_enable = 1;
		req->qdss_trace_req_mem_enable_valid = 1;
		req->qdss_trace_req_mem_enable = 1;
		req->qdss_trace_save_enable_valid = 1;
		req->qdss_trace_save_enable = 1;
		req->qdss_trace_free_enable_valid = 1;
		req->qdss_trace_free_enable = 1;
		req->respond_get_info_enable_valid = 1;
		req->respond_get_info_enable = 1;
		req->m3_dump_upload_segments_req_enable_valid = 1;
		req->m3_dump_upload_segments_req_enable = 1;
	}

	priv->stats.ind_register_req++;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_ind_register_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_qmi_fatal_err(
				"Fail to init txn for Ind Register resp %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_IND_REGISTER_REQ_V01,
			       WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_ind_register_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send Ind Register req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_qmi_fatal_err(
			"Ind Register resp wait failed with ret %d\n",
			 ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_qmi_fatal_err(
		    "QMI Ind Register request rejected, result:%d error:%d\n",
		     resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	priv->stats.ind_register_resp++;

	if (resp->fw_status_valid &&
	   (resp->fw_status & QMI_WLFW_ALREADY_REGISTERED_V01)) {
		ret = -EALREADY;
		icnss_pr_dbg("WLFW already registered\n");
		goto qmi_registered;
	}

	kfree(resp);
	kfree(req);

	return 0;

out:
	priv->stats.ind_register_err++;
qmi_registered:
	kfree(resp);
	kfree(req);
	return ret;
}

int wlfw_cal_report_req(struct icnss_priv *priv)
{
	int ret;
	struct wlfw_cal_report_req_msg_v01 *req;
	struct wlfw_cal_report_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	if (test_bit(ICNSS_FW_DOWN, &priv->state))
		return -EINVAL;

	icnss_pr_info("Sending cal report request, state: 0x%lx\n",
		      priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}
	req->meta_data_len = 0;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_cal_report_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_qmi_fatal_err("Fail to init txn for cal report req %d\n",
				    ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_CAL_REPORT_REQ_V01,
			       WLFW_CAL_REPORT_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_cal_report_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send cal report req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn,
			   priv->ctrl_params.qmi_timeout);

	if (ret < 0) {
		icnss_qmi_fatal_err("Cal report wait failed with ret %d\n",
				    ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_qmi_fatal_err("QMI cal report request rejected, result:%d error:%d\n",
				    resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	kfree(resp);
	kfree(req);

	return 0;

out:
	return ret;
}

int wlfw_cap_send_sync_msg(struct icnss_priv *priv)
{
	int ret = 0, i = 0;
	struct wlfw_cap_req_msg_v01 *req;
	struct wlfw_cap_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	icnss_pr_dbg("Sending target capability message, state: 0x%lx\n",
		     priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	priv->stats.cap_req++;

	ret = qmi_txn_init(&priv->qmi, &txn, wlfw_cap_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_qmi_fatal_err("Fail to init txn for Capability resp %d\n",
				    ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_CAP_REQ_V01,
			       WLFW_CAP_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_cap_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send Capability req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn,
			   priv->ctrl_params.qmi_timeout +
			   msecs_to_jiffies(priv->wlan_en_delay_ms));
	if (ret < 0) {
		icnss_qmi_fatal_err("Capability resp wait failed with ret %d\n",
				    ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		ret = -resp->resp.result;
		if (resp->resp.error == QMI_ERR_PLAT_CCPM_CLK_INIT_FAILED) {
			icnss_pr_err("RF card not present\n");
			goto out;
		}
		icnss_qmi_fatal_err(
			"QMI Capability request rejected, result:%d error:%d\n",
			resp->resp.result, resp->resp.error);
		goto out;
	}

	priv->stats.cap_resp++;

	if (resp->chip_info_valid) {
		priv->chip_info.chip_id = resp->chip_info.chip_id;
		priv->chip_info.chip_family = resp->chip_info.chip_family;
	}
	if (resp->board_info_valid)
		priv->board_id = resp->board_info.board_id;
	else
		priv->board_id = 0xFF;
	if (resp->soc_info_valid)
		priv->soc_id = resp->soc_info.soc_id;
	if (resp->fw_version_info_valid) {
		priv->fw_version_info.fw_version =
			resp->fw_version_info.fw_version;
		strlcpy(priv->fw_version_info.fw_build_timestamp,
				resp->fw_version_info.fw_build_timestamp,
				WLFW_MAX_TIMESTAMP_LEN + 1);
	}

	if (resp->dev_mem_info_valid) {
		for (i = 0; i < QMI_WLFW_MAX_DEV_MEM_NUM_V01; i++) {
			priv->dev_mem_info[i].start =
				resp->dev_mem_info[i].start;
			priv->dev_mem_info[i].size =
				resp->dev_mem_info[i].size;
			icnss_pr_info("Device memory info[%d]: start = 0x%llx, size = 0x%llx\n",
				      i, priv->dev_mem_info[i].start,
				      priv->dev_mem_info[i].size);
		}
	}

	if (resp->voltage_mv_valid) {
		priv->cpr_info.voltage = resp->voltage_mv;
		icnss_pr_dbg("Voltage for CPR: %dmV\n",
			    priv->cpr_info.voltage);
		icnss_update_cpr_info(priv);
	}

	if (resp->fw_build_id_valid)
		strlcpy(priv->fw_build_id, resp->fw_build_id,
			QMI_WLFW_MAX_BUILD_ID_LEN_V01 + 1);

	if (resp->rd_card_chain_cap_valid) {
		priv->rd_card_chain_cap = (enum icnss_rd_card_chain_cap)resp->rd_card_chain_cap;
		if (resp->rd_card_chain_cap == WLFW_RD_CARD_CHAIN_CAP_1x1_V01)
			priv->is_chain1_supported = false;
	}

	if (resp->foundry_name_valid)
		priv->foundry_name = resp->foundry_name[0];
	else if (resp->chip_info_valid && priv->chip_info.chip_id == UMC_CHIP_ID)
		priv->foundry_name = 'u';

	if (resp->he_channel_width_cap_valid)
		priv->phy_he_channel_width_cap =
			(enum icnss_phy_he_channel_width_cap)resp->he_channel_width_cap;

	if (resp->phy_qam_cap_valid)
		priv->phy_qam_cap = (enum icnss_phy_qam_cap)resp->phy_qam_cap;

	if (resp->serial_id_valid) {
		priv->serial_id = resp->serial_id;
		icnss_pr_info("serial id  0x%x 0x%x\n",
			     resp->serial_id.serial_id_msb,
			     resp->serial_id.serial_id_lsb);
	}

	icnss_pr_dbg("Capability, chip_id: 0x%x, chip_family: 0x%x, board_id: 0x%x, soc_id: 0x%x",
		     priv->chip_info.chip_id, priv->chip_info.chip_family,
		     priv->board_id, priv->soc_id);

	icnss_pr_dbg("fw_version: 0x%x, fw_build_timestamp: %s, fw_build_id: %s",
		     priv->fw_version_info.fw_version,
		     priv->fw_version_info.fw_build_timestamp,
		     priv->fw_build_id);

	icnss_pr_dbg("RD card chain cap: %d, PHY HE channel width cap: %d, PHY QAM cap: %d",
		     priv->rd_card_chain_cap, priv->phy_he_channel_width_cap,
		     priv->phy_qam_cap);

	kfree(resp);
	kfree(req);
	return 0;

out:
	kfree(resp);
	kfree(req);
	priv->stats.cap_err++;
	return ret;
}

int icnss_qmi_get_dms_mac(struct icnss_priv *priv)
{
	struct dms_get_mac_address_req_msg_v01 req;
	struct dms_get_mac_address_resp_msg_v01 resp;
	struct qmi_txn txn;
	int ret = 0;

	if  (!test_bit(ICNSS_QMI_DMS_CONNECTED, &priv->state)) {
		icnss_pr_err("DMS QMI connection not established\n");
		return -EAGAIN;
	}
	icnss_pr_dbg("Requesting DMS MAC address");

	memset(&resp, 0, sizeof(resp));
	ret = qmi_txn_init(&priv->qmi_dms, &txn,
			   dms_get_mac_address_resp_msg_v01_ei, &resp);
	if (ret < 0) {
		icnss_pr_err("Failed to initialize txn for dms, err: %d\n",
			     ret);
		goto out;
	}
	req.device = DMS_DEVICE_MAC_WLAN_V01;
	ret = qmi_send_request(&priv->qmi_dms, NULL, &txn,
			       QMI_DMS_GET_MAC_ADDRESS_REQ_V01,
			       DMS_GET_MAC_ADDRESS_REQ_MSG_V01_MAX_MSG_LEN,
			       dms_get_mac_address_req_msg_v01_ei, &req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Failed to send QMI_DMS_GET_MAC_ADDRESS_REQ_V01, err: %d\n",
			     ret);
		goto out;
	}
	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("Failed to wait for QMI_DMS_GET_MAC_ADDRESS_RESP_V01, err: %d\n",
			     ret);
		goto out;
	}

	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
		if (resp.resp.error == DMS_MAC_NOT_PROVISIONED) {
			icnss_pr_err("NV MAC address is not provisioned");
			priv->dms.nv_mac_not_prov = 1;
		} else {
			icnss_pr_err("QMI_DMS_GET_MAC_ADDRESS_REQ_V01 failed, result: %d, err: %d\n",
				     resp.resp.result, resp.resp.error);
		}
		ret = -resp.resp.result;
		goto out;
	}
	if (!resp.mac_address_valid ||
	    resp.mac_address_len != QMI_WLFW_MAC_ADDR_SIZE_V01) {
		icnss_pr_err("Invalid MAC address received from DMS\n");
		priv->dms.mac_valid = false;
		goto out;
	}
	priv->dms.mac_valid = true;
	memcpy(priv->dms.mac, resp.mac_address, QMI_WLFW_MAC_ADDR_SIZE_V01);
	icnss_pr_info("Received DMS MAC: [%pM]\n", priv->dms.mac);
out:
	return ret;
}

int icnss_wlfw_wlan_mac_req_send_sync(struct icnss_priv *priv,
				      u8 *mac, u32 mac_len)
{
	struct wlfw_mac_addr_req_msg_v01 req;
	struct wlfw_mac_addr_resp_msg_v01 resp = {0};
	struct qmi_txn txn;
	int ret;

	if (!priv || !mac || mac_len != QMI_WLFW_MAC_ADDR_SIZE_V01)
		return -EINVAL;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_mac_addr_resp_msg_v01_ei, &resp);
	if (ret < 0) {
		icnss_pr_err("Failed to initialize txn for mac req, err: %d\n",
			     ret);
		ret = -EIO;
		goto out;
	}

	icnss_pr_dbg("Sending WLAN mac req [%pM], state: 0x%lx\n",
			     mac, priv->state);
	memcpy(req.mac_addr, mac, mac_len);
	req.mac_addr_valid = 1;

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_MAC_ADDR_REQ_V01,
			       WLFW_MAC_ADDR_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_mac_addr_req_msg_v01_ei, &req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Failed to send mac req, err: %d\n", ret);
		ret = -EIO;
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("Failed to wait for resp of mac req, err: %d\n",
			     ret);
		ret = -EIO;
		goto out;
	}

	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("WLAN mac req failed, result: %d\n",
			     resp.resp.result);
		ret = -resp.resp.result;
	}
out:
	return ret;
}

static int icnss_dms_connect_to_server(struct icnss_priv *priv,
				      unsigned int node, unsigned int port)
{
	struct qmi_handle *qmi_dms = &priv->qmi_dms;
	struct sockaddr_qrtr sq = {0};
	int ret = 0;

	sq.sq_family = AF_QIPCRTR;
	sq.sq_node = node;
	sq.sq_port = port;

	ret = kernel_connect(qmi_dms->sock, (struct sockaddr *)&sq,
			     sizeof(sq), 0);
	if (ret < 0) {
		icnss_pr_err("Failed to connect to QMI DMS remote service Node: %d Port: %d\n",
			     node, port);
		goto out;
	}

	set_bit(ICNSS_QMI_DMS_CONNECTED, &priv->state);
	icnss_pr_info("QMI DMS service connected, state: 0x%lx\n",
		      priv->state);
out:
	return ret;
}

static int dms_new_server(struct qmi_handle *qmi_dms,
			  struct qmi_service *service)
{
	struct icnss_priv *priv =
		container_of(qmi_dms, struct icnss_priv, qmi_dms);

	if (!service)
		return -EINVAL;

	return icnss_dms_connect_to_server(priv, service->node,
					   service->port);
}

static void dms_del_server(struct qmi_handle *qmi_dms,
			   struct qmi_service *service)
{
	struct icnss_priv *priv =
		container_of(qmi_dms, struct icnss_priv, qmi_dms);

	clear_bit(ICNSS_QMI_DMS_CONNECTED, &priv->state);
	icnss_pr_info("QMI DMS service disconnected, state: 0x%lx\n",
		      priv->state);
}

static struct qmi_ops qmi_dms_ops = {
	.new_server = dms_new_server,
	.del_server = dms_del_server,
};

int icnss_dms_init(struct icnss_priv *priv)
{
	int ret = 0;

	ret = qmi_handle_init(&priv->qmi_dms, DMS_QMI_MAX_MSG_LEN,
			      &qmi_dms_ops, NULL);
	if (ret < 0) {
		icnss_pr_err("Failed to initialize DMS handle, err: %d\n", ret);
		goto out;
	}

	ret = qmi_add_lookup(&priv->qmi_dms, DMS_SERVICE_ID_V01,
			     DMS_SERVICE_VERS_V01, 0);
	if (ret < 0)
		icnss_pr_err("Failed to add DMS lookup, err: %d\n", ret);
out:
	return ret;
}

void icnss_dms_deinit(struct icnss_priv *priv)
{
	qmi_handle_release(&priv->qmi_dms);
}

static int icnss_get_bdf_file_name(struct icnss_priv *priv,
				   u32 bdf_type, char *filename,
				   u32 filename_len)
{
	char filename_tmp[ICNSS_MAX_FILE_NAME];
	char foundry_specific_filename[ICNSS_MAX_FILE_NAME];
	int ret = 0;

	switch (bdf_type) {
	case ICNSS_BDF_ELF:
		if (priv->board_id == 0xFF)
			snprintf(filename_tmp, filename_len, ELF_BDF_FILE_NAME);
		else if (priv->board_id < 0xFF)
			snprintf(filename_tmp, filename_len,
				 ELF_BDF_FILE_NAME_PREFIX "%02x",
				 priv->board_id);
		else
			snprintf(filename_tmp, filename_len,
				 BDF_FILE_NAME_PREFIX "%02x.e%02x",
				 priv->board_id >> 8 & 0xFF,
				 priv->board_id & 0xFF);
		break;
	case ICNSS_BDF_BIN:
		if (priv->board_id == 0xFF)
			snprintf(filename_tmp, filename_len, BIN_BDF_FILE_NAME);
		else if (priv->board_id >= WLAN_BOARD_ID_INDEX)
			snprintf(filename_tmp, filename_len,
				 BIN_BDF_FILE_NAME_PREFIX "%03x",
				 priv->board_id);
		else
			snprintf(filename_tmp, filename_len,
				 BIN_BDF_FILE_NAME_PREFIX "b%02x",
				 priv->board_id);
		if (priv->foundry_name) {
			strlcpy(foundry_specific_filename, filename_tmp, ICNSS_MAX_FILE_NAME);
			memmove(foundry_specific_filename + BDWLAN_SIZE + 1,
				foundry_specific_filename + BDWLAN_SIZE,
				BDWLAN_SIZE - 1);
			foundry_specific_filename[BDWLAN_SIZE] = priv->foundry_name;
			foundry_specific_filename[ICNSS_MAX_FILE_NAME - 1] = '\0';
			strlcpy(filename_tmp, foundry_specific_filename, ICNSS_MAX_FILE_NAME);
		}
		break;
	case ICNSS_BDF_REGDB:
		snprintf(filename_tmp, filename_len, REGDB_FILE_NAME);
		break;
	default:
		icnss_pr_err("Invalid BDF type: %d\n",
			     priv->ctrl_params.bdf_type);
		ret = -EINVAL;
		break;
	}

	if (!ret)
		icnss_add_fw_prefix_name(priv, filename, filename_tmp);

	return ret;
}

static char *icnss_bdf_type_to_str(enum icnss_bdf_type bdf_type)
{
	switch (bdf_type) {
	case ICNSS_BDF_BIN:
		return "BDF";
	case ICNSS_BDF_ELF:
		return "BDF";
	case ICNSS_BDF_REGDB:
		return "REGDB";
	default:
		return "UNKNOWN";
	}
};

int icnss_wlfw_bdf_dnld_send_sync(struct icnss_priv *priv, u32 bdf_type)
{
	struct wlfw_bdf_download_req_msg_v01 *req;
	struct wlfw_bdf_download_resp_msg_v01 *resp;
	struct qmi_txn txn;
	char filename[ICNSS_MAX_FILE_NAME];
	const struct firmware *fw_entry = NULL;
	const u8 *temp;
	unsigned int remaining;
	int ret = 0;

	icnss_pr_dbg("Sending %s download message, state: 0x%lx, type: %d\n",
		     icnss_bdf_type_to_str(bdf_type), priv->state, bdf_type);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	ret = icnss_get_bdf_file_name(priv, bdf_type,
				      filename, sizeof(filename));
	if (ret)
		goto err_req_fw;

	ret = firmware_request_nowarn(&fw_entry, filename, &priv->pdev->dev);
	if (ret) {
		icnss_pr_err("Failed to load %s: %s ret:%d\n",
			     icnss_bdf_type_to_str(bdf_type), filename, ret);
		goto err_req_fw;
	}

	temp = fw_entry->data;
	remaining = fw_entry->size;

	icnss_pr_dbg("Downloading %s: %s, size: %u\n",
		     icnss_bdf_type_to_str(bdf_type), filename, remaining);

	while (remaining) {
		req->valid = 1;
		req->file_id_valid = 1;
		req->file_id = priv->board_id;
		req->total_size_valid = 1;
		req->total_size = fw_entry->size;
		req->seg_id_valid = 1;
		req->data_valid = 1;
		req->end_valid = 1;
		req->bdf_type_valid = 1;
		req->bdf_type = bdf_type;

		if (remaining > QMI_WLFW_MAX_DATA_SIZE_V01) {
			req->data_len = QMI_WLFW_MAX_DATA_SIZE_V01;
		} else {
			req->data_len = remaining;
			req->end = 1;
		}

		memcpy(req->data, temp, req->data_len);

		ret = qmi_txn_init(&priv->qmi, &txn,
				   wlfw_bdf_download_resp_msg_v01_ei, resp);
		if (ret < 0) {
			icnss_pr_err("Failed to initialize txn for %s download request, err: %d\n",
				     icnss_bdf_type_to_str(bdf_type), ret);
			goto err_send;
		}

		ret = qmi_send_request
			(&priv->qmi, NULL, &txn,
			 QMI_WLFW_BDF_DOWNLOAD_REQ_V01,
			 WLFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_MSG_LEN,
			 wlfw_bdf_download_req_msg_v01_ei, req);
		if (ret < 0) {
			qmi_txn_cancel(&txn);
			icnss_pr_err("Failed to send respond %s download request, err: %d\n",
				     icnss_bdf_type_to_str(bdf_type), ret);
			goto err_send;
		}

		ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
		if (ret < 0) {
			icnss_pr_err("Failed to wait for response of %s download request, err: %d\n",
				     icnss_bdf_type_to_str(bdf_type), ret);
			goto err_send;
		}

		if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
			icnss_pr_err("%s download request failed, result: %d, err: %d\n",
				     icnss_bdf_type_to_str(bdf_type), resp->resp.result,
				     resp->resp.error);
			ret = -resp->resp.result;
			goto err_send;
		}

		remaining -= req->data_len;
		temp += req->data_len;
		req->seg_id++;
	}

	release_firmware(fw_entry);

	kfree(req);
	kfree(resp);
	return 0;

err_send:
	release_firmware(fw_entry);
err_req_fw:
	if (bdf_type != ICNSS_BDF_REGDB)
		ICNSS_QMI_ASSERT();
	kfree(req);
	kfree(resp);
	return ret;
}

int icnss_wlfw_qdss_data_send_sync(struct icnss_priv *priv, char *file_name,
				   u32 total_size)
{
	int ret = 0;
	struct wlfw_qdss_trace_data_req_msg_v01 *req;
	struct wlfw_qdss_trace_data_resp_msg_v01 *resp;
	unsigned char *p_qdss_trace_data_temp, *p_qdss_trace_data = NULL;
	unsigned int remaining;
	struct qmi_txn txn;

	icnss_pr_dbg("%s", __func__);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	p_qdss_trace_data = kzalloc(total_size, GFP_KERNEL);
	if (!p_qdss_trace_data) {
		ret = ENOMEM;
		goto end;
	}

	remaining = total_size;
	p_qdss_trace_data_temp = p_qdss_trace_data;
	while (remaining && resp->end == 0) {
		ret = qmi_txn_init(&priv->qmi, &txn,
				   wlfw_qdss_trace_data_resp_msg_v01_ei, resp);

		if (ret < 0) {
			icnss_pr_err("Fail to init txn for QDSS trace resp %d\n",
				     ret);
			goto fail;
		}

		ret = qmi_send_request
			(&priv->qmi, NULL, &txn,
			 QMI_WLFW_QDSS_TRACE_DATA_REQ_V01,
			 WLFW_QDSS_TRACE_DATA_REQ_MSG_V01_MAX_MSG_LEN,
			 wlfw_qdss_trace_data_req_msg_v01_ei, req);

		if (ret < 0) {
			qmi_txn_cancel(&txn);
			icnss_pr_err("Fail to send QDSS trace data req %d\n",
				     ret);
			goto fail;
		}

		ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);

		if (ret < 0) {
			icnss_pr_err("QDSS trace resp wait failed with rc %d\n",
				     ret);
			goto fail;
		} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
			icnss_pr_err("QMI QDSS trace request rejected, result:%d error:%d\n",
				     resp->resp.result, resp->resp.error);
				     ret = -resp->resp.result;
			goto fail;
		} else {
			ret = 0;
		}

		icnss_pr_dbg("%s: response total size  %d data len %d",
			     __func__, resp->total_size, resp->data_len);

		if ((resp->total_size_valid == 1 &&
		     resp->total_size == total_size) &&
		    (resp->seg_id_valid == 1 && resp->seg_id == req->seg_id) &&
		    (resp->data_valid == 1 &&
		     resp->data_len <= QMI_WLFW_MAX_DATA_SIZE_V01) &&
		    resp->data_len <= remaining) {
			memcpy(p_qdss_trace_data_temp,
			       resp->data, resp->data_len);
		} else {
			icnss_pr_err("%s: Unmatched qdss trace data, Expect total_size %u, seg_id %u, Recv total_size_valid %u, total_size %u, seg_id_valid %u, seg_id %u, data_len_valid %u, data_len %u",
				     __func__,
				     total_size, req->seg_id,
				     resp->total_size_valid,
				     resp->total_size,
				     resp->seg_id_valid,
				     resp->seg_id,
				     resp->data_valid,
				     resp->data_len);
			ret = -EINVAL;
			goto fail;
		}

		remaining -= resp->data_len;
		p_qdss_trace_data_temp += resp->data_len;
		req->seg_id++;
	}

	if (remaining == 0 && (resp->end_valid && resp->end)) {
		ret = icnss_genl_send_msg(p_qdss_trace_data,
					  ICNSS_GENL_MSG_TYPE_QDSS, file_name,
					  total_size);
		if (ret < 0) {
			icnss_pr_err("Fail to save QDSS trace data: %d\n",
				     ret);
		ret = -EINVAL;
		}
	} else {
		icnss_pr_err("%s: QDSS trace file corrupted: remaining %u, end_valid %u, end %u",
			     __func__,
			     remaining, resp->end_valid, resp->end);
		ret = -EINVAL;
	}

fail:
	kfree(p_qdss_trace_data);

end:
	kfree(req);
	kfree(resp);
	return ret;
}

int icnss_wlfw_qdss_dnld_send_sync(struct icnss_priv *priv)
{
	struct wlfw_qdss_trace_config_download_req_msg_v01 *req;
	struct wlfw_qdss_trace_config_download_resp_msg_v01 *resp;
	struct qmi_txn txn;
	char filename[ICNSS_MAX_FILE_NAME];
	const struct firmware *fw_entry = NULL;
	const u8 *temp;
	unsigned int remaining;
	int ret = 0;

	icnss_pr_dbg("Sending QDSS config download message, state: 0x%lx\n",
		     priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	icnss_add_fw_prefix_name(priv, filename, QDSS_TRACE_CONFIG_FILE);
	ret = firmware_request_nowarn(&fw_entry, filename,
				      &priv->pdev->dev);
	if (ret) {
		icnss_pr_err("Failed to load QDSS: %s ret:%d\n",
			     filename, ret);
		goto err_req_fw;
	}

	temp = fw_entry->data;
	remaining = fw_entry->size;

	icnss_pr_dbg("Downloading QDSS: %s, size: %u\n",
		     filename, remaining);

	while (remaining) {
		req->total_size_valid = 1;
		req->total_size = remaining;
		req->seg_id_valid = 1;
		req->data_valid = 1;
		req->end_valid = 1;

		if (remaining > QMI_WLFW_MAX_DATA_SIZE_V01) {
			req->data_len = QMI_WLFW_MAX_DATA_SIZE_V01;
		} else {
			req->data_len = remaining;
			req->end = 1;
		}

		memcpy(req->data, temp, req->data_len);

		ret = qmi_txn_init
			(&priv->qmi, &txn,
			 wlfw_qdss_trace_config_download_resp_msg_v01_ei,
			 resp);
		if (ret < 0) {
			icnss_pr_err("Failed to initialize txn for QDSS download request, err: %d\n",
				     ret);
			goto err_send;
		}

		ret = qmi_send_request
		      (&priv->qmi, NULL, &txn,
		       QMI_WLFW_QDSS_TRACE_CONFIG_DOWNLOAD_REQ_V01,
		       WLFW_QDSS_TRACE_CONFIG_DOWNLOAD_REQ_MSG_V01_MAX_MSG_LEN,
		       wlfw_qdss_trace_config_download_req_msg_v01_ei, req);
		if (ret < 0) {
			qmi_txn_cancel(&txn);
			icnss_pr_err("Failed to send respond QDSS download request, err: %d\n",
				     ret);
			goto err_send;
		}

		ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
		if (ret < 0) {
			icnss_pr_err("Failed to wait for response of QDSS download request, err: %d\n",
				     ret);
			goto err_send;
		}

		if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
			icnss_pr_err("QDSS download request failed, result: %d, err: %d\n",
				     resp->resp.result, resp->resp.error);
			ret = -resp->resp.result;
			goto err_send;
		}

		remaining -= req->data_len;
		temp += req->data_len;
		req->seg_id++;
	}

	release_firmware(fw_entry);
	kfree(req);
	kfree(resp);
	return 0;

err_send:
	release_firmware(fw_entry);
err_req_fw:

	kfree(req);
	kfree(resp);
	return ret;
}

int wlfw_wlan_mode_send_sync_msg(struct icnss_priv *priv,
		enum wlfw_driver_mode_enum_v01 mode)
{
	int ret;
	struct wlfw_wlan_mode_req_msg_v01 *req;
	struct wlfw_wlan_mode_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	/* During recovery do not send mode request for WLAN OFF as
	 * FW not able to process it.
	 */
	if (test_bit(ICNSS_PD_RESTART, &priv->state) &&
	    mode == QMI_WLFW_OFF_V01)
		return 0;

	if (!test_bit(ICNSS_MODE_ON, &priv->state) &&
	    mode == QMI_WLFW_OFF_V01)
		return 0;

	icnss_pr_dbg("Sending Mode request, state: 0x%lx, mode: %d\n",
		     priv->state, mode);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->mode = mode;
	req->hw_debug_valid = 1;
	req->hw_debug = !!test_bit(HW_DEBUG_ENABLE, &priv->ctrl_params.quirks);

	if (priv->wlan_en_delay_ms >= 100) {
		icnss_pr_dbg("Setting WLAN_EN delay: %d ms\n",
			     priv->wlan_en_delay_ms);
		req->wlan_en_delay_valid = 1;
		req->wlan_en_delay = priv->wlan_en_delay_ms;
	}

	priv->stats.mode_req++;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_wlan_mode_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_qmi_fatal_err("Fail to init txn for Mode resp %d\n", ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_WLAN_MODE_REQ_V01,
			       WLFW_WLAN_MODE_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_wlan_mode_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send Mode req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn,
			   priv->ctrl_params.qmi_timeout +
			   msecs_to_jiffies(priv->wlan_en_delay_ms));
	if (ret < 0) {
		icnss_qmi_fatal_err("Mode resp wait failed with ret %d\n", ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_qmi_fatal_err(
			"QMI Mode request rejected, result:%d error:%d\n",
			resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	priv->stats.mode_resp++;

	if (mode == QMI_WLFW_OFF_V01) {
		icnss_pr_dbg("Clear mode on 0x%lx, mode: %d\n",
			     priv->state, mode);
		clear_bit(ICNSS_MODE_ON, &priv->state);
	} else {
		icnss_pr_dbg("Set mode on 0x%lx, mode: %d\n",
			     priv->state, mode);
		set_bit(ICNSS_MODE_ON, &priv->state);
	}

	kfree(resp);
	kfree(req);
	return 0;

out:
	kfree(resp);
	kfree(req);
	priv->stats.mode_req_err++;
	return ret;
}

static int wlfw_send_qdss_trace_mode_req
		(struct icnss_priv *priv,
		 enum wlfw_qdss_trace_mode_enum_v01 mode,
		 unsigned long long option)
{
	int rc = 0;
	int tmp = 0;
	struct wlfw_qdss_trace_mode_req_msg_v01 *req;
	struct wlfw_qdss_trace_mode_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->mode_valid = 1;
	req->mode = mode;
	req->option_valid = 1;
	req->option = option;

	tmp = priv->hw_trc_override;

	req->hw_trc_disable_override_valid = 1;
	req->hw_trc_disable_override =
	(tmp > QMI_PARAM_DISABLE_V01 ? QMI_PARAM_DISABLE_V01 :
		 (tmp < 0 ? QMI_PARAM_INVALID_V01 : tmp));

	icnss_pr_dbg("%s: mode %u, option %llu, hw_trc_disable_override: %u",
		     __func__, mode, option, req->hw_trc_disable_override);

	rc = qmi_txn_init(&priv->qmi, &txn,
			  wlfw_qdss_trace_mode_resp_msg_v01_ei, resp);
	if (rc < 0) {
		icnss_qmi_fatal_err("Fail to init txn for QDSS Mode resp %d\n",
				    rc);
		goto out;
	}

	rc = qmi_send_request(&priv->qmi, NULL, &txn,
			      QMI_WLFW_QDSS_TRACE_MODE_REQ_V01,
			      WLFW_QDSS_TRACE_MODE_REQ_MSG_V01_MAX_MSG_LEN,
			      wlfw_qdss_trace_mode_req_msg_v01_ei, req);
	if (rc < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send QDSS Mode req %d\n", rc);
		goto out;
	}

	rc = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (rc < 0) {
		icnss_qmi_fatal_err("QDSS Mode resp wait failed with rc %d\n",
				    rc);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_qmi_fatal_err(
			"QMI QDSS Mode request rejected, result:%d error:%d\n",
			resp->resp.result, resp->resp.error);
		rc = -resp->resp.result;
		goto out;
	}

out:
	kfree(resp);
	kfree(req);
	return rc;
}

int wlfw_qdss_trace_start(struct icnss_priv *priv)
{
	return wlfw_send_qdss_trace_mode_req(priv,
					     QMI_WLFW_QDSS_TRACE_ON_V01, 0);
}

int wlfw_qdss_trace_stop(struct icnss_priv *priv, unsigned long long option)
{
	return wlfw_send_qdss_trace_mode_req(priv, QMI_WLFW_QDSS_TRACE_OFF_V01,
					     option);
}

int wlfw_wlan_cfg_send_sync_msg(struct icnss_priv *priv,
				struct wlfw_wlan_cfg_req_msg_v01 *data)
{
	int ret;
	struct wlfw_wlan_cfg_req_msg_v01 *req;
	struct wlfw_wlan_cfg_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	icnss_pr_dbg("Sending config request, state: 0x%lx\n", priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	memcpy(req, data, sizeof(*req));

	priv->stats.cfg_req++;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_wlan_cfg_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_qmi_fatal_err("Fail to init txn for Config resp %d\n",
				    ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_WLAN_CFG_REQ_V01,
			       WLFW_WLAN_CFG_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_wlan_cfg_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send Config req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_qmi_fatal_err("Config resp wait failed with ret %d\n",
				    ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_qmi_fatal_err(
			"QMI Config request rejected, result:%d error:%d\n",
			resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	priv->stats.cfg_resp++;

	kfree(resp);
	kfree(req);
	return 0;

out:
	kfree(resp);
	kfree(req);
	priv->stats.cfg_req_err++;
	return ret;
}

int wlfw_send_modem_shutdown_msg(struct icnss_priv *priv)
{
	int ret;
	struct wlfw_shutdown_req_msg_v01 *req;
	struct wlfw_shutdown_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	if (test_bit(ICNSS_FW_DOWN, &priv->state))
		return -EINVAL;

	icnss_pr_dbg("Sending modem shutdown request, state: 0x%lx\n",
		     priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->shutdown_valid = 1;
	req->shutdown = 1;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_shutdown_resp_msg_v01_ei, resp);

	if (ret < 0) {
		icnss_pr_err("Fail to init txn for shutdown resp %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_SHUTDOWN_REQ_V01,
			       WLFW_SHUTDOWN_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_shutdown_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Fail to send Shutdown req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("Shutdown resp wait failed with ret %d\n",
			     ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("QMI modem shutdown request rejected result:%d error:%d\n",
			     resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

out:
	kfree(resp);
	kfree(req);
	return ret;
}

int wlfw_ini_send_sync_msg(struct icnss_priv *priv, uint8_t fw_log_mode)
{
	int ret;
	struct wlfw_ini_req_msg_v01 *req;
	struct wlfw_ini_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	icnss_pr_dbg("Sending ini sync request, state: 0x%lx, fw_log_mode: %d\n",
		     priv->state, fw_log_mode);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->enablefwlog_valid = 1;
	req->enablefwlog = fw_log_mode;

	priv->stats.ini_req++;

	ret = qmi_txn_init(&priv->qmi, &txn, wlfw_ini_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_qmi_fatal_err("Fail to init txn for INI resp %d\n", ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_INI_REQ_V01,
			       WLFW_INI_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_ini_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send INI req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_qmi_fatal_err("INI resp wait failed with ret %d\n", ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_qmi_fatal_err(
			"QMI INI request rejected, result:%d error:%d\n",
			resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	priv->stats.ini_resp++;

	kfree(resp);
	kfree(req);
	return 0;

out:
	kfree(resp);
	kfree(req);
	priv->stats.ini_req_err++;
	return ret;
}

int wlfw_athdiag_read_send_sync_msg(struct icnss_priv *priv,
					   uint32_t offset, uint32_t mem_type,
					   uint32_t data_len, uint8_t *data)
{
	int ret;
	struct wlfw_athdiag_read_req_msg_v01 *req;
	struct wlfw_athdiag_read_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	icnss_pr_dbg("Diag read: state 0x%lx, offset %x, mem_type %x, data_len %u\n",
		     priv->state, offset, mem_type, data_len);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return  -ENOMEM;
	}

	req->offset = offset;
	req->mem_type = mem_type;
	req->data_len = data_len;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_athdiag_read_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_pr_err("Fail to init txn for Athdiag Read resp %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_ATHDIAG_READ_REQ_V01,
			       WLFW_ATHDIAG_READ_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_athdiag_read_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Fail to send Athdiag Read req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("Athdaig Read resp wait failed with ret %d\n",
			     ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("QMI Athdiag Read request rejected, result:%d error:%d\n",
			resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	} else {
		ret = 0;
	}

	if (!resp->data_valid || resp->data_len < data_len) {
		icnss_pr_err("Athdiag read data is invalid, data_valid = %u, data_len = %u\n",
			     resp->data_valid, resp->data_len);
		ret = -EINVAL;
		goto out;
	}

	memcpy(data, resp->data, resp->data_len);

out:
	kfree(resp);
	kfree(req);
	return ret;
}

int wlfw_athdiag_write_send_sync_msg(struct icnss_priv *priv,
					    uint32_t offset, uint32_t mem_type,
					    uint32_t data_len, uint8_t *data)
{
	int ret;
	struct wlfw_athdiag_write_req_msg_v01 *req;
	struct wlfw_athdiag_write_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	icnss_pr_dbg("Diag write: state 0x%lx, offset %x, mem_type %x, data_len %u, data %pK\n",
		     priv->state, offset, mem_type, data_len, data);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->offset = offset;
	req->mem_type = mem_type;
	req->data_len = data_len;
	memcpy(req->data, data, data_len);

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_athdiag_write_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_pr_err("Fail to init txn for Athdiag Write resp %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_ATHDIAG_WRITE_REQ_V01,
			       WLFW_ATHDIAG_WRITE_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_athdiag_write_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Fail to send Athdiag Write req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("Athdiag Write resp wait failed with ret %d\n",
			     ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("QMI Athdiag Write request rejected, result:%d error:%d\n",
			resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	} else {
		ret = 0;
	}

out:
	kfree(resp);
	kfree(req);
	return ret;
}

int wlfw_rejuvenate_ack_send_sync_msg(struct icnss_priv *priv)
{
	int ret;
	struct wlfw_rejuvenate_ack_req_msg_v01 *req;
	struct wlfw_rejuvenate_ack_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	icnss_pr_dbg("Sending rejuvenate ack request, state: 0x%lx\n",
		     priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	priv->stats.rejuvenate_ack_req++;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_rejuvenate_ack_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_qmi_fatal_err(
			"Fail to init txn for Rejuvenate Ack resp %d\n",
			 ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_REJUVENATE_ACK_REQ_V01,
			       WLFW_REJUVENATE_ACK_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_rejuvenate_ack_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_qmi_fatal_err("Fail to send Rejuvenate Ack req %d\n",
				    ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_qmi_fatal_err(
			     "Rejuvenate Ack resp wait failed with ret %d\n",
			     ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_qmi_fatal_err(
		   "QMI Rejuvenate Ack request rejected, result:%d error:%d\n",
		    resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	priv->stats.rejuvenate_ack_resp++;

	kfree(resp);
	kfree(req);
	return 0;

out:
	kfree(resp);
	kfree(req);
	priv->stats.rejuvenate_ack_err++;
	return ret;
}

int wlfw_dynamic_feature_mask_send_sync_msg(struct icnss_priv *priv,
					   uint64_t dynamic_feature_mask)
{
	int ret;
	struct wlfw_dynamic_feature_mask_req_msg_v01 *req;
	struct wlfw_dynamic_feature_mask_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	if (!test_bit(ICNSS_WLFW_CONNECTED, &priv->state)) {
		icnss_pr_err("Invalid state for dynamic feature: 0x%lx\n",
			     priv->state);
		return -EINVAL;
	}

	if (!test_bit(FW_REJUVENATE_ENABLE, &priv->ctrl_params.quirks)) {
		icnss_pr_dbg("FW rejuvenate is disabled from quirks\n");
		return 0;
	}

	icnss_pr_dbg("Sending dynamic feature mask request, val 0x%llx, state: 0x%lx\n",
		     dynamic_feature_mask, priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->mask_valid = 1;
	req->mask = dynamic_feature_mask;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_dynamic_feature_mask_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_pr_err("Fail to init txn for Dynamic Feature Mask resp %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
		       QMI_WLFW_DYNAMIC_FEATURE_MASK_REQ_V01,
		       WLFW_DYNAMIC_FEATURE_MASK_REQ_MSG_V01_MAX_MSG_LEN,
		       wlfw_dynamic_feature_mask_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Fail to send Dynamic Feature Mask req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("Dynamic Feature Mask resp wait failed with ret %d\n",
			     ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("QMI Dynamic Feature Mask request rejected, result:%d error:%d\n",
			resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	icnss_pr_dbg("prev_mask_valid %u, prev_mask 0x%llx, curr_maks_valid %u, curr_mask 0x%llx\n",
		     resp->prev_mask_valid, resp->prev_mask,
		     resp->curr_mask_valid, resp->curr_mask);

out:
	kfree(resp);
	kfree(req);
	return ret;
}

void icnss_handle_rejuvenate(struct icnss_priv *priv)
{
	struct icnss_event_pd_service_down_data *event_data;
	struct icnss_uevent_fw_down_data fw_down_data = {0};

	event_data = kzalloc(sizeof(*event_data), GFP_KERNEL);
	if (event_data == NULL)
		return;

	event_data->crashed = true;
	event_data->fw_rejuvenate = true;
	fw_down_data.crashed = true;
	set_bit(ICNSS_REJUVENATE, &priv->state);

	icnss_call_driver_uevent(priv, ICNSS_UEVENT_FW_DOWN,
				 &fw_down_data);
	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_PD_SERVICE_DOWN,
				0, event_data);
}

int wlfw_qdss_trace_mem_info_send_sync(struct icnss_priv *priv)
{
	struct wlfw_qdss_trace_mem_info_req_msg_v01 *req;
	struct wlfw_qdss_trace_mem_info_resp_msg_v01 *resp;
	struct qmi_txn txn;
	struct icnss_fw_mem *qdss_mem = priv->qdss_mem;
	int ret = 0;
	int i;

	if (test_bit(ICNSS_FW_DOWN, &priv->state))
		return -EINVAL;

	icnss_pr_dbg("Sending QDSS trace mem info, state: 0x%lx\n",
		     priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->mem_seg_len = priv->qdss_mem_seg_len;

	if (priv->qdss_mem_seg_len >  QMI_WLFW_MAX_NUM_MEM_SEG_V01) {
		icnss_pr_err("Invalid seg len %u\n",
			     priv->qdss_mem_seg_len);
		ret = -EINVAL;
		goto out;
	}

	for (i = 0; i < req->mem_seg_len; i++) {
		icnss_pr_dbg("Memory for FW, va: 0x%pK, pa: %pa, size: 0x%zx, type: %u\n",
			     qdss_mem[i].va, &qdss_mem[i].pa,
			     qdss_mem[i].size, qdss_mem[i].type);

		req->mem_seg[i].addr = qdss_mem[i].pa;
		req->mem_seg[i].size = qdss_mem[i].size;
		req->mem_seg[i].type = qdss_mem[i].type;
	}

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_qdss_trace_mem_info_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_pr_err("Fail to initialize txn for QDSS trace mem request: err %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_QDSS_TRACE_MEM_INFO_REQ_V01,
			       WLFW_QDSS_TRACE_MEM_INFO_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_qdss_trace_mem_info_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Fail to send QDSS trace mem info request: err %d\n",
			     ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("Fail to wait for response of QDSS trace mem info request, err %d\n",
			     ret);
		goto out;
	}

	if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("QDSS trace mem info request failed, result: %d, err: %d\n",
			     resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	kfree(req);
	kfree(resp);
	return 0;

out:
	kfree(req);
	kfree(resp);
	return ret;
}

int icnss_wlfw_m3_dump_upload_done_send_sync(struct icnss_priv *priv,
					     u32 pdev_id, int status)
{
	struct wlfw_m3_dump_upload_done_req_msg_v01 *req;
	struct wlfw_m3_dump_upload_done_resp_msg_v01 *resp;
	struct qmi_txn txn;
	int ret = 0;

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	icnss_pr_dbg("Sending M3 Upload done req, pdev %d, status %d\n",
		     pdev_id, status);

	req->pdev_id = pdev_id;
	req->status = status;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_m3_dump_upload_done_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_pr_err("Fail to initialize txn for M3 dump upload done req: err %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_M3_DUMP_UPLOAD_DONE_REQ_V01,
			       WLFW_M3_DUMP_UPLOAD_DONE_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_m3_dump_upload_done_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Fail to send M3 dump upload done request: err %d\n",
			     ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("Fail to wait for response of M3 dump upload done request, err %d\n",
			     ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("M3 Dump Upload Done Req failed, result: %d, err: 0x%X\n",
			     resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

out:
	kfree(req);
	kfree(resp);
	return ret;
}

static void fw_ready_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
			    struct qmi_txn *txn, const void *data)
{
	struct icnss_priv *priv =
		container_of(qmi, struct icnss_priv, qmi);

	icnss_pr_dbg("Received FW Ready Indication\n");

	if (!txn) {
		pr_err("spurious indication\n");
		return;
	}

	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_FW_READY_IND,
				0, NULL);
}

static void msa_ready_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
			     struct qmi_txn *txn, const void *data)
{
	struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi);
	struct device *dev = &priv->pdev->dev;
	const struct wlfw_msa_ready_ind_msg_v01 *ind_msg = data;
	uint64_t msa_base_addr = priv->msa_pa;
	phys_addr_t hang_data_phy_addr;

	icnss_pr_dbg("Received MSA Ready Indication\n");

	if (!txn) {
		pr_err("spurious indication\n");
		return;
	}

	priv->stats.msa_ready_ind++;

	/* Check if the length is valid &
	 * the length should not be 0 and
	 * should be <=  WLFW_MAX_HANG_EVENT_DATA_SIZE(400)
	 */

	if (ind_msg->hang_data_length_valid &&
	    ind_msg->hang_data_length &&
	    ind_msg->hang_data_length <= WLFW_MAX_HANG_EVENT_DATA_SIZE)
		priv->hang_event_data_len = ind_msg->hang_data_length;
	else
		goto out;

	/* Check if the offset is valid &
	 * the offset should be in range of 0 to msa_mem_size-hang_data_length
	 */

	if (ind_msg->hang_data_addr_offset_valid &&
	    (ind_msg->hang_data_addr_offset <= (priv->msa_mem_size -
						 ind_msg->hang_data_length)))
		hang_data_phy_addr = msa_base_addr +
						ind_msg->hang_data_addr_offset;
	else
		goto out;

	if (priv->hang_event_data_pa == hang_data_phy_addr)
		goto exit;

	priv->hang_event_data_pa = hang_data_phy_addr;
	priv->hang_event_data_va = devm_ioremap(dev, priv->hang_event_data_pa,
						ind_msg->hang_data_length);

	if (!priv->hang_event_data_va) {
		icnss_pr_err("Hang Data ioremap failed: phy addr: %pa\n",
			     &priv->hang_event_data_pa);
		goto fail;
	}
exit:
	icnss_pr_dbg("Hang Event Data details,Offset:0x%x, Length:0x%x,va_addr: 0x%pK\n",
		     ind_msg->hang_data_addr_offset,
		     ind_msg->hang_data_length,
		     priv->hang_event_data_va);

	return;

out:
	icnss_pr_err("Invalid Hang Data details, Offset:0x%x, Length:0x%x",
		     ind_msg->hang_data_addr_offset,
		     ind_msg->hang_data_length);
fail:
	priv->hang_event_data_va = NULL;
	priv->hang_event_data_pa = 0;
	priv->hang_event_data_len = 0;
}

static void pin_connect_result_ind_cb(struct qmi_handle *qmi,
				      struct sockaddr_qrtr *sq,
				      struct qmi_txn *txn, const void *data)
{
	struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi);
	const struct wlfw_pin_connect_result_ind_msg_v01 *ind_msg = data;

	icnss_pr_dbg("Received Pin Connect Result Indication\n");

	if (!txn) {
		pr_err("spurious indication\n");
		return;
	}

	if (ind_msg->pwr_pin_result_valid)
		priv->pwr_pin_result = ind_msg->pwr_pin_result;
	if (ind_msg->phy_io_pin_result_valid)
		priv->phy_io_pin_result = ind_msg->phy_io_pin_result;
	if (ind_msg->rf_pin_result_valid)
		priv->rf_pin_result = ind_msg->rf_pin_result;

	icnss_pr_dbg("Pin connect Result: pwr_pin: 0x%x phy_io_pin: 0x%x rf_io_pin: 0x%x\n",
		     ind_msg->pwr_pin_result, ind_msg->phy_io_pin_result,
		     ind_msg->rf_pin_result);
	priv->stats.pin_connect_result++;
}

static void rejuvenate_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
			      struct qmi_txn *txn, const void *data)
{
	struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi);
	const struct wlfw_rejuvenate_ind_msg_v01 *ind_msg = data;

	icnss_pr_dbg("Received Rejuvenate Indication\n");

	if (!txn) {
		pr_err("spurious indication\n");
		return;
	}

	icnss_ignore_fw_timeout(true);

	if (ind_msg->cause_for_rejuvenation_valid)
		priv->cause_for_rejuvenation = ind_msg->cause_for_rejuvenation;
	else
		priv->cause_for_rejuvenation = 0;
	if (ind_msg->requesting_sub_system_valid)
		priv->requesting_sub_system = ind_msg->requesting_sub_system;
	else
		priv->requesting_sub_system = 0;
	if (ind_msg->line_number_valid)
		priv->line_number = ind_msg->line_number;
	else
		priv->line_number = 0;
	if (ind_msg->function_name_valid)
		memcpy(priv->function_name, ind_msg->function_name,
		       QMI_WLFW_FUNCTION_NAME_LEN_V01 + 1);
	else
		memset(priv->function_name, 0,
		       QMI_WLFW_FUNCTION_NAME_LEN_V01 + 1);

	icnss_pr_info("Cause for rejuvenation: 0x%x, requesting sub-system: 0x%x, line number: %u, function name: %s\n",
		      priv->cause_for_rejuvenation,
		      priv->requesting_sub_system,
		      priv->line_number,
		      priv->function_name);

	priv->stats.rejuvenate_ind++;

	icnss_handle_rejuvenate(priv);
}

static void cal_done_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
			    struct qmi_txn *txn, const void *data)
{
	struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi);

	icnss_pr_dbg("Received QMI WLFW calibration done indication\n");

	if (!txn) {
		icnss_pr_err("Spurious indication\n");
		return;
	}

	priv->cal_done = true;
	clear_bit(ICNSS_COLD_BOOT_CAL, &priv->state);
}

static void fw_init_done_ind_cb(struct qmi_handle *qmi,
				struct sockaddr_qrtr *sq,
				struct qmi_txn *txn, const void *data)
{
	struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi);
	struct device *dev = &priv->pdev->dev;
	const struct wlfw_fw_init_done_ind_msg_v01 *ind_msg = data;
	uint64_t msa_base_addr = priv->msa_pa;
	phys_addr_t hang_data_phy_addr;

	icnss_pr_dbg("Received QMI WLFW FW initialization done indication\n");

	if (!txn) {
		icnss_pr_err("Spurious indication\n");
		return;
	}

	/* Check if the length is valid &
	 * the length should not be 0 and
	 * should be <=  WLFW_MAX_HANG_EVENT_DATA_SIZE(400)
	 */

	if (ind_msg->hang_data_length_valid &&
	ind_msg->hang_data_length &&
	ind_msg->hang_data_length <= WLFW_MAX_HANG_EVENT_DATA_SIZE)
		priv->hang_event_data_len = ind_msg->hang_data_length;
	else
		goto out;

	/* Check if the offset is valid &
	 * the offset should be in range of 0 to msa_mem_size-hang_data_length
	 */

	if (ind_msg->hang_data_addr_offset_valid &&
	    (ind_msg->hang_data_addr_offset <= (priv->msa_mem_size -
					ind_msg->hang_data_length)))
		hang_data_phy_addr = msa_base_addr +
					ind_msg->hang_data_addr_offset;
	else
		goto out;

	if (priv->hang_event_data_pa == hang_data_phy_addr)
		goto exit;

	priv->hang_event_data_pa = hang_data_phy_addr;
	priv->hang_event_data_va = devm_ioremap(dev, priv->hang_event_data_pa,
					ind_msg->hang_data_length);

	if (!priv->hang_event_data_va) {
		icnss_pr_err("Hang Data ioremap failed: phy addr: %pa\n",
		&priv->hang_event_data_pa);
		goto fail;
	}

exit:
	icnss_pr_dbg("Hang Event Data details,Offset:0x%x, Length:0x%x,va_addr: 0x%pK\n",
		     ind_msg->hang_data_addr_offset,
		     ind_msg->hang_data_length,
		     priv->hang_event_data_va);

	goto post;

out:
	icnss_pr_err("Invalid Hang Data details, Offset:0x%x, Length:0x%x",
		     ind_msg->hang_data_addr_offset,
		     ind_msg->hang_data_length);
fail:
	priv->hang_event_data_va = NULL;
	priv->hang_event_data_pa = 0;
	priv->hang_event_data_len = 0;
post:
	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_FW_INIT_DONE_IND,
				0, NULL);

}

static void wlfw_qdss_trace_req_mem_ind_cb(struct qmi_handle *qmi,
					   struct sockaddr_qrtr *sq,
					   struct qmi_txn *txn,
					   const void *data)
{
	struct icnss_priv *priv =
		container_of(qmi, struct icnss_priv, qmi);
	const struct wlfw_qdss_trace_req_mem_ind_msg_v01 *ind_msg = data;
	int i;

	icnss_pr_dbg("Received QMI WLFW QDSS trace request mem indication\n");

	if (!txn) {
		icnss_pr_err("Spurious indication\n");
		return;
	}

	if (priv->qdss_mem_seg_len) {
		icnss_pr_err("Ignore double allocation for QDSS trace, current len %u\n",
			     priv->qdss_mem_seg_len);
		return;
	}

	priv->qdss_mem_seg_len = ind_msg->mem_seg_len;

	if (priv->qdss_mem_seg_len > QMI_WLFW_MAX_NUM_MEM_SEG_V01) {
		icnss_pr_err("Invalid seg len %u\n",
			     priv->qdss_mem_seg_len);
		return;
	}

	for (i = 0; i < priv->qdss_mem_seg_len; i++) {
		icnss_pr_dbg("QDSS requests for memory, size: 0x%x, type: %u\n",
			     ind_msg->mem_seg[i].size,
			     ind_msg->mem_seg[i].type);
		priv->qdss_mem[i].type = ind_msg->mem_seg[i].type;
		priv->qdss_mem[i].size = ind_msg->mem_seg[i].size;
	}

	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_QDSS_TRACE_REQ_MEM,
				0, NULL);
}

static void wlfw_qdss_trace_save_ind_cb(struct qmi_handle *qmi,
					struct sockaddr_qrtr *sq,
					struct qmi_txn *txn,
					const void *data)
{
	struct icnss_priv *priv =
		container_of(qmi, struct icnss_priv, qmi);
	const struct wlfw_qdss_trace_save_ind_msg_v01 *ind_msg = data;
	struct icnss_qmi_event_qdss_trace_save_data *event_data;
	int i = 0;

	icnss_pr_dbg("Received QMI WLFW QDSS trace save indication\n");

	if (!txn) {
		icnss_pr_err("Spurious indication\n");
		return;
	}

	icnss_pr_dbg("QDSS_trace_save info: source %u, total_size %u, file_name_valid %u, file_name %s\n",
		     ind_msg->source, ind_msg->total_size,
		     ind_msg->file_name_valid, ind_msg->file_name);

	event_data = kzalloc(sizeof(*event_data), GFP_KERNEL);
	if (!event_data)
		return;

	if (ind_msg->mem_seg_valid) {
		if (ind_msg->mem_seg_len > QDSS_TRACE_SEG_LEN_MAX) {
			icnss_pr_err("Invalid seg len %u\n",
				     ind_msg->mem_seg_len);
			goto free_event_data;
		}
		icnss_pr_dbg("QDSS_trace_save seg len %u\n",
			     ind_msg->mem_seg_len);
		event_data->mem_seg_len = ind_msg->mem_seg_len;
		for (i = 0; i < ind_msg->mem_seg_len; i++) {
			event_data->mem_seg[i].addr = ind_msg->mem_seg[i].addr;
			event_data->mem_seg[i].size = ind_msg->mem_seg[i].size;
			icnss_pr_dbg("seg-%d: addr 0x%llx size 0x%x\n",
				     i, ind_msg->mem_seg[i].addr,
				     ind_msg->mem_seg[i].size);
		}
	}

	event_data->total_size = ind_msg->total_size;

	if (ind_msg->file_name_valid)
		strlcpy(event_data->file_name, ind_msg->file_name,
			QDSS_TRACE_FILE_NAME_MAX + 1);

	if (ind_msg->source == 1) {
		if (!ind_msg->file_name_valid)
			strlcpy(event_data->file_name, "qdss_trace_wcss_etb",
				QDSS_TRACE_FILE_NAME_MAX + 1);
	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_QDSS_TRACE_REQ_DATA,
				0, event_data);
	} else {
		if (!ind_msg->file_name_valid)
			strlcpy(event_data->file_name, "qdss_trace_ddr",
				QDSS_TRACE_FILE_NAME_MAX + 1);
	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_QDSS_TRACE_SAVE,
				0, event_data);
	}

	return;

free_event_data:
	kfree(event_data);
}

static void wlfw_qdss_trace_free_ind_cb(struct qmi_handle *qmi,
					struct sockaddr_qrtr *sq,
					struct qmi_txn *txn,
					const void *data)
{
	struct icnss_priv *priv =
		container_of(qmi, struct icnss_priv, qmi);

	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_QDSS_TRACE_FREE,
				0, NULL);
}

static void icnss_wlfw_respond_get_info_ind_cb(struct qmi_handle *qmi,
					      struct sockaddr_qrtr *sq,
					      struct qmi_txn *txn,
					      const void *data)
{
	struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi);
	const struct wlfw_respond_get_info_ind_msg_v01 *ind_msg = data;

	if (!txn) {
		icnss_pr_err("Spurious indication\n");
		return;
	}

	icnss_pr_vdbg("Extract message with event length: %d, type: %d, is last: %d, seq no: %d\n",
		     ind_msg->data_len, ind_msg->type,
		     ind_msg->is_last, ind_msg->seq_no);

	if (priv->get_info_cb_ctx && priv->get_info_cb)
		priv->get_info_cb(priv->get_info_cb_ctx,
				       (void *)ind_msg->data,
				       ind_msg->data_len);
}

static void icnss_wlfw_m3_dump_upload_segs_req_ind_cb(struct qmi_handle *qmi,
						      struct sockaddr_qrtr *sq,
						      struct qmi_txn *txn,
						      const void *d)
{
	struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi);
	const struct wlfw_m3_dump_upload_segments_req_ind_msg_v01 *ind_msg = d;
	struct icnss_m3_upload_segments_req_data *event_data = NULL;
	u64 max_mapped_addr = 0;
	u64 segment_addr = 0;
	int i = 0;

	icnss_pr_dbg("Received QMI WLFW M3 dump upload sigments indication\n");

	if (!txn) {
		icnss_pr_err("Spurious indication\n");
		return;
	}

	icnss_pr_dbg("M3 Dump upload info: pdev_id: %d no_of_segments: %d\n",
		     ind_msg->pdev_id, ind_msg->no_of_valid_segments);

	if (ind_msg->no_of_valid_segments > QMI_WLFW_MAX_M3_SEGMENTS_SIZE_V01)
		return;

	event_data = kzalloc(sizeof(*event_data), GFP_KERNEL);
	if (!event_data)
		return;

	event_data->pdev_id = ind_msg->pdev_id;
	event_data->no_of_valid_segments = ind_msg->no_of_valid_segments;
	max_mapped_addr = priv->msa_pa + priv->msa_mem_size;

	for (i = 0; i < ind_msg->no_of_valid_segments; i++) {
		segment_addr = ind_msg->m3_segment[i].addr &
				M3_SEGMENT_ADDR_MASK;

		if (ind_msg->m3_segment[i].size > priv->msa_mem_size ||
		    segment_addr >= max_mapped_addr ||
		    segment_addr < priv->msa_pa ||
		    ind_msg->m3_segment[i].size +
		    segment_addr > max_mapped_addr) {
			icnss_pr_dbg("Received out of range Segment %d Addr: 0x%llx Size: 0x%x, Name: %s, type: %d\n",
				     (i + 1), segment_addr,
				     ind_msg->m3_segment[i].size,
				     ind_msg->m3_segment[i].name,
				     ind_msg->m3_segment[i].type);
			goto out;
		}

		event_data->m3_segment[i].addr = segment_addr;
		event_data->m3_segment[i].size = ind_msg->m3_segment[i].size;
		event_data->m3_segment[i].type = ind_msg->m3_segment[i].type;
		strlcpy(event_data->m3_segment[i].name,
			ind_msg->m3_segment[i].name,
			WLFW_MAX_STR_LEN + 1);

		icnss_pr_dbg("Received Segment %d Addr: 0x%llx Size: 0x%x, Name: %s, type: %d\n",
			     (i + 1), segment_addr,
			     ind_msg->m3_segment[i].size,
			     ind_msg->m3_segment[i].name,
			     ind_msg->m3_segment[i].type);
	}

	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_M3_DUMP_UPLOAD_REQ,
				0, event_data);

	return;
out:
	kfree(event_data);
}

static int icnss_wlfw_wfc_call_status_send_sync
	(struct icnss_priv *priv,
	 const struct ims_private_service_wfc_call_status_ind_msg_v01 *ind_msg)
{
	struct wlfw_wfc_call_status_req_msg_v01 *req;
	struct wlfw_wfc_call_status_resp_msg_v01 *resp;
	struct qmi_txn txn;
	int ret = 0;

	if (!test_bit(ICNSS_FW_READY, &priv->state)) {
		icnss_pr_err("Drop IMS WFC indication as FW not initialized\n");
		return -EINVAL;
	}
	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	/**
	 * WFC Call r1 design has CNSS as pass thru using opaque hex buffer.
	 * But in r2 update QMI structure is expanded and as an effect qmi
	 * decoded structures have padding. Thus we cannot use buffer design.
	 * For backward compatibility for r1 design copy only wfc_call_active
	 * value in hex buffer.
	 */
	req->wfc_call_status_len = sizeof(ind_msg->wfc_call_active);
	req->wfc_call_status[0] = ind_msg->wfc_call_active;

	/* wfc_call_active is mandatory in IMS indication */
	req->wfc_call_active_valid = 1;
	req->wfc_call_active = ind_msg->wfc_call_active;
	req->all_wfc_calls_held_valid = ind_msg->all_wfc_calls_held_valid;
	req->all_wfc_calls_held = ind_msg->all_wfc_calls_held;
	req->is_wfc_emergency_valid = ind_msg->is_wfc_emergency_valid;
	req->is_wfc_emergency = ind_msg->is_wfc_emergency;
	req->twt_ims_start_valid = ind_msg->twt_ims_start_valid;
	req->twt_ims_start = ind_msg->twt_ims_start;
	req->twt_ims_int_valid = ind_msg->twt_ims_int_valid;
	req->twt_ims_int = ind_msg->twt_ims_int;
	req->media_quality_valid = ind_msg->media_quality_valid;
	req->media_quality =
		(enum wlfw_wfc_media_quality_v01)ind_msg->media_quality;

	icnss_pr_dbg("CNSS->FW: WFC_CALL_REQ: state: 0x%lx\n",
		     priv->state);

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_wfc_call_status_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_pr_err("CNSS->FW: WFC_CALL_REQ: QMI Txn Init: Err %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_WFC_CALL_STATUS_REQ_V01,
			       WLFW_WFC_CALL_STATUS_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_wfc_call_status_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("CNSS->FW: WFC_CALL_REQ: QMI Send Err: %d\n",
			     ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("FW->CNSS: WFC_CALL_RSP: QMI Wait Err: %d\n",
			     ret);
		goto out;
	}

	if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("FW->CNSS: WFC_CALL_RSP: Result: %d Err: %d\n",
			     resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}
	ret = 0;
out:
	kfree(req);
	kfree(resp);
	return ret;
}

static int icnss_ims_wfc_call_twt_cfg_send_sync
	(struct icnss_priv *priv,
	const struct wlfw_wfc_call_twt_config_ind_msg_v01 *ind_msg)
{
	struct ims_private_service_wfc_call_twt_config_req_msg_v01 *req;
	struct ims_private_service_wfc_call_twt_config_rsp_msg_v01 *resp;
	struct qmi_txn txn;
	int ret = 0;

	if (!test_bit(ICNSS_IMS_CONNECTED, &priv->state)) {
		icnss_pr_err("Drop FW WFC indication as IMS QMI not connected\n");
		return -EINVAL;
	}

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->twt_sta_start_valid = ind_msg->twt_sta_start_valid;
	req->twt_sta_start = ind_msg->twt_sta_start;
	req->twt_sta_int_valid = ind_msg->twt_sta_int_valid;
	req->twt_sta_int = ind_msg->twt_sta_int;
	req->twt_sta_upo_valid = ind_msg->twt_sta_upo_valid;
	req->twt_sta_upo = ind_msg->twt_sta_upo;
	req->twt_sta_sp_valid = ind_msg->twt_sta_sp_valid;
	req->twt_sta_sp = ind_msg->twt_sta_sp;
	req->twt_sta_dl_valid = req->twt_sta_dl_valid;
	req->twt_sta_dl = req->twt_sta_dl;
	req->twt_sta_config_changed_valid =
				ind_msg->twt_sta_config_changed_valid;
	req->twt_sta_config_changed = ind_msg->twt_sta_config_changed;

	icnss_pr_dbg("CNSS->IMS: TWT_CFG_REQ: state: 0x%lx\n",
		     priv->state);

	ret =
	qmi_txn_init(&priv->ims_qmi, &txn,
		     ims_private_service_wfc_call_twt_config_rsp_msg_v01_ei,
		     resp);
	if (ret < 0) {
		icnss_pr_err("CNSS->IMS: TWT_CFG_REQ: QMI Txn Init Err: %d\n",
			    ret);
		goto out;
	}

	ret =
	qmi_send_request(&priv->ims_qmi, NULL, &txn,
			 QMI_IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_REQ_V01,
		IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_REQ_MSG_V01_MAX_MSG_LEN,
		ims_private_service_wfc_call_twt_config_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("CNSS->IMS: TWT_CFG_REQ: QMI Send Err: %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("IMS->CNSS: TWT_CFG_RSP: QMI Wait Err: %d\n", ret);
		goto out;
	}

	if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("IMS->CNSS: TWT_CFG_RSP: Result: %d Err: %d\n",
			    resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}
	ret = 0;
out:
	kfree(req);
	kfree(resp);
	return ret;
}

int icnss_process_twt_cfg_ind_event(struct icnss_priv *priv,
				    void *data)
{
	int ret;
	struct wlfw_wfc_call_twt_config_ind_msg_v01 *ind_msg = data;

	ret = icnss_ims_wfc_call_twt_cfg_send_sync(priv, ind_msg);
	kfree(data);
	return ret;
}

static void icnss_wlfw_process_twt_cfg_ind(struct qmi_handle *qmi,
					   struct sockaddr_qrtr *sq,
					   struct qmi_txn *txn,
					   const void *data)
{
	struct icnss_priv *priv =
		container_of(qmi, struct icnss_priv, qmi);
	const struct wlfw_wfc_call_twt_config_ind_msg_v01 *ind_msg = data;
	struct wlfw_wfc_call_twt_config_ind_msg_v01 *event_data;

	if (!txn) {
		icnss_pr_err("FW->CNSS: TWT_CFG_IND: Spurious indication\n");
		return;
	}

	if (!ind_msg) {
		icnss_pr_err("FW->CNSS: TWT_CFG_IND: Invalid indication\n");
		return;
	}
	icnss_pr_dbg("FW->CNSS: TWT_CFG_IND: %x %llx, %x %x, %x %x, %x %x, %x %x, %x %x\n",
		     ind_msg->twt_sta_start_valid, ind_msg->twt_sta_start,
		     ind_msg->twt_sta_int_valid, ind_msg->twt_sta_int,
		     ind_msg->twt_sta_upo_valid, ind_msg->twt_sta_upo,
		     ind_msg->twt_sta_sp_valid, ind_msg->twt_sta_sp,
		     ind_msg->twt_sta_dl_valid, ind_msg->twt_sta_dl,
		     ind_msg->twt_sta_config_changed_valid,
		     ind_msg->twt_sta_config_changed);

	event_data = kmemdup(ind_msg, sizeof(*event_data), GFP_KERNEL);
	if (!event_data)
		return;
	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_WLFW_TWT_CFG_IND, 0,
			       event_data);
}

static struct qmi_msg_handler wlfw_msg_handlers[] = {
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_FW_READY_IND_V01,
		.ei = wlfw_fw_ready_ind_msg_v01_ei,
		.decoded_size = sizeof(struct wlfw_fw_ready_ind_msg_v01),
		.fn = fw_ready_ind_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_MSA_READY_IND_V01,
		.ei = wlfw_msa_ready_ind_msg_v01_ei,
		.decoded_size = sizeof(struct wlfw_msa_ready_ind_msg_v01),
		.fn = msa_ready_ind_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_PIN_CONNECT_RESULT_IND_V01,
		.ei = wlfw_pin_connect_result_ind_msg_v01_ei,
		.decoded_size =
		sizeof(struct wlfw_pin_connect_result_ind_msg_v01),
		.fn = pin_connect_result_ind_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_REJUVENATE_IND_V01,
		.ei = wlfw_rejuvenate_ind_msg_v01_ei,
		.decoded_size = sizeof(struct wlfw_rejuvenate_ind_msg_v01),
		.fn = rejuvenate_ind_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_CAL_DONE_IND_V01,
		.ei = wlfw_cal_done_ind_msg_v01_ei,
		.decoded_size = sizeof(struct wlfw_cal_done_ind_msg_v01),
		.fn = cal_done_ind_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_FW_INIT_DONE_IND_V01,
		.ei = wlfw_fw_init_done_ind_msg_v01_ei,
		.decoded_size = sizeof(struct wlfw_fw_init_done_ind_msg_v01),
		.fn = fw_init_done_ind_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_QDSS_TRACE_REQ_MEM_IND_V01,
		.ei = wlfw_qdss_trace_req_mem_ind_msg_v01_ei,
		.decoded_size =
		sizeof(struct wlfw_qdss_trace_req_mem_ind_msg_v01),
		.fn = wlfw_qdss_trace_req_mem_ind_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_QDSS_TRACE_SAVE_IND_V01,
		.ei = wlfw_qdss_trace_save_ind_msg_v01_ei,
		.decoded_size =
		sizeof(struct wlfw_qdss_trace_save_ind_msg_v01),
		.fn = wlfw_qdss_trace_save_ind_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_QDSS_TRACE_FREE_IND_V01,
		.ei = wlfw_qdss_trace_free_ind_msg_v01_ei,
		.decoded_size =
		sizeof(struct wlfw_qdss_trace_free_ind_msg_v01),
		.fn = wlfw_qdss_trace_free_ind_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_RESPOND_GET_INFO_IND_V01,
		.ei = wlfw_respond_get_info_ind_msg_v01_ei,
		.decoded_size =
		sizeof(struct wlfw_respond_get_info_ind_msg_v01),
		.fn = icnss_wlfw_respond_get_info_ind_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_M3_DUMP_UPLOAD_SEGMENTS_REQ_IND_V01,
		.ei = wlfw_m3_dump_upload_segments_req_ind_msg_v01_ei,
		.decoded_size =
		sizeof(struct wlfw_m3_dump_upload_segments_req_ind_msg_v01),
		.fn = icnss_wlfw_m3_dump_upload_segs_req_ind_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_WLFW_WFC_CALL_TWT_CONFIG_IND_V01,
		.ei = wlfw_wfc_call_twt_config_ind_msg_v01_ei,
		.decoded_size =
		sizeof(struct wlfw_wfc_call_twt_config_ind_msg_v01),
		.fn = icnss_wlfw_process_twt_cfg_ind
	},
	{}
};

int icnss_connect_to_fw_server(struct icnss_priv *priv, void *data)
{
	struct icnss_event_server_arrive_data *event_data = data;
	struct qmi_handle *qmi = &priv->qmi;
	struct sockaddr_qrtr sq = { 0 };
	int ret = 0;

	if (!priv) {
		ret = -ENODEV;
		goto out;
	}

	sq.sq_family = AF_QIPCRTR;
	sq.sq_node = event_data->node;
	sq.sq_port = event_data->port;
	ret = kernel_connect(qmi->sock, (struct sockaddr *)&sq, sizeof(sq), 0);
	if (ret < 0) {
		icnss_pr_err("Fail to connect to remote service port\n");
		goto out;
	}

	icnss_pr_info("QMI Server Connected: state: 0x%lx\n", priv->state);

	kfree(data);
	return 0;

out:
	kfree(data);
	ICNSS_ASSERT(0);
	return ret;
}

int icnss_clear_server(struct icnss_priv *priv)
{
	int ret;

	if (!priv)
		return -ENODEV;

	icnss_pr_info("QMI Service Disconnected: 0x%lx\n", priv->state);
	clear_bit(ICNSS_WLFW_CONNECTED, &priv->state);

	icnss_unregister_fw_service(priv);

	clear_bit(ICNSS_DEL_SERVER, &priv->state);

	ret =  icnss_register_fw_service(priv);
	if (ret < 0) {
		icnss_pr_err("WLFW server registration failed\n");
		ICNSS_ASSERT(0);
	}

	return 0;
}

static int wlfw_new_server(struct qmi_handle *qmi,
			   struct qmi_service *service)
{
	struct icnss_priv *priv =
		container_of(qmi, struct icnss_priv, qmi);
	struct icnss_event_server_arrive_data *event_data;

	if (priv && test_bit(ICNSS_DEL_SERVER, &priv->state)) {
		icnss_pr_info("WLFW server delete in progress, Ignore server arrive: 0x%lx\n",
			      priv->state);
		return 0;
	}

	icnss_pr_dbg("WLFW server arrive: node %u port %u\n",
		     service->node, service->port);

	event_data = kzalloc(sizeof(*event_data), GFP_KERNEL);
	if (event_data == NULL)
		return -ENOMEM;

	event_data->node = service->node;
	event_data->port = service->port;

	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_SERVER_ARRIVE,
				0, event_data);

	return 0;
}

static void wlfw_del_server(struct qmi_handle *qmi,
			    struct qmi_service *service)
{
	struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi);

	if (priv && test_bit(ICNSS_DEL_SERVER, &priv->state)) {
		icnss_pr_info("WLFW server delete / icnss remove in progress, Ignore server delete:  0x%lx\n",
			      priv->state);
		return;
	}

	icnss_pr_dbg("WLFW server delete\n");

	if (priv) {
		set_bit(ICNSS_DEL_SERVER, &priv->state);
		set_bit(ICNSS_FW_DOWN, &priv->state);
		icnss_ignore_fw_timeout(true);
	}

	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_SERVER_EXIT,
				0, NULL);
}

static struct qmi_ops wlfw_qmi_ops = {
	.new_server = wlfw_new_server,
	.del_server = wlfw_del_server,
};

int icnss_register_fw_service(struct icnss_priv *priv)
{
	int ret;

	ret = qmi_handle_init(&priv->qmi,
			      WLFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_MSG_LEN,
			      &wlfw_qmi_ops, wlfw_msg_handlers);
	if (ret < 0)
		return ret;

	if (priv->device_id == WCN6750_DEVICE_ID ||
	    priv->device_id == WCN6450_DEVICE_ID)
		ret = qmi_add_lookup(&priv->qmi, WLFW_SERVICE_ID_V01,
				     WLFW_SERVICE_VERS_V01,
				     WLFW_SERVICE_WCN_INS_ID_V01);
	else
		ret = qmi_add_lookup(&priv->qmi, WLFW_SERVICE_ID_V01,
				     WLFW_SERVICE_VERS_V01,
				     WLFW_SERVICE_INS_ID_V01);
	return ret;
}

void icnss_unregister_fw_service(struct icnss_priv *priv)
{
	set_bit(ICNSS_DEL_SERVER, &priv->state);
	qmi_handle_release(&priv->qmi);
}

int icnss_send_wlan_enable_to_fw(struct icnss_priv *priv,
			struct icnss_wlan_enable_cfg *config,
			enum icnss_driver_mode mode,
			const char *host_version)
{
	struct wlfw_wlan_cfg_req_msg_v01 req;
	u32 i;
	int ret;

	icnss_pr_dbg("Mode: %d, config: %pK, host_version: %s\n",
		     mode, config, host_version);

	memset(&req, 0, sizeof(req));

	if (mode == ICNSS_WALTEST || mode == ICNSS_CCPM)
		goto skip;

	if (!config || !host_version) {
		icnss_pr_err("Invalid cfg pointer, config: %pK, host_version: %pK\n",
			     config, host_version);
		ret = -EINVAL;
		goto out;
	}

	req.host_version_valid = 1;
	strlcpy(req.host_version, host_version,
		WLFW_MAX_STR_LEN + 1);

	req.tgt_cfg_valid = 1;
	if (config->num_ce_tgt_cfg > WLFW_MAX_NUM_CE)
		req.tgt_cfg_len = WLFW_MAX_NUM_CE;
	else
		req.tgt_cfg_len = config->num_ce_tgt_cfg;
	for (i = 0; i < req.tgt_cfg_len; i++) {
		req.tgt_cfg[i].pipe_num = config->ce_tgt_cfg[i].pipe_num;
		req.tgt_cfg[i].pipe_dir = config->ce_tgt_cfg[i].pipe_dir;
		req.tgt_cfg[i].nentries = config->ce_tgt_cfg[i].nentries;
		req.tgt_cfg[i].nbytes_max = config->ce_tgt_cfg[i].nbytes_max;
		req.tgt_cfg[i].flags = config->ce_tgt_cfg[i].flags;
	}

	req.svc_cfg_valid = 1;
	if (config->num_ce_svc_pipe_cfg > WLFW_MAX_NUM_SVC)
		req.svc_cfg_len = WLFW_MAX_NUM_SVC;
	else
		req.svc_cfg_len = config->num_ce_svc_pipe_cfg;
	for (i = 0; i < req.svc_cfg_len; i++) {
		req.svc_cfg[i].service_id = config->ce_svc_cfg[i].service_id;
		req.svc_cfg[i].pipe_dir = config->ce_svc_cfg[i].pipe_dir;
		req.svc_cfg[i].pipe_num = config->ce_svc_cfg[i].pipe_num;
	}

	if (priv->device_id == WCN6750_DEVICE_ID) {
		req.shadow_reg_v2_valid = 1;
		if (config->num_shadow_reg_v2_cfg >
			QMI_WLFW_MAX_NUM_SHADOW_REG_V2_V01)
			req.shadow_reg_v2_len =
				QMI_WLFW_MAX_NUM_SHADOW_REG_V2_V01;
		else
			req.shadow_reg_v2_len = config->num_shadow_reg_v2_cfg;

		memcpy(req.shadow_reg_v2, config->shadow_reg_v2_cfg,
			 sizeof(struct wlfw_shadow_reg_v2_cfg_s_v01) *
			 req.shadow_reg_v2_len);
	} else if (priv->device_id == ADRASTEA_DEVICE_ID) {
		req.shadow_reg_valid = 1;
		if (config->num_shadow_reg_cfg >
			QMI_WLFW_MAX_NUM_SHADOW_REG_V01)
			req.shadow_reg_len = QMI_WLFW_MAX_NUM_SHADOW_REG_V01;
		else
			req.shadow_reg_len = config->num_shadow_reg_cfg;

		memcpy(req.shadow_reg, config->shadow_reg_cfg,
		       sizeof(struct wlfw_msi_cfg_s_v01) * req.shadow_reg_len);
	} else if (priv->device_id == WCN6450_DEVICE_ID) {
		req.shadow_reg_v3_valid = 1;
		if (config->num_shadow_reg_v3_cfg >
			MAX_NUM_SHADOW_REG_V3)
			req.shadow_reg_v3_len = MAX_NUM_SHADOW_REG_V3;
		else
			req.shadow_reg_v3_len = config->num_shadow_reg_v3_cfg;

		memcpy(req.shadow_reg_v3, config->shadow_reg_v3_cfg,
		       sizeof(struct wlfw_shadow_reg_v3_cfg_s_v01)
		       * req.shadow_reg_v3_len);
	}

	ret = wlfw_wlan_cfg_send_sync_msg(priv, &req);
	if (ret)
		goto out;
skip:
	ret = wlfw_wlan_mode_send_sync_msg(priv,
			   (enum wlfw_driver_mode_enum_v01)mode);
out:
	if (test_bit(SKIP_QMI, &priv->ctrl_params.quirks))
		ret = 0;

	return ret;
}

int icnss_send_wlan_disable_to_fw(struct icnss_priv *priv)
{
	enum wlfw_driver_mode_enum_v01 mode = QMI_WLFW_OFF_V01;

	return wlfw_wlan_mode_send_sync_msg(priv, mode);
}

#ifdef CONFIG_ICNSS2_DEBUG
static inline u32 icnss_get_host_build_type(void)
{
	return QMI_HOST_BUILD_TYPE_PRIMARY_V01;
}
#else
static inline u32 icnss_get_host_build_type(void)
{
	return QMI_HOST_BUILD_TYPE_SECONDARY_V01;
}
#endif

int wlfw_host_cap_send_sync(struct icnss_priv *priv)
{
	struct wlfw_host_cap_req_msg_v01 *req;
	struct wlfw_host_cap_resp_msg_v01 *resp;
	struct qmi_txn txn;
	int ddr_type;
	u32 gpio;
	int ret = 0;
	u64 iova_start = 0, iova_size = 0,
	    iova_ipa_start = 0, iova_ipa_size = 0;

	icnss_pr_dbg("Sending host capability message, state: 0x%lx\n",
		    priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->num_clients_valid = 1;
	req->num_clients = 1;

	req->bdf_support_valid = 1;
	req->bdf_support = 1;

	req->cal_done_valid = 1;
	req->cal_done = priv->cal_done;
	icnss_pr_dbg("Calibration done is %d\n", priv->cal_done);

	if (priv->smmu_s1_enable &&
	    !icnss_get_iova(priv, &iova_start, &iova_size) &&
	    !icnss_get_iova_ipa(priv, &iova_ipa_start,
				&iova_ipa_size)) {
		req->ddr_range_valid = 1;
		req->ddr_range[0].start = iova_start;
		req->ddr_range[0].size = iova_size + iova_ipa_size;
		req->ddr_range[1].start = priv->msa_pa;
		req->ddr_range[1].size = priv->msa_mem_size;
		icnss_pr_dbg("Sending iova starting 0x%llx with size 0x%llx\n",
			    req->ddr_range[0].start, req->ddr_range[0].size);
		icnss_pr_dbg("Sending msa starting 0x%llx with size 0x%llx\n",
			    req->ddr_range[1].start, req->ddr_range[1].size);
	}

	req->host_build_type_valid = 1;
	req->host_build_type = icnss_get_host_build_type();

	if (priv->wlan_en_delay_ms >= 100) {
		icnss_pr_dbg("Setting WLAN_EN delay: %d ms\n",
			     priv->wlan_en_delay_ms);
		req->wlan_enable_delay_valid = 1;
		req->wlan_enable_delay = priv->wlan_en_delay_ms;
	}

	/* ddr_type = 7(LPDDR4) and 8(LPDDR5) */
	ddr_type = of_fdt_get_ddrtype();
	if (ddr_type > 0) {
		icnss_pr_dbg("DDR Type: %d\n", ddr_type);
		req->ddr_type_valid = 1;
		req->ddr_type = ddr_type;
	}

	ret = of_property_read_u32(priv->pdev->dev.of_node, "wlan-en-gpio",
				   &gpio);
	if (!ret) {
		icnss_pr_dbg("WLAN_EN_GPIO modified through DT: %d\n", gpio);
		req->gpio_info_valid = 1;
		req->gpio_info[WLAN_EN_GPIO_V01] = gpio;
	} else {
		req->gpio_info[WLAN_EN_GPIO_V01] = 0xFFFF;
	}

	ret = of_property_read_u32(priv->pdev->dev.of_node, "bt-en-gpio",
				   &gpio);
	if (!ret) {
		icnss_pr_dbg("BT_EN_GPIO modified through DT: %d\n", gpio);
		req->gpio_info_valid = 1;
		req->gpio_info[BT_EN_GPIO_V01] = gpio;
	} else {
		req->gpio_info[BT_EN_GPIO_V01] = 0xFFFF;
	}

	ret = of_property_read_u32(priv->pdev->dev.of_node, "host-sol-gpio",
				   &gpio);
	if (!ret) {
		icnss_pr_dbg("HOST_SOL_GPIO modified through DT: %d\n", gpio);
		req->gpio_info_valid = 1;
		req->gpio_info[HOST_SOL_GPIO_V01] = gpio;
	} else {
		req->gpio_info[HOST_SOL_GPIO_V01] = 0xFFFF;
	}

	ret = of_property_read_u32(priv->pdev->dev.of_node, "target-sol-gpio",
				   &gpio);
	if (!ret) {
		icnss_pr_dbg("TARGET_SOL_GPIO modified through DT: %d\n", gpio);
		req->gpio_info_valid = 1;
		req->gpio_info[TARGET_SOL_GPIO_V01] = gpio;
	} else {
		req->gpio_info[TARGET_SOL_GPIO_V01] = 0xFFFF;
	}

	req->gpio_info_len = GPIO_TYPE_MAX_V01;

	ret = qmi_txn_init(&priv->qmi, &txn,
			   wlfw_host_cap_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_pr_err("Failed to initialize txn for host capability request, err: %d\n",
			    ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_HOST_CAP_REQ_V01,
			       WLFW_HOST_CAP_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_host_cap_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Failed to send host capability request, err: %d\n",
			    ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("Failed to wait for response of host capability request, err: %d\n",
			    ret);
		goto out;
	}

	if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("Host capability request failed, result: %d, err: %d\n",
			    resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	kfree(req);
	kfree(resp);
	return 0;

out:
	ICNSS_QMI_ASSERT();
	kfree(req);
	kfree(resp);
	return ret;
}

int icnss_wlfw_get_info_send_sync(struct icnss_priv *plat_priv, int type,
				 void *cmd, int cmd_len)
{
	struct wlfw_get_info_req_msg_v01 *req;
	struct wlfw_get_info_resp_msg_v01 *resp;
	struct qmi_txn txn;
	int ret = 0;
	int flags = GFP_KERNEL & ~__GFP_DIRECT_RECLAIM;

	if (cmd_len > QMI_WLFW_MAX_DATA_SIZE_V01)
		return -EINVAL;

	if (test_bit(ICNSS_FW_DOWN, &plat_priv->state))
		return -EINVAL;

	req = kzalloc(sizeof(*req), flags);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), flags);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->type = type;
	req->data_len = cmd_len;
	memcpy(req->data, cmd, req->data_len);

	ret = qmi_txn_init(&plat_priv->qmi, &txn,
			   wlfw_get_info_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_pr_err("Failed to initialize txn for get info request, err: %d\n",
			    ret);
		goto out;
	}

	ret = qmi_send_request(&plat_priv->qmi, NULL, &txn,
			       QMI_WLFW_GET_INFO_REQ_V01,
			       WLFW_GET_INFO_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_get_info_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Failed to send get info request, err: %d\n",
			    ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, plat_priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("Failed to wait for response of get info request, err: %d\n",
			    ret);
		goto out;
	}

	if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("Get info request failed, result: %d, err: %d\n",
			    resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	kfree(req);
	kfree(resp);
	return 0;

out:
	kfree(req);
	kfree(resp);
	return ret;
}

int wlfw_subsys_restart_level_msg(struct icnss_priv *penv, uint8_t restart_level)
{
	int ret;
	struct wlfw_subsys_restart_level_req_msg_v01 *req;
	struct wlfw_subsys_restart_level_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!penv)
		return -ENODEV;

	if (test_bit(ICNSS_FW_DOWN, &penv->state))
		return -EINVAL;

	icnss_pr_dbg("Sending subsystem restart level: 0x%x\n", restart_level);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->restart_level_type_valid = 1;
	req->restart_level_type = restart_level;

	penv->stats.restart_level_req++;

	ret = qmi_txn_init(&penv->qmi, &txn,
			   wlfw_subsys_restart_level_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_pr_err("Fail to init txn for subsystem restart level, resp %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&penv->qmi, NULL, &txn,
			       QMI_WLFW_SUBSYS_RESTART_LEVEL_REQ_V01,
			       WLFW_SUBSYS_RESTART_LEVEL_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_subsys_restart_level_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Fail to send subsystem restart level %d\n",
			     ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, penv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("Subsystem restart level timed out with ret %d\n",
			     ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("Subsystem restart level request rejected,result:%d error:%d\n",
			     resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	penv->stats.restart_level_resp++;

	kfree(resp);
	kfree(req);
	return 0;

out:
	kfree(req);
	kfree(resp);
	penv->stats.restart_level_err++;
	return ret;
}

int icnss_send_vbatt_update(struct icnss_priv *priv, uint64_t voltage_uv)
{
	int ret;
	struct wlfw_vbatt_req_msg_v01 *req;
	struct wlfw_vbatt_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!priv)
		return -ENODEV;

	if (test_bit(ICNSS_FW_DOWN, &priv->state))
		return -EINVAL;

	icnss_pr_dbg("Sending Vbatt message, state: 0x%lx\n", priv->state);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->voltage_uv = voltage_uv;

	ret = qmi_txn_init(&priv->qmi, &txn, wlfw_vbatt_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_pr_err("Fail to init txn for Vbatt message resp %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&priv->qmi, NULL, &txn,
			       QMI_WLFW_VBATT_REQ_V01,
			       WLFW_VBATT_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_vbatt_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Fail to send Vbatt message req %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("VBATT message resp wait failed with ret %d\n",
			     ret);
		goto out;
	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("QMI Vbatt message request rejected, result:%d error:%d\n",
			     resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	kfree(resp);
	kfree(req);
	return 0;

out:
	kfree(resp);
	kfree(req);
	return ret;
}

int wlfw_wlan_hw_init_cfg_msg(struct icnss_priv *penv,
			      enum wlfw_wlan_rf_subtype_v01 type)
{
	int ret;
	struct wlfw_wlan_hw_init_cfg_req_msg_v01 *req;
	struct wlfw_wlan_hw_init_cfg_resp_msg_v01 *resp;
	struct qmi_txn txn;

	if (!penv)
		return -ENODEV;

	icnss_pr_dbg("Sending hw init cfg, rf_subtype: 0x%x\n", type);

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
	if (!resp) {
		kfree(req);
		return -ENOMEM;
	}

	req->rf_subtype_valid = 1;
	req->rf_subtype = type;

	ret = qmi_txn_init(&penv->qmi, &txn,
			   wlfw_wlan_hw_init_cfg_resp_msg_v01_ei, resp);
	if (ret < 0) {
		icnss_pr_err("Fail to init txn for hw init cfg, resp %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request(&penv->qmi, NULL, &txn,
			       QMI_WLFW_WLAN_HW_INIT_CFG_REQ_V01,
			       WLFW_WLAN_HW_INIT_CFG_REQ_MSG_V01_MAX_MSG_LEN,
			       wlfw_wlan_hw_init_cfg_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(&txn);
		icnss_pr_err("Fail to send hw init cfg %d\n", ret);
		goto out;
	}

	ret = qmi_txn_wait(&txn, penv->ctrl_params.qmi_timeout);
	if (ret < 0) {
		icnss_pr_err("HW init cfg timed out with ret %d\n",
			     ret);
		goto out;

	} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("HW init cfg request rejected,result:%d error:%d\n",
			     resp->resp.result, resp->resp.error);
		ret = -resp->resp.result;
		goto out;
	}

	kfree(resp);
	kfree(req);
	return 0;

out:
	kfree(req);
	kfree(resp);
	return ret;
}

/* IMS Service */
int ims_subscribe_for_indication_send_async(struct icnss_priv *priv)
{
	int ret;
	struct ims_private_service_subscribe_for_indications_req_msg_v01 *req;
	struct qmi_txn *txn;

	if (!priv)
		return -ENODEV;

	icnss_pr_dbg("Sending ASYNC ims subscribe for indication\n");

	req = kzalloc(sizeof(*req), GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	req->wfc_call_status_valid = 1;
	req->wfc_call_status = 1;

	txn = &priv->ims_async_txn;
	ret = qmi_txn_init(&priv->ims_qmi, txn, NULL, NULL);
	if (ret < 0) {
		icnss_pr_err("Fail to init txn for ims subscribe for indication resp %d\n",
			     ret);
		goto out;
	}

	ret = qmi_send_request
	(&priv->ims_qmi, NULL, txn,
	QMI_IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_V01,
	IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_MSG_V01_MAX_MSG_LEN,
	ims_private_service_subscribe_ind_req_msg_v01_ei, req);
	if (ret < 0) {
		qmi_txn_cancel(txn);
		icnss_pr_err("Fail to send ims subscribe for indication req %d\n",
			     ret);
		goto out;
	}

	kfree(req);
	return 0;

out:
	kfree(req);
	return ret;
}

static void ims_subscribe_for_indication_resp_cb(struct qmi_handle *qmi,
						 struct sockaddr_qrtr *sq,
						 struct qmi_txn *txn,
						 const void *data)
{
	const
	struct ims_private_service_subscribe_for_indications_rsp_msg_v01 *resp =
		data;

	icnss_pr_dbg("Received IMS subscribe indication response\n");

	if (!txn) {
		icnss_pr_err("spurious response\n");
		return;
	}

	if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
		icnss_pr_err("IMS subscribe for indication request rejected, result:%d error:%d\n",
			     resp->resp.result, resp->resp.error);
		txn->result = -resp->resp.result;
	}
}

int icnss_process_wfc_call_ind_event(struct icnss_priv *priv,
				     void *data)
{
	int ret;
	struct ims_private_service_wfc_call_status_ind_msg_v01 *ind_msg = data;

	ret = icnss_wlfw_wfc_call_status_send_sync(priv, ind_msg);
	kfree(data);
	return ret;
}

static void
icnss_ims_process_wfc_call_ind_cb(struct qmi_handle *ims_qmi,
				  struct sockaddr_qrtr *sq,
				  struct qmi_txn *txn, const void *data)
{
	struct icnss_priv *priv =
		container_of(ims_qmi, struct icnss_priv, ims_qmi);
	const
	struct ims_private_service_wfc_call_status_ind_msg_v01 *ind_msg = data;
	struct ims_private_service_wfc_call_status_ind_msg_v01 *event_data;

	if (!txn) {
		icnss_pr_err("IMS->CNSS: WFC_CALL_IND: Spurious indication\n");
		return;
	}

	if (!ind_msg) {
		icnss_pr_err("IMS->CNSS: WFC_CALL_IND: Invalid indication\n");
		return;
	}
	icnss_pr_dbg("IMS->CNSS: WFC_CALL_IND: %x, %x %x, %x %x, %x %llx, %x %x, %x %x\n",
		     ind_msg->wfc_call_active, ind_msg->all_wfc_calls_held_valid,
		     ind_msg->all_wfc_calls_held,
		     ind_msg->is_wfc_emergency_valid, ind_msg->is_wfc_emergency,
		     ind_msg->twt_ims_start_valid, ind_msg->twt_ims_start,
		     ind_msg->twt_ims_int_valid, ind_msg->twt_ims_int,
		     ind_msg->media_quality_valid, ind_msg->media_quality);

	event_data = kmemdup(ind_msg, sizeof(*event_data), GFP_KERNEL);
	if (!event_data)
		return;
	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_IMS_WFC_CALL_IND,
			       0, event_data);
}

static struct qmi_msg_handler qmi_ims_msg_handlers[] = {
	{
		.type = QMI_RESPONSE,
		.msg_id =
		QMI_IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_V01,
		.ei =
		ims_private_service_subscribe_ind_rsp_msg_v01_ei,
		.decoded_size = sizeof(struct
		ims_private_service_subscribe_for_indications_rsp_msg_v01),
		.fn = ims_subscribe_for_indication_resp_cb
	},
	{
		.type = QMI_INDICATION,
		.msg_id = QMI_IMS_PRIVATE_SERVICE_WFC_CALL_STATUS_IND_V01,
		.ei = ims_private_service_wfc_call_status_ind_msg_v01_ei,
		.decoded_size =
		sizeof(struct ims_private_service_wfc_call_status_ind_msg_v01),
		.fn = icnss_ims_process_wfc_call_ind_cb
	},
	{}
};

static int ims_new_server(struct qmi_handle *qmi,
			  struct qmi_service *service)
{
	struct icnss_priv *priv =
		container_of(qmi, struct icnss_priv, ims_qmi);
	struct sockaddr_qrtr sq = { 0 };
	int ret = 0;

	icnss_pr_dbg("IMS server arrive: node %u port %u\n",
		    service->node, service->port);

	sq.sq_family = AF_QIPCRTR;
	sq.sq_node = service->node;
	sq.sq_port = service->port;
	ret = kernel_connect(qmi->sock, (struct sockaddr *)&sq, sizeof(sq), 0);
	if (ret < 0) {
		icnss_pr_err("Fail to connect to remote service port\n");
		return ret;
	}

	set_bit(ICNSS_IMS_CONNECTED, &priv->state);
	icnss_pr_dbg("IMS Server Connected: 0x%lx\n",
		    priv->state);

	ret = ims_subscribe_for_indication_send_async(priv);
	return ret;
}

static void ims_del_server(struct qmi_handle *qmi,
			   struct qmi_service *service)
{
	struct icnss_priv *priv =
		container_of(qmi, struct icnss_priv, ims_qmi);

	icnss_pr_dbg("IMS server exit\n");

	clear_bit(ICNSS_IMS_CONNECTED, &priv->state);
}

static struct qmi_ops ims_qmi_ops = {
	.new_server = ims_new_server,
	.del_server = ims_del_server,
};

int icnss_register_ims_service(struct icnss_priv *priv)
{
	int ret;

	ret = qmi_handle_init(&priv->ims_qmi,
			      IMSPRIVATE_SERVICE_MAX_MSG_LEN,
			      &ims_qmi_ops, qmi_ims_msg_handlers);
	if (ret < 0)
		return ret;

	ret = qmi_add_lookup(&priv->ims_qmi, IMSPRIVATE_SERVICE_ID_V01,
			     IMSPRIVATE_SERVICE_VERS_V01, 0);
	return ret;
}

void icnss_unregister_ims_service(struct icnss_priv *priv)
{
	qmi_handle_release(&priv->ims_qmi);
}