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

Commit 735a26c2 authored by qctecmdr's avatar qctecmdr Committed by Gerrit - the friendly Code Review server
Browse files

Merge "icnss: Add code to downdload qdss trace config"

parents 7ff28e58 df520af2

drivers/soc/qcom/icnss2/main.c

+27 −0
Original line number Diff line number Diff line
@@ -183,6 +183,8 @@ char *icnss_driver_event_to_str(enum icnss_driver_event_type type) 
		return "QDSS_TRACE_FREE";

	case ICNSS_DRIVER_EVENT_M3_DUMP_UPLOAD_REQ:

		return "M3_DUMP_UPLOAD";

	case ICNSS_DRIVER_EVENT_QDSS_TRACE_REQ_DATA:

		return "QDSS_TRACE_REQ_DATA";

	case ICNSS_DRIVER_EVENT_MAX:

		return "EVENT_MAX";

	}
@@ -832,6 +834,9 @@ static int icnss_driver_event_fw_init_done(struct icnss_priv *priv, void *data) 


	icnss_pr_info("WLAN FW Initialization done: 0x%lx\n", priv->state);



	if (icnss_wlfw_qdss_dnld_send_sync(priv))

		icnss_pr_info("Failed to download qdss configuration file");



	if (test_bit(ICNSS_COLD_BOOT_CAL, &priv->state))

		ret = wlfw_wlan_mode_send_sync_msg(priv,

			(enum wlfw_driver_mode_enum_v01)ICNSS_CALIBRATION);
@@ -1007,6 +1012,25 @@ static inline int icnss_atomic_dec_if_greater_one(atomic_t *v) 
	return dec;

}



static int icnss_qdss_trace_req_data_hdlr(struct icnss_priv *priv,

				      void *data)

{

	int ret = 0;

	struct icnss_qmi_event_qdss_trace_save_data *event_data = data;



	if (!priv)

		return -ENODEV;



	if (!data)

		return -EINVAL;



	ret = icnss_wlfw_qdss_data_send_sync(priv, event_data->file_name,

					     event_data->total_size);



	kfree(data);

	return ret;

}



static int icnss_event_soc_wake_request(struct icnss_priv *priv, void *data)

{

	int ret = 0;
@@ -1431,6 +1455,9 @@ static void icnss_driver_event_work(struct work_struct *work) 
			break;

		case ICNSS_DRIVER_EVENT_M3_DUMP_UPLOAD_REQ:

			ret = icnss_m3_dump_upload_req_hdlr(priv, event->data);

		case ICNSS_DRIVER_EVENT_QDSS_TRACE_REQ_DATA:

			ret = icnss_qdss_trace_req_data_hdlr(priv,

							     event->data);

			break;

		default:

			icnss_pr_err("Invalid Event type: %d", event->type);

drivers/soc/qcom/icnss2/main.h

+1 −0
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ enum icnss_driver_event_type { 
	ICNSS_DRIVER_EVENT_QDSS_TRACE_SAVE,

	ICNSS_DRIVER_EVENT_QDSS_TRACE_FREE,

	ICNSS_DRIVER_EVENT_M3_DUMP_UPLOAD_REQ,

	ICNSS_DRIVER_EVENT_QDSS_TRACE_REQ_DATA,

	ICNSS_DRIVER_EVENT_MAX,

};

drivers/soc/qcom/icnss2/qmi.c

+246 −6
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 
#include "main.h"

#include "qmi.h"

#include "debug.h"

#include "genl.h"



#define WLFW_SERVICE_WCN_INS_ID_V01	3

#define WLFW_SERVICE_INS_ID_V01		0
@@ -43,6 +44,8 @@ 
#define REGDB_FILE_NAME			"regdb.bin"

#define DUMMY_BDF_FILE_NAME		"bdwlan.dmy"



#define QDSS_TRACE_CONFIG_FILE "qdss_trace_config.cfg"



#define DEVICE_BAR_SIZE			0x200000

#define M3_SEGMENT_ADDR_MASK		0xFFFFFFFF
@@ -883,6 +886,238 @@ int icnss_wlfw_bdf_dnld_send_sync(struct icnss_priv *priv, u32 bdf_type) 
	return ret;

}



int icnss_wlfw_qdss_data_send_sync(struct icnss_priv *priv, char *file_name,

				   u32 total_size)

