diff --git a/drivers/net/wireless/cnss2/debug.c b/drivers/net/wireless/cnss2/debug.c
index 21ceda6e53a4..1d6c3748ff8c 100644
--- a/drivers/net/wireless/cnss2/debug.c
+++ b/drivers/net/wireless/cnss2/debug.c
@@ -10,28 +10,10 @@
 #include "pci.h"
 
 #define MMIO_REG_ACCESS_MEM_TYPE		0xFF
-#define HEX_DUMP_ROW_SIZE			16
 
 void *cnss_ipc_log_context;
 void *cnss_ipc_log_long_context;
 
-static void cnss_print_hex_dump(const void *buf, int len)
-{
-	const u8 *ptr = buf;
-	int i, linelen, remaining = len, rowsize = HEX_DUMP_ROW_SIZE;
-	unsigned char linebuf[HEX_DUMP_ROW_SIZE * 3 + 1];
-
-	for (i = 0; i < len; i += rowsize) {
-		linelen = min(remaining, rowsize);
-		remaining -= rowsize;
-
-		hex_dump_to_buffer(ptr + i, linelen, rowsize, 1,
-				   linebuf, sizeof(linebuf), false);
-
-		cnss_pr_dbg("%.8x: %s\n", i, linebuf);
-	}
-}
-
 static int cnss_pin_connect_show(struct seq_file *s, void *data)
 {
 	struct cnss_plat_data *cnss_priv = s->private;
@@ -768,95 +750,6 @@ static const struct file_operations cnss_dynamic_feature_fops = {
 	.llseek = seq_lseek,
 };
 
-static int cnss_wfc_call_status_debug_show(struct seq_file *s, void *data)
-{
-	seq_puts(s, "\nUsage: echo <data_len> <hex data> > <debugfs_path>/cnss/wfc_call_status\n");
-	seq_puts(s, "e.g. Send 4 bytes of hex data for WFC call status using QMI message:\n");
-	seq_puts(s, "echo '0x4 0xA 0xB 0xC 0xD' > /d/cnss/wfc_call_status\n");
-
-	return 0;
-}
-
-static ssize_t cnss_wfc_call_status_debug_write(struct file *fp,
-						const char __user *user_buf,
-						size_t count, loff_t *off)
-{
-	struct cnss_plat_data *plat_priv =
-		((struct seq_file *)fp->private_data)->private;
-	char buf[(QMI_WLFW_MAX_WFC_CALL_STATUS_DATA_SIZE_V01 + 1) * 5];
-	char *sptr, *token;
-	unsigned int len = 0;
-	const char *delim = " ";
-	u32 data_len;
-	u8 data[QMI_WLFW_MAX_WFC_CALL_STATUS_DATA_SIZE_V01] = {0}, data_byte;
-	int ret = 0, i;
-
-	if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
-		cnss_pr_err("Firmware is not ready yet\n");
-		return -EINVAL;
-	}
-
-	len = min(count, sizeof(buf) - 1);
-	if (copy_from_user(buf, user_buf, len))
-		return -EFAULT;
-
-	buf[len] = '\0';
-	sptr = buf;
-
-	token = strsep(&sptr, delim);
-	if (!token || !sptr)
-		return -EINVAL;
-
-	if (kstrtou32(token, 0, &data_len))
-		return -EINVAL;
-
-	cnss_pr_dbg("Parsing 0x%x bytes data for WFC call status\n", data_len);
-
-	if (data_len > QMI_WLFW_MAX_WFC_CALL_STATUS_DATA_SIZE_V01 ||
-	    data_len == 0) {
-		cnss_pr_err("Invalid data length 0x%x\n", data_len);
-		return -EINVAL;
-	}
-
-	for (i = 0; i < data_len; i++) {
-		token = strsep(&sptr, delim);
-		if (!token || (!sptr && i < data_len - 1)) {
-			cnss_pr_err("Input data is less than length\n");
-			return -EINVAL;
-		}
-
-		if (kstrtou8(token, 0, &data_byte)) {
-			cnss_pr_err("Data format is incorrect\n");
-			return -EINVAL;
-		}
-
-		data[i] = data_byte;
-	}
-
-	cnss_print_hex_dump(data, data_len);
-
-	ret = cnss_wlfw_wfc_call_status_send_sync(plat_priv, data_len, data);
-	if (ret)
-		return ret;
-
-	return count;
-}
-
-static int cnss_wfc_call_status_debug_open(struct inode *inode,
-					   struct file *file)
-{
-	return single_open(file, cnss_wfc_call_status_debug_show,
-			   inode->i_private);
-}
-
-static const struct file_operations cnss_wfc_call_status_debug_fops = {
-	.read		= seq_read,
-	.write		= cnss_wfc_call_status_debug_write,
-	.open		= cnss_wfc_call_status_debug_open,
-	.owner		= THIS_MODULE,
-	.llseek		= seq_lseek,
-};
-
 #ifdef CONFIG_CNSS2_DEBUG
 static int cnss_create_debug_only_node(struct cnss_plat_data *plat_priv)
 {
@@ -874,8 +767,6 @@ static int cnss_create_debug_only_node(struct cnss_plat_data *plat_priv)
 			    &cnss_control_params_debug_fops);
 	debugfs_create_file("dynamic_feature", 0600, root_dentry, plat_priv,
 			    &cnss_dynamic_feature_fops);
