icnss: Update WLFW QMI messages

Add QMI message to send MSA0 physical memory start address
and size to wlan FW.
Add QMI message indication to get the HAL-PYH Pin connect test
result from wlan FW.
Add a new qmi message for sending fw debug configuration.
Update cap_resp message.

CRs-Fixed: 978217
Change-Id: Ie0fa374b720ebbffd1d1fd5b9289b2aa816a822a
Signed-off-by: Yuanyuan Liu <yuanliu@codeaurora.org>

Documentation/devicetree/bindings/cnss/icnss.txt

@@ -11,6 +11,7 @@ Required properties:
   - reg: Memory regions defined as starting address and size
   - reg-names: Names of the memory regions defined in reg entry
   - interrupts: Copy engine interrupt table
+  - qcom,wlan-msa-memory: MSA memory size
 
 Optional properties:
 
@@ -33,4 +34,5 @@ Example:
 		   <0 139 0 /* CE9 */ >,
 		   <0 140 0 /* CE10 */ >,
 		   <0 141 0 /* CE11 */ >;
+        qcom,wlan-msa-memory = <0x200000>;
     };

drivers/soc/qcom/icnss.c

@@ -1,4 +1,4 @@
-/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
@@ -20,6 +20,7 @@
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/dma-mapping.h>
 #include <linux/qmi_encdec.h>
 #include <soc/qcom/memory_dump.h>
 #include <soc/qcom/icnss.h>
@@ -85,11 +86,19 @@ static struct {
 	struct work_struct qmi_event_work;
 	struct work_struct qmi_recv_msg_work;
 	struct workqueue_struct *qmi_event_wq;
+	phys_addr_t msa_phys;
+	uint32_t msa_mem_size;
+	void *msa_addr;
 	uint32_t state;
-	u32 board_id;
+	struct wlfw_rf_chip_info_s_v01 chip_info;
-	u32 num_peers;
+	struct wlfw_rf_board_info_s_v01 board_info;
-	u32 mac_version;
+	struct wlfw_soc_info_s_v01 soc_info;
-	char fw_version[QMI_WLFW_MAX_STR_LEN_V01 + 1];
+	struct wlfw_fw_version_info_s_v01 fw_version_info;
+	u32 pwr_pin_result;
+	u32 phy_io_pin_result;
+	u32 rf_pin_result;
+	struct icnss_mem_region_info
+		icnss_mem_region[QMI_WLFW_MAX_NUM_MEMORY_REGIONS_V01];
 } *penv;
 
 static int icnss_qmi_event_post(enum icnss_qmi_event_type type, void *data)
@@ -116,6 +125,167 @@ static int icnss_qmi_event_post(enum icnss_qmi_event_type type, void *data)
 	return 0;
 }
 