{

	int ret = 0;

	struct wlfw_qdss_trace_data_req_msg_v01 *req;

	struct wlfw_qdss_trace_data_resp_msg_v01 *resp;

	unsigned char *p_qdss_trace_data_temp, *p_qdss_trace_data = NULL;

	unsigned int remaining;

	struct qmi_txn txn;



	icnss_pr_dbg("%s", __func__);



	req = kzalloc(sizeof(*req), GFP_KERNEL);

	if (!req)

		return -ENOMEM;



	resp = kzalloc(sizeof(*resp), GFP_KERNEL);

	if (!resp) {

		kfree(req);

		return -ENOMEM;

	}



	p_qdss_trace_data = kzalloc(total_size, GFP_KERNEL);

	if (p_qdss_trace_data == NULL) {

		ret = ENOMEM;

		goto end;

	}



	remaining = total_size;

	p_qdss_trace_data_temp = p_qdss_trace_data;

	while (remaining && resp->end == 0) {



		ret = qmi_txn_init(&priv->qmi, &txn,

				   wlfw_qdss_trace_data_resp_msg_v01_ei, resp);



		if (ret < 0) {

			icnss_pr_err("Fail to init txn for QDSS trace resp %d\n",

				     ret);

			goto fail;

		}



		ret = qmi_send_request

			(&priv->qmi, NULL, &txn,

			 QMI_WLFW_QDSS_TRACE_DATA_REQ_V01,

			 WLFW_QDSS_TRACE_DATA_REQ_MSG_V01_MAX_MSG_LEN,

			 wlfw_qdss_trace_data_req_msg_v01_ei, req);



		if (ret < 0) {

			qmi_txn_cancel(&txn);

			icnss_pr_err("Fail to send QDSS trace data req %d\n",

				     ret);

			goto fail;

		}



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



		if (ret < 0) {

			icnss_pr_err("QDSS trace resp wait failed with rc %d\n",

				     ret);

			goto fail;

		} else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {

			icnss_pr_err("QMI QDSS trace request rejected, result:%d error:%d\n",

				     resp->resp.result, resp->resp.error);

				     ret = -resp->resp.result;

			goto fail;

		} else {

			ret = 0;

		}



		icnss_pr_dbg("%s: response total size  %d data len %d",

			     __func__, resp->total_size, resp->data_len);



		if ((resp->total_size_valid == 1 &&

		    resp->total_size == total_size)

		   && (resp->seg_id_valid == 1 && resp->seg_id == req->seg_id)

		   && (resp->data_valid == 1 &&

		resp->data_len <= QMI_WLFW_MAX_DATA_SIZE_V01)) {



			memcpy(p_qdss_trace_data_temp,

			       resp->data, resp->data_len);

		} else {

			icnss_pr_err("%s: Unmatched qdss trace data, Expect total_size %u, seg_id %u, Recv total_size_valid %u, total_size %u, seg_id_valid %u, seg_id %u, data_len_valid %u, data_len %u",

				     __func__,

				     total_size, req->seg_id,

				     resp->total_size_valid,

				     resp->total_size,

				     resp->seg_id_valid,

				     resp->seg_id,

				     resp->data_valid,

				     resp->data_len);

			ret = -EINVAL;

			goto fail;

		}



		remaining -= resp->data_len;

		p_qdss_trace_data_temp += resp->data_len;

		req->seg_id++;

	}



	if (remaining == 0 && (resp->end_valid && resp->end)) {

		ret = icnss_genl_send_msg(p_qdss_trace_data,

					 ICNSS_GENL_MSG_TYPE_QDSS, file_name,

					 total_size);

		if (ret < 0) {

			icnss_pr_err("Fail to save QDSS trace data: %d\n",

				     ret);

		ret = -EINVAL;

		}

	} else {

		icnss_pr_err("%s: QDSS trace file corrupted: remaining %u, end_valid %u, end %u",

			     __func__,

			     remaining, resp->end_valid, resp->end);

		ret = -EINVAL;

	}



fail:

	kfree(p_qdss_trace_data);



end:

	kfree(req);

	kfree(resp);

	return ret;

}



int icnss_wlfw_qdss_dnld_send_sync(struct icnss_priv *priv)