-	debugfs_create_file("wfc_call_status", 0600, root_dentry, plat_priv,
-			    &cnss_wfc_call_status_debug_fops);
 
 	return 0;
 }
diff --git a/drivers/net/wireless/cnss2/ip_multimedia_subsystem_private_service_v01.c b/drivers/net/wireless/cnss2/ip_multimedia_subsystem_private_service_v01.c
index 5b958e9323eb..2caf9496c4e9 100644
--- a/drivers/net/wireless/cnss2/ip_multimedia_subsystem_private_service_v01.c
+++ b/drivers/net/wireless/cnss2/ip_multimedia_subsystem_private_service_v01.c
@@ -1,10 +1,34 @@
 // SPDX-License-Identifier: GPL-2.0-only
-/* Copyright (c) 2019, The Linux Foundation. All rights reserved. */
-
-#include <linux/soc/qcom/qmi.h>
+/* Copyright (c) 2019-2020, The Linux Foundation. All rights reserved. */
 
 #include "ip_multimedia_subsystem_private_service_v01.h"
 
+static struct qmi_elem_info ims_private_service_header_value_v01_ei[] = {
+	{
+		.data_type      = QMI_STRING,
+		.elem_len       = IMS_PRIVATE_SERVICE_HEADER_STR_LEN_V01 + 1,
+		.elem_size      = sizeof(char),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0,
+		.offset         =
+		offsetof(struct ims_private_service_header_value_v01, header),
+	},
+	{
+		.data_type      = QMI_STRING,
+		.elem_len       = IMS_PRIVATE_SERVICE_HEADER_STR_LEN_V01 + 1,
+		.elem_size      = sizeof(char),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0,
+		.offset         =
+		offsetof(struct ims_private_service_header_value_v01, value),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.array_type       = NO_ARRAY,
+		.tlv_type       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
 struct qmi_elem_info
 ims_private_service_subscribe_for_indications_req_msg_v01_ei[] = {
 	{
@@ -74,16 +98,68 @@ ims_private_service_subscribe_for_indications_rsp_msg_v01_ei[] = {
 	},
 };
 
-struct qmi_elem_info ims_private_service_wfc_call_status_ind_msg_v01_ei[] = {
+struct qmi_elem_info ims_private_service_mt_invite_ind_msg_v01_ei[] = {
 	{
-		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
+		.elem_len       = 1,
+		.elem_size      = sizeof(enum ims_subscription_type_enum_v01),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x01,
+		.offset         =
+		offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
+			 subscription_type),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
 		.elem_len       = 1,
 		.elem_size      = sizeof(u8),
 		.array_type       = NO_ARRAY,
-		.tlv_type       = 0x01,
-		.offset         = offsetof(struct
-				ims_private_service_wfc_call_status_ind_msg_v01,
-				wfc_call_active),
+		.tlv_type       = 0x10,
+		.offset         =
+		offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
+			 iccid_valid),
+	},
+	{
+		.data_type      = QMI_STRING,
+		.elem_len       = IMS_PRIVATE_SERVICE_MAX_ICCID_LEN_V01 + 1,
+		.elem_size      = sizeof(char),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         =
+		offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
+			 iccid),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         =
+		offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
+			 header_value_list_valid),
+	},
+	{
+		.data_type      = QMI_DATA_LEN,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         =
+		offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
+			 header_value_list_len),
+	},
+	{
+		.data_type      = QMI_STRUCT,
+		.elem_len       = IMS_PRIVATE_SERVICE_MAX_MT_INVITE_HEADERS_V01,
+		.elem_size      =
+		sizeof(struct ims_private_service_header_value_v01),
+		.array_type       = VAR_LEN_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         =
+		offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
+			 header_value_list),
+		.ei_array      = ims_private_service_header_value_v01_ei,
 	},
 	{
 		.data_type      = QMI_EOTI,
@@ -91,3 +167,284 @@ struct qmi_elem_info ims_private_service_wfc_call_status_ind_msg_v01_ei[] = {
 		.tlv_type       = QMI_COMMON_TLV_TYPE,
 	},
 };