+static int icnss_qmi_pin_connect_result_ind(void *msg, unsigned int msg_len)
+{
+	struct msg_desc ind_desc;
+	struct wlfw_pin_connect_result_ind_msg_v01 ind_msg;
+	int ret = 0;
+
+	if (!penv || !penv->wlfw_clnt) {
+		ret = -ENODEV;
+		goto out;
+	}
+
+	ind_desc.msg_id = QMI_WLFW_PIN_CONNECT_RESULT_IND_V01;
+	ind_desc.max_msg_len = WLFW_PIN_CONNECT_RESULT_IND_MSG_V01_MAX_MSG_LEN;
+	ind_desc.ei_array = wlfw_pin_connect_result_ind_msg_v01_ei;
+
+	ret = qmi_kernel_decode(&ind_desc, &ind_msg, msg, msg_len);
+	if (ret < 0) {
+		pr_err("%s: Failed to decode message!\n", __func__);
+		goto out;
+	}
+
+	/* store pin result locally */
+	if (ind_msg.pwr_pin_result_valid)
+		penv->pwr_pin_result = ind_msg.pwr_pin_result;
+	if (ind_msg.phy_io_pin_result_valid)
+		penv->phy_io_pin_result = ind_msg.phy_io_pin_result;
+	if (ind_msg.rf_pin_result_valid)
+		penv->rf_pin_result = ind_msg.rf_pin_result;
+
+	pr_debug("%s: Pin connect Result: pwr_pin: 0x%x phy_io_pin: 0x%x rf_io_pin: 0x%x\n",
+		__func__, ind_msg.pwr_pin_result, ind_msg.phy_io_pin_result,
+		ind_msg.rf_pin_result);
+out:
+	return ret;
+}
+
+
+static int icnss_adrastea_power_on(void)
+{
+	int ret = 0;
+
+	/* TZ API of power on adrastea */
+
+	return ret;
+}
+
+void icnss_adrastea_power_off(void)
+{
+	/* TZ API of power off adrastea */
+}
+
+static int wlfw_msa_mem_info_send_sync_msg(void)
+{
+	int ret = 0;
+	int i;
+	struct wlfw_msa_info_req_msg_v01 req;
+	struct wlfw_msa_info_resp_msg_v01 resp;
+	struct msg_desc req_desc, resp_desc;
+
+	if (!penv || !penv->wlfw_clnt) {
+		ret = -ENODEV;
+		goto out;
+	}
+
+	memset(&req, 0, sizeof(req));
+	memset(&resp, 0, sizeof(resp));
+
+	req.msa_addr = penv->msa_phys;
+	req.size = penv->msa_mem_size;
+
+	req_desc.max_msg_len = WLFW_MSA_INFO_REQ_MSG_V01_MAX_MSG_LEN;
+	req_desc.msg_id = QMI_WLFW_MSA_INFO_REQ_V01;
+	req_desc.ei_array = wlfw_msa_info_req_msg_v01_ei;
+
+	resp_desc.max_msg_len = WLFW_MSA_INFO_RESP_MSG_V01_MAX_MSG_LEN;
+	resp_desc.msg_id = QMI_WLFW_MSA_INFO_RESP_V01;
+	resp_desc.ei_array = wlfw_msa_info_resp_msg_v01_ei;
+
+	ret = qmi_send_req_wait(penv->wlfw_clnt, &req_desc, &req, sizeof(req),
+			&resp_desc, &resp, sizeof(resp), WLFW_TIMEOUT_MS);
+	if (ret < 0) {
+		pr_err("%s: send req failed %d\n", __func__, ret);
+		goto out;
+	}
+
+	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
+		pr_err("%s: QMI request failed %d %d\n",
+			__func__, resp.resp.result, resp.resp.error);
+		ret = resp.resp.result;
+		goto out;
+	}
+
+	pr_debug("%s: Receive mem_region_info_len: %d\n",
+			__func__, resp.mem_region_info_len);
+
+	if (resp.mem_region_info_len > 2) {
+		pr_err("%s : Invalid memory region length received\n",
+		       __func__);
+		ret = -EINVAL;
+		goto out;
+	}
+
+	for (i = 0; i < resp.mem_region_info_len; i++) {
+		penv->icnss_mem_region[i].reg_addr =
+			resp.mem_region_info[i].region_addr;
+		penv->icnss_mem_region[i].size =
+			resp.mem_region_info[i].size;
+		penv->icnss_mem_region[i].secure_flag =
+			resp.mem_region_info[i].secure_flag;
+		pr_debug("%s : Memory Region: %d  Addr:0x%x Size : %d Flag: %d\n",
+			 __func__,
+			 i,
+			 (unsigned int)penv->icnss_mem_region[i].reg_addr,
+			 penv->icnss_mem_region[i].size,
+			 penv->icnss_mem_region[i].secure_flag);
+	}
+
+out:
+	return ret;
+}
+
+static int wlfw_msa_ready_send_sync_msg(void)
+{
+	int ret;
+	struct wlfw_msa_ready_req_msg_v01 req;
+	struct wlfw_msa_ready_resp_msg_v01 resp;
+	struct msg_desc req_desc, resp_desc;
+
+	if (!penv || !penv->wlfw_clnt) {
+		ret = -ENODEV;
+		goto out;
+	}
+
+	memset(&req, 0, sizeof(req));
+	memset(&resp, 0, sizeof(resp));
+
+	req_desc.max_msg_len = WLFW_MSA_READY_REQ_MSG_V01_MAX_MSG_LEN;
+	req_desc.msg_id = QMI_WLFW_MSA_READY_REQ_V01;
+	req_desc.ei_array = wlfw_msa_ready_req_msg_v01_ei;
+
+	resp_desc.max_msg_len = WLFW_MSA_READY_RESP_MSG_V01_MAX_MSG_LEN;
+	resp_desc.msg_id = QMI_WLFW_MSA_READY_RESP_V01;
+	resp_desc.ei_array = wlfw_msa_ready_resp_msg_v01_ei;
+
+	ret = qmi_send_req_wait(penv->wlfw_clnt, &req_desc, &req, sizeof(req),
+			&resp_desc, &resp, sizeof(resp), WLFW_TIMEOUT_MS);
+	if (ret < 0) {
+		pr_err("%s: send req failed %d\n", __func__, ret);
+		goto out;
+	}
+
+	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
+		pr_err("%s: QMI request failed %d %d\n",
+			__func__, resp.resp.result, resp.resp.error);
+		ret = resp.resp.result;
+		goto out;
+	}
+out:
+	return ret;
+}
+
 static int wlfw_ind_register_send_sync_msg(void)
 {
 	int ret;
@@ -133,6 +303,10 @@ static int wlfw_ind_register_send_sync_msg(void)
 
 	req.fw_ready_enable_valid = 1;
 	req.fw_ready_enable = 1;
+	req.msa_ready_enable_valid = 1;
+	req.msa_ready_enable = 1;
+	req.pin_connect_result_enable_valid = 1;
+	req.pin_connect_result_enable = 1;
 
 	req_desc.max_msg_len = WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN;
 	req_desc.msg_id = QMI_WLFW_IND_REGISTER_REQ_V01;
@@ -198,19 +372,25 @@ static int wlfw_cap_send_sync_msg(void)
 	}
 
 	/* store cap locally */
-	if (resp.board_id_valid)
+	if (resp.chip_info_valid)
-		penv->board_id = resp.board_id;
+		penv->chip_info = resp.chip_info;
-	if (resp.num_peers_valid)
+	if (resp.board_info_valid)
-		penv->num_peers = resp.num_peers;
+		penv->board_info = resp.board_info;
-	if (resp.mac_version_valid)
+	else
-		penv->mac_version = resp.mac_version;
+		penv->board_info.board_id = 0xFF;
-	if (resp.fw_version_valid)
+	if (resp.soc_info_valid)
-		strlcpy(penv->fw_version, resp.fw_version,
+		penv->soc_info = resp.soc_info;
-			QMI_WLFW_MAX_STR_LEN_V01 + 1);
+	if (resp.fw_version_info_valid)
+		penv->fw_version_info = resp.fw_version_info;
 
