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

Commit 6b595b00 authored by Linux Build Service Account's avatar Linux Build Service Account Committed by Gerrit - the friendly Code Review server
Browse files

Merge "msm: secure_buffer: Add WLAN support"

parents 2924164f 5dff00e1

Documentation/devicetree/bindings/cnss/icnss.txt

+2 −0
Original line number Diff line number Diff line
@@ -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

+330 −28
Original line number Diff line number Diff line 
/* 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
@@ -19,6 +19,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>
@@ -84,11 +85,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;

	u32 num_peers;

	u32 mac_version;

	char fw_version[QMI_WLFW_MAX_STR_LEN_V01 + 1];

	struct wlfw_rf_chip_info_s_v01 chip_info;

	struct wlfw_rf_board_info_s_v01 board_info;

	struct wlfw_soc_info_s_v01 soc_info;

	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)
@@ -115,6 +124,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;
@@ -132,6 +302,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;
@@ -197,19 +371,25 @@ static int wlfw_cap_send_sync_msg(void) 
	}



	/* store cap locally */

	if (resp.board_id_valid)

		penv->board_id = resp.board_id;

	if (resp.num_peers_valid)

		penv->num_peers = resp.num_peers;

	if (resp.mac_version_valid)

		penv->mac_version = resp.mac_version;

	if (resp.fw_version_valid)

		strlcpy(penv->fw_version, resp.fw_version,

			QMI_WLFW_MAX_STR_LEN_V01 + 1);



	pr_debug("%s: board_id:0x%0x num_peers: %d mac_version: 0x%0x fw_version: %s",

		__func__, penv->board_id, penv->num_peers,

		penv->mac_version, penv->fw_version);

	if (resp.chip_info_valid)

		penv->chip_info = resp.chip_info;

	if (resp.board_info_valid)

		penv->board_info = resp.board_info;

	else

		penv->board_info.board_id = 0xFF;

	if (resp.soc_info_valid)

		penv->soc_info = resp.soc_info;

	if (resp.fw_version_info_valid)

		penv->fw_version_info = resp.fw_version_info;



	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->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;

}
@@ -300,6 +480,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;
@@ -344,6 +567,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;
@@ -376,8 +608,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",

		       ret);

		pr_err("%s: Failed to register indication callback: %d\n",

		       __func__, ret);

		goto fail;

	}
@@ -385,17 +617,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",

		       ret);

		pr_err("%s: Failed to send indication message: %d\n",

		       __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",

		       ret);

		pr_err("%s: Failed to get capability: %d\n",

		       __func__, ret);

		goto out;

	}

	return ret;
@@ -403,6 +666,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;

}
@@ -415,6 +682,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;
@@ -435,6 +706,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;
@@ -457,7 +731,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:
@@ -468,7 +742,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;
@@ -498,7 +772,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);
@@ -535,8 +810,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;
@@ -743,6 +1022,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)
@@ -837,6 +1128,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;
@@ -872,6 +1165,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/secure_buffer.c

+4 −0
Original line number Diff line number Diff line
@@ -374,6 +374,10 @@ const char *msm_secure_vmid_to_string(int secure_vmid) 
		return "VMID_CP_SEC_DISPLAY";

	case VMID_CP_APP:

		return "VMID_CP_APP";

	case VMID_WLAN:

		return "VMID_WLAN";

	case VMID_WLAN_CE:

		return "VMID_WLAN_CE";

	case VMID_INVAL:

		return "VMID_INVAL";

	default:

drivers/soc/qcom/wlan_firmware_service_v01.c

+387 −18

File changed.

Preview size limit exceeded, changes collapsed.

drivers/soc/qcom/wlan_firmware_service_v01.h

+119 −23
Original line number Diff line number Diff line 
 /* 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;

	uint32_t board_id;

	uint8_t num_peers_valid;

	uint32_t num_peers;

	uint8_t mac_version_valid;

	uint32_t mac_version;

	uint8_t fw_version_valid;

	char fw_version[QMI_WLFW_MAX_STR_LEN_V01 + 1];

};

#define WLFW_CAP_RESP_MSG_V01_MAX_MSG_LEN 47

	uint8_t chip_info_valid;

	struct wlfw_rf_chip_info_s_v01 chip_info;

	uint8_t board_info_valid;

	struct wlfw_rf_board_info_s_v01 board_info;

	uint8_t soc_info_valid;

	struct wlfw_soc_info_s_v01 soc_info;

	uint8_t fw_version_info_valid;

	struct wlfw_fw_version_info_s_v01 fw_version_info;

};

#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