+
+struct qmi_elem_info ims_private_service_wfc_call_status_ind_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x01,
+		.offset         =
+		offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
+			 wfc_call_active),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         =
+		offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
+			 all_wfc_calls_held_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         =
+		offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
+			 all_wfc_calls_held),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         =
+		offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
+			 is_wfc_emergency_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         =
+		offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
+			 is_wfc_emergency),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x12,
+		.offset         =
+		offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
+			 twt_ims_start_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_8_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u64),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x12,
+		.offset         =
+		offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
+			 twt_ims_start),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x13,
+		.offset         =
+		offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
+			 twt_ims_int_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_2_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u16),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x13,
+		.offset         =
+		offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
+			 twt_ims_int),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x14,
+		.offset         =
+		offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
+			 media_quality_valid),
+	},
+	{
+		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
+		.elem_len       = 1,
+		.elem_size      = sizeof(enum wfc_media_quality_v01),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x14,
+		.offset         =
+		offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
+			 media_quality),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.array_type       = NO_ARRAY,
+		.tlv_type       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+struct qmi_elem_info
+ims_private_service_wfc_call_twt_config_req_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_start_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_8_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u64),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_start),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_int_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_2_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u16),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_int),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x12,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_upo_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_2_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u16),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x12,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_upo),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x13,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_sp_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_2_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u16),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x13,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_sp),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x14,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_dl_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_2_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u16),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x14,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_dl),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x15,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_config_changed_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x15,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_req_msg_v01,
+			 twt_sta_config_changed),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.array_type       = NO_ARRAY,
+		.tlv_type       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+struct qmi_elem_info
+ims_private_service_wfc_call_twt_config_rsp_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_STRUCT,
+		.elem_len       = 1,
+		.elem_size      = sizeof(struct qmi_response_type_v01),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x02,
+		.offset         =
+		offsetof(struct
+			 ims_private_service_wfc_call_twt_config_rsp_msg_v01,
+			 resp),
+		.ei_array      = qmi_response_type_v01_ei,
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.array_type       = NO_ARRAY,
+		.tlv_type       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
diff --git a/drivers/net/wireless/cnss2/ip_multimedia_subsystem_private_service_v01.h b/drivers/net/wireless/cnss2/ip_multimedia_subsystem_private_service_v01.h
index 582c4ff96880..c8cdb59bcea5 100644
--- a/drivers/net/wireless/cnss2/ip_multimedia_subsystem_private_service_v01.h
+++ b/drivers/net/wireless/cnss2/ip_multimedia_subsystem_private_service_v01.h
@@ -1,17 +1,58 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
-/* Copyright (c) 2019, The Linux Foundation. All rights reserved. */
+/* Copyright (c) 2020, The Linux Foundation. All rights reserved. */
 
 #ifndef IP_MULTIMEDIA_SUBSYSTEM_PRIVATE_SERVICE_V01_H
 #define IP_MULTIMEDIA_SUBSYSTEM_PRIVATE_SERVICE_V01_H
 
+#include <linux/soc/qcom/qmi.h>
+
 #define IMSPRIVATE_SERVICE_ID_V01 0x4D
 #define IMSPRIVATE_SERVICE_VERS_V01 0x01
 
-#define IMSPRIVATE_SERVICE_MAX_MSG_LEN 8
-
 #define QMI_IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_RSP_V01 0x003E
-#define QMI_IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_V01 0x003E
 #define QMI_IMS_PRIVATE_SERVICE_WFC_CALL_STATUS_IND_V01 0x0040