-	pr_debug("%s: board_id:0x%0x num_peers: %d mac_version: 0x%0x fw_version: %s",
+	pr_debug("%s: chip_id: 0x%0x, chip_family: 0x%0x, board_id: 0x%0x, soc_id: 0x%0x, fw_version: 0x%0x, fw_build_timestamp: %s",
-		__func__, penv->board_id, penv->num_peers,
+		__func__,
-		penv->mac_version, penv->fw_version);
+		penv->chip_info.chip_id,
+		penv->chip_info.chip_family,
+		penv->board_info.board_id,
+		penv->soc_info.soc_id,
+		penv->fw_version_info.fw_version,
+		penv->fw_version_info.fw_build_timestamp);
 out:
 	return ret;
 }
@@ -301,6 +481,49 @@ out:
 	return ret;
 }
 
+static int wlfw_ini_send_sync_msg(bool enablefwlog)
+{
+	int ret;
+	struct wlfw_ini_req_msg_v01 req;
+	struct wlfw_ini_resp_msg_v01 resp;
+	struct msg_desc req_desc, resp_desc;
+
+	if (!penv || !penv->wlfw_clnt) {
+		ret = -ENODEV;
+		goto out;
+	}
+
+	memset(&req, 0, sizeof(req));
+	memset(&resp, 0, sizeof(resp));
+
+	req.enablefwlog_valid = 1;
+	req.enablefwlog = enablefwlog;
+
+	req_desc.max_msg_len = WLFW_INI_REQ_MSG_V01_MAX_MSG_LEN;
+	req_desc.msg_id = QMI_WLFW_INI_REQ_V01;
+	req_desc.ei_array = wlfw_ini_req_msg_v01_ei;
+
+	resp_desc.max_msg_len = WLFW_INI_RESP_MSG_V01_MAX_MSG_LEN;
+	resp_desc.msg_id = QMI_WLFW_INI_RESP_V01;
+	resp_desc.ei_array = wlfw_ini_resp_msg_v01_ei;
+
+	ret = qmi_send_req_wait(penv->wlfw_clnt, &req_desc, &req, sizeof(req),
+			&resp_desc, &resp, sizeof(resp), WLFW_TIMEOUT_MS);
+	if (ret < 0) {
+		pr_err("%s: send req failed %d\n", __func__, ret);
+		goto out;
+	}
+
+	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
+		pr_err("%s: QMI request failed %d %d\n",
+		       __func__, resp.resp.result, resp.resp.error);
+		ret = resp.resp.result;
+		goto out;
+	}
+out:
+	return ret;
+}
+
 static void icnss_qmi_wlfw_clnt_notify_work(struct work_struct *work)
 {
 	int ret;
@@ -345,6 +568,15 @@ static void icnss_qmi_wlfw_clnt_ind(struct qmi_handle *handle,
 	case QMI_WLFW_FW_READY_IND_V01:
 		icnss_qmi_event_post(ICNSS_QMI_EVENT_FW_READY_IND, NULL);
 		break;
+	case QMI_WLFW_MSA_READY_IND_V01:
+		pr_debug("%s: Received MSA Ready Indication msg_id 0x%x\n",
+			 __func__, msg_id);
+		break;
+	case QMI_WLFW_PIN_CONNECT_RESULT_IND_V01:
+		pr_debug("%s: Received Pin Connect Test Result msg_id 0x%x\n",
+			 __func__, msg_id);
+		icnss_qmi_pin_connect_result_ind(msg, msg_len);
+		break;
 	default:
 		pr_err("%s: Invalid msg_id 0x%x\n", __func__, msg_id);
 		break;
@@ -377,8 +609,8 @@ static int icnss_qmi_event_server_arrive(void *data)
 	ret = qmi_register_ind_cb(penv->wlfw_clnt,
 				  icnss_qmi_wlfw_clnt_ind, penv);
 	if (ret < 0) {
-		pr_err("Failed to register indication callback: %d\n",
+		pr_err("%s: Failed to register indication callback: %d\n",
-		       ret);
+		       __func__, ret);
 		goto fail;
 	}
 
@@ -386,17 +618,48 @@ static int icnss_qmi_event_server_arrive(void *data)
 
 	pr_info("%s: QMI Server Connected\n", __func__);
 
+	ret = icnss_adrastea_power_on();
+	if (ret < 0) {
+		pr_err("%s: Failed to power on hardware: %d\n",
+		       __func__, ret);
+		goto fail;
+	}
+
 	ret = wlfw_ind_register_send_sync_msg();
 	if (ret < 0) {
-		pr_err("Failed to send indication message: %d\n",
+		pr_err("%s: Failed to send indication message: %d\n",
-		       ret);
+		       __func__, ret);
 		goto out;
 	}
 
+	if (penv->msa_mem_size) {
+		penv->msa_addr = dma_alloc_coherent(&penv->pdev->dev,
+				    penv->msa_mem_size, &penv->msa_phys,
+				    GFP_KERNEL);
+
+		pr_debug("%s: MSA addr: %p, MSA phys: %pa\n", __func__,
+			penv->msa_addr, &penv->msa_phys);
+
+		if (penv->msa_addr) {
+			ret = wlfw_msa_mem_info_send_sync_msg();
+			if (ret < 0) {
+				pr_err("%s: Failed to send MSA info: %d\n",
+				       __func__, ret);
+				goto out;
+			}
+			ret = wlfw_msa_ready_send_sync_msg();
+			if (ret < 0) {
+				pr_err("%s: Failed to send MSA ready : %d\n",
+				       __func__, ret);
+				goto out;
+			}
+		}
+	}
+
 	ret = wlfw_cap_send_sync_msg();
 	if (ret < 0) {
-		pr_err("Failed to get capability: %d\n",
+		pr_err("%s: Failed to get capability: %d\n",
-		       ret);
+		       __func__, ret);
 		goto out;
 	}
 	return ret;
@@ -404,6 +667,10 @@ fail:
 	qmi_handle_destroy(penv->wlfw_clnt);
 	penv->wlfw_clnt = NULL;
 out:
+	if (penv->msa_addr) {
+		dma_free_coherent(&penv->pdev->dev, penv->msa_mem_size,
+				  penv->msa_addr, penv->msa_phys);
+	}
 	ICNSS_ASSERT(0);
 	return ret;
 }
@@ -416,6 +683,10 @@ static int icnss_qmi_event_server_exit(void *data)
 	pr_info("%s: QMI Service Disconnected\n", __func__);
 
 	qmi_handle_destroy(penv->wlfw_clnt);
+	if (penv->msa_addr) {
+		dma_free_coherent(&penv->pdev->dev, penv->msa_mem_size,
+				  penv->msa_addr, penv->msa_phys);
+	}
 	penv->state = 0;
 	penv->wlfw_clnt = NULL;
 
@@ -436,6 +707,9 @@ static int icnss_qmi_event_fw_ready_ind(void *data)
 		ret = -ENODEV;
 		goto out;
 	}