{

	struct wlfw_qdss_trace_config_download_req_msg_v01 *req;

	struct wlfw_qdss_trace_config_download_resp_msg_v01 *resp;

	struct qmi_txn txn;

	const struct firmware *fw_entry = NULL;

	const u8 *temp;

	unsigned int remaining;

	int ret = 0;



	icnss_pr_dbg("Sending QDSS config download message, state: 0x%lx\n",

		     priv->state);



	req = kzalloc(sizeof(*req), GFP_KERNEL);

	if (!req)

		return -ENOMEM;



	resp = kzalloc(sizeof(*resp), GFP_KERNEL);

	if (!resp) {

		kfree(req);

		return -ENOMEM;

	}



	ret = request_firmware(&fw_entry, QDSS_TRACE_CONFIG_FILE,

			       &priv->pdev->dev);

	if (ret) {

		icnss_pr_err("Failed to load QDSS: %s\n",

			     QDSS_TRACE_CONFIG_FILE);

		goto err_req_fw;

	}



	temp = fw_entry->data;

	remaining = fw_entry->size;



	icnss_pr_dbg("Downloading QDSS: %s, size: %u\n",

		     QDSS_TRACE_CONFIG_FILE, remaining);



	while (remaining) {

		req->total_size_valid = 1;

		req->total_size = remaining;

		req->seg_id_valid = 1;

		req->data_valid = 1;

		req->end_valid = 1;



		if (remaining > QMI_WLFW_MAX_DATA_SIZE_V01) {

			req->data_len = QMI_WLFW_MAX_DATA_SIZE_V01;

		} else {

			req->data_len = remaining;

			req->end = 1;

		}



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



		ret = qmi_txn_init

			(&priv->qmi, &txn,

			 wlfw_qdss_trace_config_download_resp_msg_v01_ei,

			 resp);

		if (ret < 0) {

			icnss_pr_err("Failed to initialize txn for QDSS download request, err: %d\n",

				      ret);

			goto err_send;

		}



		ret = qmi_send_request

		      (&priv->qmi, NULL, &txn,

		       QMI_WLFW_QDSS_TRACE_CONFIG_DOWNLOAD_REQ_V01,

		       WLFW_QDSS_TRACE_CONFIG_DOWNLOAD_REQ_MSG_V01_MAX_MSG_LEN,

		       wlfw_qdss_trace_config_download_req_msg_v01_ei, req);

		if (ret < 0) {

			qmi_txn_cancel(&txn);

			icnss_pr_err("Failed to send respond QDSS download request, err: %d\n",

				      ret);

			goto err_send;

		}



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

		if (ret < 0) {

			icnss_pr_err("Failed to wait for response of QDSS download request, err: %d\n",

				      ret);

			goto err_send;

		}



		if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {

			icnss_pr_err("QDSS download request failed, result: %d, err: %d\n",

				      resp->resp.result, resp->resp.error);

			ret = -resp->resp.result;

			goto err_send;

		}



		remaining -= req->data_len;

		temp += req->data_len;

		req->seg_id++;

	}



	release_firmware(fw_entry);

	kfree(req);

	kfree(resp);

	return 0;



err_send:

	release_firmware(fw_entry);

err_req_fw:



	kfree(req);

	kfree(resp);

	return ret;

}



int wlfw_wlan_mode_send_sync_msg(struct icnss_priv *priv,

		enum wlfw_driver_mode_enum_v01 mode)

{
@@ -1937,9 +2172,6 @@ static void wlfw_qdss_trace_save_ind_cb(struct qmi_handle *qmi, 
		     ind_msg->source, ind_msg->total_size,

		     ind_msg->file_name_valid, ind_msg->file_name);



	if (ind_msg->source == 1)

		return;



	event_data = kzalloc(sizeof(*event_data), GFP_KERNEL);

	if (!event_data)

		return;
@@ -1967,12 +2199,20 @@ static void wlfw_qdss_trace_save_ind_cb(struct qmi_handle *qmi, 
	if (ind_msg->file_name_valid)

		strlcpy(event_data->file_name, ind_msg->file_name,

			QDSS_TRACE_FILE_NAME_MAX + 1);

	else

		strlcpy(event_data->file_name, "qdss_trace",

			QDSS_TRACE_FILE_NAME_MAX + 1);



	if (ind_msg->source == 1) {

		if (!ind_msg->file_name_valid)

			strlcpy(event_data->file_name, "qdss_trace_wcss_etb",

			QDSS_TRACE_FILE_NAME_MAX + 1);

	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_QDSS_TRACE_REQ_DATA,

				0, event_data);

	} else {

		if (!ind_msg->file_name_valid)

			strlcpy(event_data->file_name, "qdss_trace_ddr",

			QDSS_TRACE_FILE_NAME_MAX + 1);

	icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_QDSS_TRACE_SAVE,

				0, event_data);

	}



	return;

drivers/soc/qcom/icnss2/qmi.h

+8 −0
Original line number Diff line number Diff line
@@ -36,6 +36,11 @@ struct icnss_m3_upload_segments_req_data { 
	struct icnss_m3_segment m3_segment[M3_SEGMENTS_SIZE_MAX];

};



struct icnss_qmi_event_qdss_trace_req_data {

	u32 total_size;

	char file_name[QDSS_TRACE_FILE_NAME_MAX + 1];

};



#ifndef CONFIG_ICNSS2_QMI



static inline int wlfw_ind_register_send_sync_msg(struct icnss_priv *priv)
@@ -201,6 +206,9 @@ int wlfw_device_info_send_msg(struct icnss_priv *priv); 
int wlfw_wlan_mode_send_sync_msg(struct icnss_priv *priv,

				 enum wlfw_driver_mode_enum_v01 mode);

int icnss_wlfw_bdf_dnld_send_sync(struct icnss_priv *priv, u32 bdf_type);

int icnss_wlfw_qdss_dnld_send_sync(struct icnss_priv *priv);

int icnss_wlfw_qdss_data_send_sync(struct icnss_priv *priv, char *file_name,

				   u32 total_size);

int wlfw_qdss_trace_mem_info_send_sync(struct icnss_priv *priv);

int wlfw_power_save_send_msg(struct icnss_priv *priv,

			     enum wlfw_power_save_mode_v01 mode);