+#define QMI_IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_V01 0x003E
+#define QMI_IMS_PRIVATE_SERVICE_MT_INVITE_IND_V01 0x003F
+#define QMI_IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_RSP_V01 0x0041
+#define QMI_IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_REQ_V01 0x0041
+
+#define IMS_PRIVATE_SERVICE_MAX_MT_INVITE_HEADERS_V01 15
+#define IMS_PRIVATE_SERVICE_HEADER_STR_LEN_V01 1024
+#define IMS_PRIVATE_SERVICE_MAX_ICCID_LEN_V01 21
+
+enum ims_common_resp_enum_v01 {
+	IMS_COMMON_RESP_ENUM_MIN_VAL_V01 = INT_MIN,
+	IMS_COMMON_MSG_NO_ERR_V01 = 0,
+	IMS_COMMON_MSG_IMS_NOT_READY_V01 = 1,
+	IMS_COMMON_MSG_FILE_NOT_AVAILABLE_V01 = 2,
+	IMS_COMMON_MSG_READ_FAILED_V01 = 3,
+	IMS_COMMON_MSG_WRITE_FAILED_V01 = 4,
+	IMS_COMMON_MSG_OTHER_INTERNAL_ERR_V01 = 5,
+	IMS_COMMON_RESP_ENUM_MAX_VAL_V01 = INT_MAX,
+};
+
+enum ims_subscription_type_enum_v01 {
+	IMS_SUBSCRIPTION_TYPE_ENUM_MIN_VAL_V01 = INT_MIN,
+	IMS_SUBSCRIPTION_TYPE_NONE_V01 = -1,
+	IMS_SUBSCRIPTION_TYPE_PRIMARY_V01 = 0,
+	IMS_SUBSCRIPTION_TYPE_SECONDARY_V01 = 1,
+	IMS_SUBSCRIPTION_TYPE_TERTIARY_V01 = 2,
+	IMS_SUBSCRIPTION_TYPE_ENUM_MAX_VAL_V01 = INT_MAX,
+};
+
+enum wfc_media_quality_v01 {
+	WFC_MEDIA_QUALITY_MIN_VAL_V01 = INT_MIN,
+	WFC_MEDIA_QUAL_NOT_AVAILABLE_V01 = 0,
+	WFC_MEDIA_QUAL_BAD_V01 = 1,
+	WFC_MEDIA_QUAL_GOOD_V01 = 2,
+	WFC_MEDIA_QUAL_EXCELLENT_V01 = 3,
+	WFC_MEDIA_QUALITY_MAX_VAL_V01 = INT_MAX,
+};
+
+struct ims_private_service_header_value_v01 {
+	char header[IMS_PRIVATE_SERVICE_HEADER_STR_LEN_V01 + 1];
+	char value[IMS_PRIVATE_SERVICE_HEADER_STR_LEN_V01 + 1];
+};
 
 struct ims_private_service_subscribe_for_indications_req_msg_v01 {
 	u8 mt_invite_valid;
@@ -21,23 +62,73 @@ struct ims_private_service_subscribe_for_indications_req_msg_v01 {
 };
 
 #define IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_MSG_V01_MAX_MSG_LEN 8
-extern struct
-qmi_elem_info ims_private_service_subscribe_for_indications_req_msg_v01_ei[];
+extern struct qmi_elem_info
+ims_private_service_subscribe_for_indications_req_msg_v01_ei[];
 
 struct ims_private_service_subscribe_for_indications_rsp_msg_v01 {
 	struct qmi_response_type_v01 resp;
 };
 
 #define IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_RSP_MSG_V01_MAX_MSG_LEN 7
-extern struct
-qmi_elem_info ims_private_service_subscribe_for_indications_rsp_msg_v01_ei[];
+extern struct qmi_elem_info
+ims_private_service_subscribe_for_indications_rsp_msg_v01_ei[];
+
+struct ims_private_service_mt_invite_ind_msg_v01 {
+	enum ims_subscription_type_enum_v01 subscription_type;
+	u8 iccid_valid;
+	char iccid[IMS_PRIVATE_SERVICE_MAX_ICCID_LEN_V01 + 1];
+	u8 header_value_list_valid;
+	u32 header_value_list_len;
+	struct ims_private_service_header_value_v01
+	header_value_list[IMS_PRIVATE_SERVICE_MAX_MT_INVITE_HEADERS_V01];
+};
+
+#define IMS_PRIVATE_SERVICE_MT_INVITE_IND_MSG_V01_MAX_MSG_LEN 30815
+extern struct qmi_elem_info ims_private_service_mt_invite_ind_msg_v01_ei[];
 
 struct ims_private_service_wfc_call_status_ind_msg_v01 {
 	u8 wfc_call_active;
+	u8 all_wfc_calls_held_valid;
+	u8 all_wfc_calls_held;
+	u8 is_wfc_emergency_valid;
+	u8 is_wfc_emergency;
+	u8 twt_ims_start_valid;
+	u64 twt_ims_start;
+	u8 twt_ims_int_valid;
+	u16 twt_ims_int;
+	u8 media_quality_valid;
+	enum wfc_media_quality_v01 media_quality;
 };
 
-#define IMS_PRIVATE_SERVICE_WFC_CALL_STATUS_IND_MSG_V01_MAX_MSG_LEN 4
-extern struct
-qmi_elem_info ims_private_service_wfc_call_status_ind_msg_v01_ei[];
+#define IMS_PRIVATE_SERVICE_WFC_CALL_STATUS_IND_MSG_V01_MAX_MSG_LEN 35
+extern struct qmi_elem_info
+ims_private_service_wfc_call_status_ind_msg_v01_ei[];
+
+struct ims_private_service_wfc_call_twt_config_req_msg_v01 {
+	u8 twt_sta_start_valid;
+	u64 twt_sta_start;
+	u8 twt_sta_int_valid;
+	u16 twt_sta_int;
+	u8 twt_sta_upo_valid;
+	u16 twt_sta_upo;
+	u8 twt_sta_sp_valid;
+	u16 twt_sta_sp;
+	u8 twt_sta_dl_valid;
+	u16 twt_sta_dl;
+	u8 twt_sta_config_changed_valid;
+	u8 twt_sta_config_changed;
+};
+
+#define IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_REQ_MSG_V01_MAX_MSG_LEN 35
+extern struct qmi_elem_info
+ims_private_service_wfc_call_twt_config_req_msg_v01_ei[];
+
+struct ims_private_service_wfc_call_twt_config_rsp_msg_v01 {
+	struct qmi_response_type_v01 resp;
+};
+
+#define IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_RSP_MSG_V01_MAX_MSG_LEN 7
+extern struct qmi_elem_info
+ims_private_service_wfc_call_twt_config_rsp_msg_v01_ei[];
 
 #endif
diff --git a/drivers/net/wireless/cnss2/qmi.c b/drivers/net/wireless/cnss2/qmi.c
index ea73016bf466..872290abb118 100644
--- a/drivers/net/wireless/cnss2/qmi.c
+++ b/drivers/net/wireless/cnss2/qmi.c
@@ -27,6 +27,7 @@
 #define IMS_TIMEOUT                     QMI_WLFW_TIMEOUT_JF
 
 #define QMI_WLFW_MAX_RECV_BUF_SIZE	SZ_8K
+#define IMSPRIVATE_SERVICE_MAX_MSG_LEN	SZ_8K
 
 #define QMI_WLFW_MAC_READY_TIMEOUT_MS	50
 #define QMI_WLFW_MAC_READY_MAX_RETRY	200
@@ -97,6 +98,8 @@ static int cnss_wlfw_ind_register_send_sync(struct cnss_plat_data *plat_priv)
 	req->qdss_trace_free_enable = 1;
 	req->respond_get_info_enable_valid = 1;
 	req->respond_get_info_enable = 1;
+	req->wfc_call_twt_config_enable_valid = 1;
+	req->wfc_call_twt_config_enable = 1;
 
 	ret = qmi_txn_init(&plat_priv->qmi_wlfw, &txn,
 			   wlfw_ind_register_resp_msg_v01_ei, resp);
@@ -1481,17 +1484,15 @@ out:
 	return ret;
 }
 