+
+	icnss_adrastea_power_off();
+
 	if (!penv->ops || !penv->ops->probe) {
 		pr_err("%s: WLAN driver is not registed yet\n", __func__);
 		ret = -ENOENT;
@@ -458,7 +732,7 @@ static int icnss_qmi_wlfw_clnt_svc_event_notify(struct notifier_block *this,
 	if (!penv)
 		return -ENODEV;
 
-	pr_debug("Event Notify: code: %ld", code);
+	pr_debug("%s: Event Notify: code: %ld", __func__, code);
 
 	switch (code) {
 	case QMI_SERVER_ARRIVE:
@@ -469,7 +743,7 @@ static int icnss_qmi_wlfw_clnt_svc_event_notify(struct notifier_block *this,
 		ret = icnss_qmi_event_post(ICNSS_QMI_EVENT_SERVER_EXIT, NULL);
 		break;
 	default:
-		pr_debug("Invalid code: %ld", code);
+		pr_debug("%s: Invalid code: %ld", __func__, code);
 		break;
 	}
 	return ret;
@@ -499,7 +773,8 @@ static void icnss_qmi_wlfw_event_work(struct work_struct *work)
 			icnss_qmi_event_fw_ready_ind(event->data);
 			break;
 		default:
-			pr_debug("Invalid Event type: %d", event->type);
+			pr_debug("%s: Invalid Event type: %d",
+				 __func__, event->type);
 			break;
 		}
 		kfree(event);
@@ -536,8 +811,12 @@ int icnss_register_driver(struct icnss_driver_ops *ops)
 	penv->ops = ops;
 
 	/* check for all conditions before invoking probe */
-	if (ICNSS_IS_FW_READY(penv->state) && penv->ops->probe)
+	if (ICNSS_IS_FW_READY(penv->state) && penv->ops->probe) {
 		ret = penv->ops->probe(&pdev->dev);
+	} else {
+		pr_err("icnss: FW is not ready\n");
+		ret = -ENOENT;
+	}
 
 out:
 	return ret;
@@ -744,6 +1023,18 @@ int icnss_get_soc_info(struct icnss_soc_info *info)
 }
 EXPORT_SYMBOL(icnss_get_soc_info);
 
+int icnss_set_fw_debug_mode(bool enablefwlog)
+{
+	int ret;
+
+	ret = wlfw_ini_send_sync_msg(enablefwlog);
+	if (ret)
+		pr_err("icnss: Fail to send ini, ret = %d\n", ret);
+
+	return ret;
+}
+EXPORT_SYMBOL(icnss_set_fw_debug_mode);
+
 int icnss_wlan_enable(struct icnss_wlan_enable_cfg *config,
 		      enum icnss_driver_mode mode,
 		      const char *host_version)
@@ -838,6 +1129,8 @@ static int icnss_probe(struct platform_device *pdev)
 	int ret = 0;
 	struct resource *res;
 	int i;
+	struct device *dev = &pdev->dev;
+	u32 msa_mem_size = 0;
 
 	if (penv)
 		return -EEXIST;
@@ -873,6 +1166,15 @@ static int icnss_probe(struct platform_device *pdev)
 		}
 	}
 