-int cnss_wlfw_wfc_call_status_send_sync(struct cnss_plat_data *plat_priv,
-					u32 data_len, const void *data)
+static int cnss_wlfw_wfc_call_status_send_sync
+	(struct cnss_plat_data *plat_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;
 
-	cnss_pr_dbg("Sending WFC call status: state: 0x%lx\n",
-		    plat_priv->driver_state);
-
 	req = kzalloc(sizeof(*req), GFP_KERNEL);
 	if (!req)
 		return -ENOMEM;
@@ -1502,13 +1503,38 @@ int cnss_wlfw_wfc_call_status_send_sync(struct cnss_plat_data *plat_priv,
 		return -ENOMEM;
 	}
 
-	req->wfc_call_status_len = data_len;
-	memcpy(req->wfc_call_status, data, req->wfc_call_status_len);
+	/**
+	 * 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;
+
+	cnss_pr_dbg("CNSS->FW: WFC_CALL_REQ: state: 0x%lx\n",
+		    plat_priv->driver_state);
 
 	ret = qmi_txn_init(&plat_priv->qmi_wlfw, &txn,
 			   wlfw_wfc_call_status_resp_msg_v01_ei, resp);
 	if (ret < 0) {
-		cnss_pr_err("Fail to initialize txn for WFC call status request: err %d\n",
+		cnss_pr_err("CNSS->FW: WFC_CALL_REQ: QMI Txn Init: Err %d\n",
 			    ret);
 		goto out;
 	}
@@ -1519,29 +1545,25 @@ int cnss_wlfw_wfc_call_status_send_sync(struct cnss_plat_data *plat_priv,
 			       wlfw_wfc_call_status_req_msg_v01_ei, req);
 	if (ret < 0) {
 		qmi_txn_cancel(&txn);
-		cnss_pr_err("Fail to send WFC call status request: err %d\n",
+		cnss_pr_err("CNSS->FW: WFC_CALL_REQ: QMI Send Err: %d\n",
 			    ret);
 		goto out;
 	}
 
 	ret = qmi_txn_wait(&txn, QMI_WLFW_TIMEOUT_JF);
 	if (ret < 0) {
-		cnss_pr_err("Fail to wait for response of WFC call status request, err %d\n",
+		cnss_pr_err("FW->CNSS: WFC_CALL_RSP: QMI Wait Err: %d\n",
 			    ret);
 		goto out;
 	}
 
 	if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
-		cnss_pr_err("WFC call status request failed, result: %d, err: %d\n",
+		cnss_pr_err("FW->CNSS: WFC_CALL_RSP: Result: %d Err: %d\n",
 			    resp->resp.result, resp->resp.error);
 		ret = -resp->resp.result;
 		goto out;
 	}
-
-	kfree(req);
-	kfree(resp);
-	return 0;
-
+	ret = 0;
 out:
 	kfree(req);
 	kfree(resp);
@@ -1970,6 +1992,113 @@ static void cnss_wlfw_respond_get_info_ind_cb(struct qmi_handle *qmi_wlfw,
 				       (void *)ind_msg->data,
 				       ind_msg->data_len);
 }
+
+static int cnss_ims_wfc_call_twt_cfg_send_sync
+	(struct cnss_plat_data *plat_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;
+
+	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;
+
+	cnss_pr_dbg("CNSS->IMS: TWT_CFG_REQ: state: 0x%lx\n",
+		    plat_priv->driver_state);
+
+	ret =
+	qmi_txn_init(&plat_priv->ims_qmi, &txn,
+		     ims_private_service_wfc_call_twt_config_rsp_msg_v01_ei,
+		     resp);
+	if (ret < 0) {
+		cnss_pr_err("CNSS->IMS: TWT_CFG_REQ: QMI Txn Init Err: %d\n",
+			    ret);
+		goto out;
+	}
+
+	ret =
+	qmi_send_request(&plat_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);
+		cnss_pr_err("CNSS->IMS: TWT_CFG_REQ: QMI Send Err: %d\n", ret);
+		goto out;
+	}
+
+	ret = qmi_txn_wait(&txn, QMI_WLFW_TIMEOUT_JF);
+	if (ret < 0) {
+		cnss_pr_err("IMS->CNSS: TWT_CFG_RSP: QMI Wait Err: %d\n", ret);
+		goto out;
+	}
+
+	if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
+		cnss_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;
+}
+
+static void cnss_wlfw_process_twt_cfg_ind(struct qmi_handle *qmi_wlfw,
+					  struct sockaddr_qrtr *sq,
+					  struct qmi_txn *txn,
+					  const void *data)
+{
+	struct cnss_plat_data *plat_priv =
+		container_of(qmi_wlfw, struct cnss_plat_data, qmi_wlfw);
+	const struct wlfw_wfc_call_twt_config_ind_msg_v01 *ind_msg = data;
+
+	if (!txn) {
+		cnss_pr_err("FW->CNSS: TWT_CFG_IND: Spurious indication\n");
+		return;
+	}
+
+	if (!ind_msg) {
+		cnss_pr_err("FW->CNSS: TWT_CFG_IND: Invalid indication\n");
+		return;
+	}
+	cnss_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);
+
+	cnss_ims_wfc_call_twt_cfg_send_sync(plat_priv, ind_msg);
+}
+
 static struct qmi_msg_handler qmi_wlfw_msg_handlers[] = {
 	{
 		.type = QMI_INDICATION,
@@ -2046,6 +2175,14 @@ static struct qmi_msg_handler qmi_wlfw_msg_handlers[] = {
 		sizeof(struct wlfw_respond_get_info_ind_msg_v01),
 		.fn = cnss_wlfw_respond_get_info_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 = cnss_wlfw_process_twt_cfg_ind
+	},
 	{}
 };
 
@@ -2460,35 +2597,34 @@ static void ims_subscribe_for_indication_resp_cb(struct qmi_handle *qmi,
 	}
 }
 
-static void ims_wfc_call_status_ind_cb(struct qmi_handle *ims_qmi,
-				       struct sockaddr_qrtr *sq,
-				       struct qmi_txn *txn, const void *data)
+static void
+cnss_ims_process_wfc_call_ind_cb(struct qmi_handle *ims_qmi,
+				 struct sockaddr_qrtr *sq,
+				 struct qmi_txn *txn, const void *data)
 {
 	struct cnss_plat_data *plat_priv =
 		container_of(ims_qmi, struct cnss_plat_data, ims_qmi);
 	const
 	struct ims_private_service_wfc_call_status_ind_msg_v01 *ind_msg = data;
-	u32 data_len = 0;
-
-	cnss_pr_dbg("Received IMS wfc call status indication\n");
 
 	if (!txn) {
-		cnss_pr_err("Spurious indication\n");
+		cnss_pr_err("IMS->CNSS: WFC_CALL_IND: Spurious indication\n");
 		return;
 	}
 
 	if (!ind_msg) {
-		cnss_pr_err("Invalid indication\n");
+		cnss_pr_err("IMS->CNSS: WFC_CALL_IND: Invalid indication\n");
 		return;
 	}
+	cnss_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);
 
-	data_len = sizeof(*ind_msg);
-	if (data_len > QMI_WLFW_MAX_WFC_CALL_STATUS_DATA_SIZE_V01) {
-		cnss_pr_err("Exceed maxinum data len:%u\n", data_len);
-		return;
-	}
-
-	cnss_wlfw_wfc_call_status_send_sync(plat_priv, data_len, ind_msg);
+	cnss_wlfw_wfc_call_status_send_sync(plat_priv, ind_msg);
 }
 
 static struct qmi_msg_handler qmi_ims_msg_handlers[] = {
@@ -2508,7 +2644,7 @@ static struct qmi_msg_handler qmi_ims_msg_handlers[] = {
 		.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 = ims_wfc_call_status_ind_cb
+		.fn = cnss_ims_process_wfc_call_ind_cb
 	},
 	{}
 };
diff --git a/drivers/net/wireless/cnss2/qmi.h b/drivers/net/wireless/cnss2/qmi.h
index 90a9dbddcbed..60967e7843e9 100644
--- a/drivers/net/wireless/cnss2/qmi.h
+++ b/drivers/net/wireless/cnss2/qmi.h
@@ -4,7 +4,7 @@
 #ifndef _CNSS_QMI_H
 #define _CNSS_QMI_H
 
-#include <linux/soc/qcom/qmi.h>
+#include "wlan_firmware_service_v01.h"
 
 struct cnss_plat_data;
 
@@ -29,7 +29,6 @@ struct cnss_qmi_event_qdss_trace_save_data {
 };
 
 #ifdef CONFIG_CNSS2_QMI
-#include "wlan_firmware_service_v01.h"
 #include "coexistence_service_v01.h"
 #include "ip_multimedia_subsystem_private_service_v01.h"
 
@@ -61,8 +60,6 @@ int cnss_wlfw_antenna_grant_send_sync(struct cnss_plat_data *plat_priv);
 int cnss_wlfw_dynamic_feature_mask_send_sync(struct cnss_plat_data *plat_priv);
 int cnss_wlfw_get_info_send_sync(struct cnss_plat_data *plat_priv, int type,
 				 void *cmd, int cmd_len);
-int cnss_wlfw_wfc_call_status_send_sync(struct cnss_plat_data *plat_priv,
-					u32 data_len, const void *data);
 int cnss_register_coex_service(struct cnss_plat_data *plat_priv);
 void cnss_unregister_coex_service(struct cnss_plat_data *plat_priv);
 int coex_antenna_switch_to_wlan_send_sync_msg(struct cnss_plat_data *plat_priv);
@@ -184,13 +181,6 @@ int cnss_wlfw_get_info_send_sync(struct cnss_plat_data *plat_priv, int type,
 	return 0;
 }
 
-static inline
-int cnss_wlfw_wfc_call_status_send_sync(struct cnss_plat_data *plat_priv,
-					u32 data_len, const void *data);
-{
-	return 0;
-}
-
 static inline
 int cnss_register_coex_service(struct cnss_plat_data *plat_priv)
 {
@@ -208,6 +198,9 @@ int coex_antenna_switch_to_wlan_send_sync_msg(struct cnss_plat_data *plat_priv)
 
 static inline
 int coex_antenna_switch_to_mdm_send_sync_msg(struct cnss_plat_data *plat_priv)
+{
+	return 0;
+}
 
 static inline
 int cnss_wlfw_qdss_trace_mem_info_send_sync(struct cnss_plat_data *plat_priv)
diff --git a/drivers/net/wireless/cnss2/wlan_firmware_service_v01.c b/drivers/net/wireless/cnss2/wlan_firmware_service_v01.c
index 1899d4a61905..6c768eda9120 100644
--- a/drivers/net/wireless/cnss2/wlan_firmware_service_v01.c
+++ b/drivers/net/wireless/cnss2/wlan_firmware_service_v01.c
@@ -464,8 +464,7 @@ struct qmi_elem_info wlfw_ind_register_req_msg_v01_ei[] = {
 		.elem_size      = sizeof(u8),
 		.array_type       = NO_ARRAY,
 		.tlv_type       = 0x10,
-		.offset         = offsetof(struct
-					   wlfw_ind_register_req_msg_v01,
+		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 					   fw_ready_enable_valid),
 	},
 	{
@@ -765,6 +764,24 @@ struct qmi_elem_info wlfw_ind_register_req_msg_v01_ei[] = {
 		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 					   m3_dump_upload_req_enable),
 	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x21,
+		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
+					   wfc_call_twt_config_enable_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x21,
+		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
+					   wfc_call_twt_config_enable),
+	},
 	{
 		.data_type      = QMI_EOTI,
 		.array_type       = NO_ARRAY,
@@ -3753,6 +3770,126 @@ struct qmi_elem_info wlfw_wfc_call_status_req_msg_v01_ei[] = {
 					   wlfw_wfc_call_status_req_msg_v01,
 					   wfc_call_status),
 	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   wfc_call_active_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   wfc_call_active),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   all_wfc_calls_held_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   all_wfc_calls_held),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x12,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   is_wfc_emergency_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x12,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   is_wfc_emergency),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x13,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   twt_ims_start_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_8_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u64),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x13,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   twt_ims_start),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x14,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   twt_ims_int_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_2_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u16),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x14,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   twt_ims_int),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x15,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   media_quality_valid),
+	},
+	{
+		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
+		.elem_len       = 1,
+		.elem_size      = sizeof(enum wlfw_wfc_media_quality_v01),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x15,
+		.offset         = offsetof(struct
+					   wlfw_wfc_call_status_req_msg_v01,
+					   media_quality),
+	},
 	{
 		.data_type      = QMI_EOTI,
 		.array_type       = NO_ARRAY,
@@ -4138,3 +4275,131 @@ struct qmi_elem_info wlfw_exit_power_save_resp_msg_v01_ei[] = {
 		.tlv_type       = QMI_COMMON_TLV_TYPE,
 	},
 };
+
+struct qmi_elem_info wlfw_wfc_call_twt_config_ind_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_start_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_8_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u64),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_start),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_int_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_2_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u16),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_int),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x12,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_upo_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_2_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u16),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x12,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_upo),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x13,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_sp_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_2_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u16),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x13,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_sp),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x14,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_dl_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_2_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u16),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x14,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_dl),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x15,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_config_changed_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(u8),
+		.array_type       = NO_ARRAY,
+		.tlv_type       = 0x15,
+		.offset         =
+		offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
+			 twt_sta_config_changed),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.array_type       = NO_ARRAY,
+		.tlv_type       = QMI_COMMON_TLV_TYPE,
+	},
+};
diff --git a/drivers/net/wireless/cnss2/wlan_firmware_service_v01.h b/drivers/net/wireless/cnss2/wlan_firmware_service_v01.h
index e105cd48a9c4..c42038911142 100644
--- a/drivers/net/wireless/cnss2/wlan_firmware_service_v01.h
+++ b/drivers/net/wireless/cnss2/wlan_firmware_service_v01.h
@@ -84,6 +84,7 @@
 #define QMI_WLFW_MAC_ADDR_REQ_V01 0x0033
 #define QMI_WLFW_EXIT_POWER_SAVE_RESP_V01 0x0050
 #define QMI_WLFW_RESPOND_MEM_RESP_V01 0x0036
+#define QMI_WLFW_WFC_CALL_TWT_CONFIG_IND_V01 0x0051
 #define QMI_WLFW_VBATT_RESP_V01 0x0032
 #define QMI_WLFW_MSA_INFO_REQ_V01 0x002D
 #define QMI_WLFW_QDSS_TRACE_FREE_IND_V01 0x0046
@@ -153,6 +154,7 @@ enum wlfw_mem_type_enum_v01 {
 	QMI_WLFW_MEM_CAL_V01 = 4,
 	QMI_WLFW_MEM_DPD_V01 = 5,
 	QMI_WLFW_MEM_QDSS_V01 = 6,
+	QMI_WLFW_MEM_HANG_DATA_V01 = 7,
 	WLFW_MEM_TYPE_ENUM_MAX_VAL_V01 = INT_MAX,
 };
 
@@ -163,6 +165,15 @@ enum wlfw_qdss_trace_mode_enum_v01 {
 	WLFW_QDSS_TRACE_MODE_ENUM_MAX_VAL_V01 = INT_MAX,
 };
 
+enum wlfw_wfc_media_quality_v01 {
+	WLFW_WFC_MEDIA_QUALITY_MIN_VAL_V01 = INT_MIN,
+	QMI_WLFW_WFC_MEDIA_QUAL_NOT_AVAILABLE_V01 = 0,
+	QMI_WLFW_WFC_MEDIA_QUAL_BAD_V01 = 1,
+	QMI_WLFW_WFC_MEDIA_QUAL_GOOD_V01 = 2,
+	QMI_WLFW_WFC_MEDIA_QUAL_EXCELLENT_V01 = 3,
+	WLFW_WFC_MEDIA_QUALITY_MAX_VAL_V01 = INT_MAX,
+};
+
 enum wlfw_soc_wake_enum_v01 {
 	WLFW_SOC_WAKE_ENUM_MIN_VAL_V01 = INT_MIN,
 	QMI_WLFW_WAKE_REQUEST_V01 = 0,
@@ -302,9 +313,11 @@ struct wlfw_ind_register_req_msg_v01 {
 	u8 respond_get_info_enable;
 	u8 m3_dump_upload_req_enable_valid;
 	u8 m3_dump_upload_req_enable;
+	u8 wfc_call_twt_config_enable_valid;
+	u8 wfc_call_twt_config_enable;
 };
 
-#define WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN 74
+#define WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN 78
 extern struct qmi_elem_info wlfw_ind_register_req_msg_v01_ei[];
 
 struct wlfw_ind_register_resp_msg_v01 {
@@ -979,9 +992,21 @@ extern struct qmi_elem_info wlfw_antenna_grant_resp_msg_v01_ei[];
 struct wlfw_wfc_call_status_req_msg_v01 {
 	u32 wfc_call_status_len;
 	u8 wfc_call_status[QMI_WLFW_MAX_WFC_CALL_STATUS_DATA_SIZE_V01];
+	u8 wfc_call_active_valid;
+	u8 wfc_call_active;
+	u8 all_wfc_calls_held_valid;
+	u8 all_wfc_calls_held;
+	u8 is_wfc_emergency_valid;
+	u8 is_wfc_emergency;
+	u8 twt_ims_start_valid;
+	u64 twt_ims_start;
+	u8 twt_ims_int_valid;
+	u16 twt_ims_int;
+	u8 media_quality_valid;
+	enum wlfw_wfc_media_quality_v01 media_quality;
 };
 
-#define WLFW_WFC_CALL_STATUS_REQ_MSG_V01_MAX_MSG_LEN 261
+#define WLFW_WFC_CALL_STATUS_REQ_MSG_V01_MAX_MSG_LEN 296
 extern struct qmi_elem_info wlfw_wfc_call_status_req_msg_v01_ei[];
 
 struct wlfw_wfc_call_status_resp_msg_v01 {
@@ -1092,4 +1117,22 @@ struct wlfw_exit_power_save_resp_msg_v01 {
 #define WLFW_EXIT_POWER_SAVE_RESP_MSG_V01_MAX_MSG_LEN 7
 extern struct qmi_elem_info wlfw_exit_power_save_resp_msg_v01_ei[];
 
+struct wlfw_wfc_call_twt_config_ind_msg_v01 {
+	u8 twt_sta_start_valid;
+	u64 twt_sta_start;
+	u8 twt_sta_int_valid;
+	u16 twt_sta_int;
+	u8 twt_sta_upo_valid;
+	u16 twt_sta_upo;
+	u8 twt_sta_sp_valid;
+	u16 twt_sta_sp;
+	u8 twt_sta_dl_valid;
+	u16 twt_sta_dl;
+	u8 twt_sta_config_changed_valid;
+	u8 twt_sta_config_changed;
+};
+
+#define WLFW_WFC_CALL_TWT_CONFIG_IND_MSG_V01_MAX_MSG_LEN 35
+extern struct qmi_elem_info wlfw_wfc_call_twt_config_ind_msg_v01_ei[];
+
 #endif