+	if (of_property_read_u32(dev->of_node, "qcom,wlan-msa-memory",
+				 &msa_mem_size) == 0) {
+		penv->msa_mem_size = msa_mem_size;
+	} else {
+		pr_err("icnss: Fail to get MSA Memory Size\n");
+		ret = -ENODEV;
+		goto out;
+	}
+
 	penv->qmi_event_wq = alloc_workqueue("icnss_qmi_event", 0, 0);
 	if (!penv->qmi_event_wq) {
 		pr_err("%s: workqueue creation failed\n", __func__);

drivers/soc/qcom/wlan_firmware_service_v01.c

@@ -1,4 +1,4 @@
- /* Copyright (c) 2015, The Linux Foundation. All rights reserved.
+ /* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
@@ -130,6 +130,127 @@ static struct elem_info wlfw_shadow_reg_cfg_s_v01_ei[] = {
 	},
 };
 
+static struct elem_info wlfw_memory_region_info_s_v01_ei[] = {
+	{
+		.data_type      = QMI_UNSIGNED_8_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint64_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0,
+		.offset         = offsetof(struct wlfw_memory_region_info_s_v01,
+					   region_addr),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint32_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0,
+		.offset         = offsetof(struct wlfw_memory_region_info_s_v01,
+					   size),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint8_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0,
+		.offset         = offsetof(struct wlfw_memory_region_info_s_v01,
+					   secure_flag),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+static struct elem_info wlfw_rf_chip_info_s_v01_ei[] = {
+	{
+		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint32_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0,
+		.offset         = offsetof(struct wlfw_rf_chip_info_s_v01,
+					   chip_id),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint32_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0,
+		.offset         = offsetof(struct wlfw_rf_chip_info_s_v01,
+					   chip_family),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+static struct elem_info wlfw_rf_board_info_s_v01_ei[] = {
+	{
+		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint32_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0,
+		.offset         = offsetof(struct wlfw_rf_board_info_s_v01,
+					   board_id),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+static struct elem_info wlfw_soc_info_s_v01_ei[] = {
+	{
+		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint32_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0,
+		.offset         = offsetof(struct wlfw_soc_info_s_v01,
+					   soc_id),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+static struct elem_info wlfw_fw_version_info_s_v01_ei[] = {
+	{
+		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint32_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0,
+		.offset         = offsetof(struct wlfw_fw_version_info_s_v01,
+					   fw_version),
+	},
+	{
+		.data_type      = QMI_STRING,
+		.elem_len       = QMI_WLFW_MAX_TIMESTAMP_LEN_V01 + 1,
+		.elem_size      = sizeof(char),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0,
+		.offset         = offsetof(struct wlfw_fw_version_info_s_v01,
+					   fw_build_timestamp),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
 struct elem_info wlfw_ind_register_req_msg_v01_ei[] = {
 	{
 		.data_type      = QMI_OPT_FLAG,
@@ -185,6 +306,42 @@ struct elem_info wlfw_ind_register_req_msg_v01_ei[] = {
 		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 					   initiate_cal_update_enable),
 	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint8_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x13,
+		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
+					   msa_ready_enable_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint8_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x13,
+		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
+					   msa_ready_enable),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint8_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x14,
+		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
+					   pin_connect_result_enable_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint8_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x14,
+		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
+					   pin_connect_result_enable),
+	},
 	{
 		.data_type      = QMI_EOTI,
 		.is_array       = NO_ARRAY,
@@ -218,6 +375,82 @@ struct elem_info wlfw_fw_ready_ind_msg_v01_ei[] = {
 	},
 };
 
+struct elem_info wlfw_msa_ready_ind_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+struct elem_info wlfw_pin_connect_result_ind_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint8_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         = offsetof(
+				   struct wlfw_pin_connect_result_ind_msg_v01,
+				   pwr_pin_result_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint32_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         = offsetof(
+				   struct wlfw_pin_connect_result_ind_msg_v01,
+				   pwr_pin_result),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint8_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         = offsetof(
+				   struct wlfw_pin_connect_result_ind_msg_v01,
+				   phy_io_pin_result_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint32_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x11,
+		.offset         = offsetof(
+				   struct wlfw_pin_connect_result_ind_msg_v01,
+				   phy_io_pin_result),
+	},
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint8_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x12,
+		.offset         = offsetof(
+				   struct wlfw_pin_connect_result_ind_msg_v01,
+				   rf_pin_result_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint32_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x12,
+		.offset         = offsetof(
+				   struct wlfw_pin_connect_result_ind_msg_v01,
+				   rf_pin_result),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
 struct elem_info wlfw_wlan_mode_req_msg_v01_ei[] = {
 	{
 		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
@@ -407,16 +640,17 @@ struct elem_info wlfw_cap_resp_msg_v01_ei[] = {
 		.is_array       = NO_ARRAY,
 		.tlv_type       = 0x10,
 		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
-					   board_id_valid),
+					   chip_info_valid),
 	},
 	{
-		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.data_type      = QMI_STRUCT,
 		.elem_len       = 1,
-		.elem_size      = sizeof(uint32_t),
+		.elem_size      = sizeof(struct wlfw_rf_chip_info_s_v01),
 		.is_array       = NO_ARRAY,
 		.tlv_type       = 0x10,
 		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
-					   board_id),
+					   chip_info),
+		.ei_array      = wlfw_rf_chip_info_s_v01_ei,
 	},
 	{
 		.data_type      = QMI_OPT_FLAG,
@@ -425,16 +659,17 @@ struct elem_info wlfw_cap_resp_msg_v01_ei[] = {
 		.is_array       = NO_ARRAY,
 		.tlv_type       = 0x11,
 		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
-					   num_peers_valid),
+					   board_info_valid),
 	},
 	{
-		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.data_type      = QMI_STRUCT,
 		.elem_len       = 1,
-		.elem_size      = sizeof(uint32_t),
+		.elem_size      = sizeof(struct wlfw_rf_board_info_s_v01),
 		.is_array       = NO_ARRAY,
 		.tlv_type       = 0x11,
 		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
-					   num_peers),
+					   board_info),
+		.ei_array      = wlfw_rf_board_info_s_v01_ei,
 	},
 	{
 		.data_type      = QMI_OPT_FLAG,
@@ -443,16 +678,17 @@ struct elem_info wlfw_cap_resp_msg_v01_ei[] = {
 		.is_array       = NO_ARRAY,
 		.tlv_type       = 0x12,
 		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
-					   mac_version_valid),
+					   soc_info_valid),
 	},
 	{
-		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.data_type      = QMI_STRUCT,
 		.elem_len       = 1,
-		.elem_size      = sizeof(uint32_t),
+		.elem_size      = sizeof(struct wlfw_soc_info_s_v01),
 		.is_array       = NO_ARRAY,
 		.tlv_type       = 0x12,
 		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
-					   mac_version),
+					   soc_info),
+		.ei_array      = wlfw_soc_info_s_v01_ei,
 	},
 	{
 		.data_type      = QMI_OPT_FLAG,
@@ -461,16 +697,17 @@ struct elem_info wlfw_cap_resp_msg_v01_ei[] = {
 		.is_array       = NO_ARRAY,
 		.tlv_type       = 0x13,
 		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
-					   fw_version_valid),
+					   fw_version_info_valid),
 	},
 	{
-		.data_type      = QMI_STRING,
+		.data_type      = QMI_STRUCT,
-		.elem_len       = QMI_WLFW_MAX_STR_LEN_V01 + 1,
+		.elem_len       = 1,
-		.elem_size      = sizeof(char),
+		.elem_size      = sizeof(struct wlfw_fw_version_info_s_v01),
 		.is_array       = NO_ARRAY,
 		.tlv_type       = 0x13,
 		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
-					   fw_version),
+					   fw_version_info),
+		.ei_array      = wlfw_fw_version_info_s_v01_ei,
 	},
 	{
 		.data_type      = QMI_EOTI,
@@ -976,3 +1213,136 @@ struct elem_info wlfw_cal_update_resp_msg_v01_ei[] = {
 		.is_array       = QMI_COMMON_TLV_TYPE,
 	},
 };
+
+struct elem_info wlfw_msa_info_req_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_UNSIGNED_8_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint64_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x01,
+		.offset         = offsetof(struct wlfw_msa_info_req_msg_v01,
+					   msa_addr),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_4_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint32_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x02,
+		.offset         = offsetof(struct wlfw_msa_info_req_msg_v01,
+					   size),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+struct elem_info wlfw_msa_info_resp_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_STRUCT,
+		.elem_len       = 1,
+		.elem_size      = sizeof(struct qmi_response_type_v01),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x02,
+		.offset         = offsetof(struct wlfw_msa_info_resp_msg_v01,
+					   resp),
+		.ei_array      = get_qmi_response_type_v01_ei(),
+	},
+	{
+		.data_type      = QMI_DATA_LEN,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint8_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x03,
+		.offset         = offsetof(struct wlfw_msa_info_resp_msg_v01,
+					   mem_region_info_len),
+	},
+	{
+		.data_type      = QMI_STRUCT,
+		.elem_len       = QMI_WLFW_MAX_NUM_MEMORY_REGIONS_V01,
+		.elem_size      = sizeof(struct wlfw_memory_region_info_s_v01),
+		.is_array       = VAR_LEN_ARRAY,
+		.tlv_type       = 0x03,
+		.offset         = offsetof(struct wlfw_msa_info_resp_msg_v01,
+					   mem_region_info),
+		.ei_array      = wlfw_memory_region_info_s_v01_ei,
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+struct elem_info wlfw_msa_ready_req_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+struct elem_info wlfw_msa_ready_resp_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_STRUCT,
+		.elem_len       = 1,
+		.elem_size      = sizeof(struct qmi_response_type_v01),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x02,
+		.offset         = offsetof(struct wlfw_msa_ready_resp_msg_v01,
+					   resp),
+		.ei_array      = get_qmi_response_type_v01_ei(),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+struct elem_info wlfw_ini_req_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_OPT_FLAG,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint8_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         = offsetof(struct wlfw_ini_req_msg_v01,
+					   enablefwlog_valid),
+	},
+	{
+		.data_type      = QMI_UNSIGNED_1_BYTE,
+		.elem_len       = 1,
+		.elem_size      = sizeof(uint8_t),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x10,
+		.offset         = offsetof(struct wlfw_ini_req_msg_v01,
+					   enablefwlog),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};
+
+struct elem_info wlfw_ini_resp_msg_v01_ei[] = {
+	{
+		.data_type      = QMI_STRUCT,
+		.elem_len       = 1,
+		.elem_size      = sizeof(struct qmi_response_type_v01),
+		.is_array       = NO_ARRAY,
+		.tlv_type       = 0x02,
+		.offset         = offsetof(struct wlfw_ini_resp_msg_v01,
+					   resp),
+		.ei_array      = get_qmi_response_type_v01_ei(),
+	},
+	{
+		.data_type      = QMI_EOTI,
+		.is_array       = NO_ARRAY,
+		.is_array       = QMI_COMMON_TLV_TYPE,
+	},
+};

drivers/soc/qcom/wlan_firmware_service_v01.h

@@ -1,4 +1,4 @@
- /* Copyright (c) 2015, The Linux Foundation. All rights reserved.
+ /* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
@@ -16,29 +16,39 @@
 #define WLFW_SERVICE_ID_V01 0x45
 #define WLFW_SERVICE_VERS_V01 0x01
 
-#define QMI_WLFW_CAL_REPORT_REQ_V01 0x0026
-#define QMI_WLFW_CAL_REPORT_RESP_V01 0x0026
-#define QMI_WLFW_CAP_RESP_V01 0x0024
 #define QMI_WLFW_BDF_DOWNLOAD_REQ_V01 0x0025
-#define QMI_WLFW_CAL_DOWNLOAD_RESP_V01 0x0027
-#define QMI_WLFW_WLAN_MODE_RESP_V01 0x0022
-#define QMI_WLFW_CAL_UPDATE_RESP_V01 0x0029
-#define QMI_WLFW_BDF_DOWNLOAD_RESP_V01 0x0025
 #define QMI_WLFW_INITIATE_CAL_UPDATE_IND_V01 0x002A
-#define QMI_WLFW_FW_READY_IND_V01 0x0021
-#define QMI_WLFW_INITIATE_CAL_DOWNLOAD_IND_V01 0x0028
 #define QMI_WLFW_CAP_REQ_V01 0x0024
-#define QMI_WLFW_CAL_DOWNLOAD_REQ_V01 0x0027
+#define QMI_WLFW_CAL_REPORT_REQ_V01 0x0026
+#define QMI_WLFW_CAL_UPDATE_RESP_V01 0x0029
+#define QMI_WLFW_CAL_DOWNLOAD_RESP_V01 0x0027
+#define QMI_WLFW_INI_RESP_V01 0x002F
+#define QMI_WLFW_CAL_REPORT_RESP_V01 0x0026
+#define QMI_WLFW_INITIATE_CAL_DOWNLOAD_IND_V01 0x0028
+#define QMI_WLFW_MSA_READY_IND_V01 0x002B
 #define QMI_WLFW_WLAN_MODE_REQ_V01 0x0022
-#define QMI_WLFW_CAL_UPDATE_REQ_V01 0x0029
 #define QMI_WLFW_IND_REGISTER_REQ_V01 0x0020
 #define QMI_WLFW_WLAN_CFG_RESP_V01 0x0023
+#define QMI_WLFW_WLAN_MODE_RESP_V01 0x0022
+#define QMI_WLFW_PIN_CONNECT_RESULT_IND_V01 0x002C
+#define QMI_WLFW_FW_READY_IND_V01 0x0021
+#define QMI_WLFW_MSA_READY_RESP_V01 0x002E
+#define QMI_WLFW_CAL_UPDATE_REQ_V01 0x0029
+#define QMI_WLFW_INI_REQ_V01 0x002F
+#define QMI_WLFW_BDF_DOWNLOAD_RESP_V01 0x0025
+#define QMI_WLFW_MSA_INFO_RESP_V01 0x002D
+#define QMI_WLFW_MSA_READY_REQ_V01 0x002E
+#define QMI_WLFW_CAP_RESP_V01 0x0024
+#define QMI_WLFW_MSA_INFO_REQ_V01 0x002D
+#define QMI_WLFW_CAL_DOWNLOAD_REQ_V01 0x0027
 #define QMI_WLFW_WLAN_CFG_REQ_V01 0x0023
 #define QMI_WLFW_IND_REGISTER_RESP_V01 0x0020
 
+#define QMI_WLFW_MAX_NUM_MEMORY_REGIONS_V01 2
 #define QMI_WLFW_MAX_NUM_CAL_V01 5
 #define QMI_WLFW_MAX_DATA_SIZE_V01 6144
 #define QMI_WLFW_MAX_NUM_CE_V01 12
+#define QMI_WLFW_MAX_TIMESTAMP_LEN_V01 32
 #define QMI_WLFW_MAX_STR_LEN_V01 16
 #define QMI_WLFW_MAX_NUM_SHADOW_REG_V01 24
 #define QMI_WLFW_MAX_NUM_SVC_V01 24
@@ -98,6 +108,30 @@ struct wlfw_shadow_reg_cfg_s_v01 {
 	uint16_t offset;
 };
 
+struct wlfw_memory_region_info_s_v01 {
+	uint64_t region_addr;
+	uint32_t size;
+	uint8_t secure_flag;
+};
+
+struct wlfw_rf_chip_info_s_v01 {
+	uint32_t chip_id;
+	uint32_t chip_family;
+};
+
+struct wlfw_rf_board_info_s_v01 {
+	uint32_t board_id;
+};
+
+struct wlfw_soc_info_s_v01 {
+	uint32_t soc_id;
+};
+
+struct wlfw_fw_version_info_s_v01 {
+	uint32_t fw_version;
+	char fw_build_timestamp[QMI_WLFW_MAX_TIMESTAMP_LEN_V01 + 1];
+};
+
 struct wlfw_ind_register_req_msg_v01 {
 	uint8_t fw_ready_enable_valid;
 	uint8_t fw_ready_enable;
@@ -105,8 +139,12 @@ struct wlfw_ind_register_req_msg_v01 {
 	uint8_t initiate_cal_download_enable;
 	uint8_t initiate_cal_update_enable_valid;
 	uint8_t initiate_cal_update_enable;
+	uint8_t msa_ready_enable_valid;
+	uint8_t msa_ready_enable;
+	uint8_t pin_connect_result_enable_valid;
+	uint8_t pin_connect_result_enable;
 };
-#define WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN 12
+#define WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN 20
 extern struct elem_info wlfw_ind_register_req_msg_v01_ei[];
 
 struct wlfw_ind_register_resp_msg_v01 {
@@ -121,6 +159,23 @@ struct wlfw_fw_ready_ind_msg_v01 {
 #define WLFW_FW_READY_IND_MSG_V01_MAX_MSG_LEN 0
 extern struct elem_info wlfw_fw_ready_ind_msg_v01_ei[];
 
+struct wlfw_msa_ready_ind_msg_v01 {
+	char placeholder;
+};
+#define WLFW_MSA_READY_IND_MSG_V01_MAX_MSG_LEN 0
+extern struct elem_info wlfw_msa_ready_ind_msg_v01_ei[];
+
+struct wlfw_pin_connect_result_ind_msg_v01 {
+	uint8_t pwr_pin_result_valid;
+	uint32_t pwr_pin_result;
+	uint8_t phy_io_pin_result_valid;
+	uint32_t phy_io_pin_result;
+	uint8_t rf_pin_result_valid;
+	uint32_t rf_pin_result;
+};
+#define WLFW_PIN_CONNECT_RESULT_IND_MSG_V01_MAX_MSG_LEN 21
+extern struct elem_info wlfw_pin_connect_result_ind_msg_v01_ei[];
+
 struct wlfw_wlan_mode_req_msg_v01 {
 	enum wlfw_driver_mode_enum_v01 mode;
 };
@@ -163,16 +218,16 @@ extern struct elem_info wlfw_cap_req_msg_v01_ei[];
 
 struct wlfw_cap_resp_msg_v01 {
 	struct qmi_response_type_v01 resp;
-	uint8_t board_id_valid;
+	uint8_t chip_info_valid;
-	uint32_t board_id;
+	struct wlfw_rf_chip_info_s_v01 chip_info;
-	uint8_t num_peers_valid;
+	uint8_t board_info_valid;
-	uint32_t num_peers;
+	struct wlfw_rf_board_info_s_v01 board_info;
-	uint8_t mac_version_valid;
+	uint8_t soc_info_valid;
-	uint32_t mac_version;
+	struct wlfw_soc_info_s_v01 soc_info;
-	uint8_t fw_version_valid;
+	uint8_t fw_version_info_valid;
-	char fw_version[QMI_WLFW_MAX_STR_LEN_V01 + 1];
+	struct wlfw_fw_version_info_s_v01 fw_version_info;
 };
-#define WLFW_CAP_RESP_MSG_V01_MAX_MSG_LEN 47
+#define WLFW_CAP_RESP_MSG_V01_MAX_MSG_LEN 72
 extern struct elem_info wlfw_cap_resp_msg_v01_ei[];
 
 struct wlfw_bdf_download_req_msg_v01 {
@@ -271,4 +326,45 @@ struct wlfw_cal_update_resp_msg_v01 {
 #define WLFW_CAL_UPDATE_RESP_MSG_V01_MAX_MSG_LEN 6181
 extern struct elem_info wlfw_cal_update_resp_msg_v01_ei[];
 
+struct wlfw_msa_info_req_msg_v01 {
+	uint64_t msa_addr;
+	uint32_t size;
+};
+#define WLFW_MSA_INFO_REQ_MSG_V01_MAX_MSG_LEN 18
+extern struct elem_info wlfw_msa_info_req_msg_v01_ei[];
+
+struct wlfw_msa_info_resp_msg_v01 {
+	struct qmi_response_type_v01 resp;
+	uint32_t mem_region_info_len;
+	struct wlfw_memory_region_info_s_v01
+	mem_region_info[QMI_WLFW_MAX_NUM_MEMORY_REGIONS_V01];
+};
+#define WLFW_MSA_INFO_RESP_MSG_V01_MAX_MSG_LEN 37
+extern struct elem_info wlfw_msa_info_resp_msg_v01_ei[];
+
+struct wlfw_msa_ready_req_msg_v01 {
+	char placeholder;
+};
+#define WLFW_MSA_READY_REQ_MSG_V01_MAX_MSG_LEN 0
+extern struct elem_info wlfw_msa_ready_req_msg_v01_ei[];
+
+struct wlfw_msa_ready_resp_msg_v01 {
+	struct qmi_response_type_v01 resp;
+};
+#define WLFW_MSA_READY_RESP_MSG_V01_MAX_MSG_LEN 7
+extern struct elem_info wlfw_msa_ready_resp_msg_v01_ei[];
+
+struct wlfw_ini_req_msg_v01 {
+	uint8_t enablefwlog_valid;
+	uint8_t enablefwlog;
+};
+#define WLFW_INI_REQ_MSG_V01_MAX_MSG_LEN 4
+extern struct elem_info wlfw_ini_req_msg_v01_ei[];
+
+struct wlfw_ini_resp_msg_v01 {
+	struct qmi_response_type_v01 resp;
+};
+#define WLFW_INI_RESP_MSG_V01_MAX_MSG_LEN 7
+extern struct elem_info wlfw_ini_resp_msg_v01_ei[];
+
 #endif

include/soc/qcom/icnss.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
@@ -58,6 +58,13 @@ struct icnss_wlan_enable_cfg {
 	struct icnss_shadow_reg_cfg *shadow_reg_cfg;
 };
 
+/* MSA Memory Regions Information */
+struct icnss_mem_region_info {
+	uint64_t reg_addr;
+	uint32_t size;
+	uint8_t secure_flag;
+};
+
 /* driver modes */
 enum icnss_driver_mode {
 	ICNSS_MISSION,
@@ -91,5 +98,6 @@ extern int icnss_ce_request_irq(unsigned int ce_id,
 	irqreturn_t (*handler)(int, void *),
 	unsigned long flags, const char *name, void *ctx);
 extern int icnss_get_ce_id(int irq);
+extern int icnss_set_fw_debug_mode(bool enablefwlog);
 
 #endif /* _ICNSS_WLAN_H_ */