icnss: Add code to downdload qdss trace config (df520af2) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/soc/qcom/icnss2/main.c

+27 −0

Original line number	Original line	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";		return "QDSS_TRACE_FREE";
	case ICNSS_DRIVER_EVENT_M3_DUMP_UPLOAD_REQ:		case ICNSS_DRIVER_EVENT_M3_DUMP_UPLOAD_REQ:
	return "M3_DUMP_UPLOAD";		return "M3_DUMP_UPLOAD";
			case ICNSS_DRIVER_EVENT_QDSS_TRACE_REQ_DATA:
			return "QDSS_TRACE_REQ_DATA";
	case ICNSS_DRIVER_EVENT_MAX:		case ICNSS_DRIVER_EVENT_MAX:
	return "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);		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))		if (test_bit(ICNSS_COLD_BOOT_CAL, &priv->state))
	ret = wlfw_wlan_mode_send_sync_msg(priv,		ret = wlfw_wlan_mode_send_sync_msg(priv,
	(enum wlfw_driver_mode_enum_v01)ICNSS_CALIBRATION);		(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;		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)		static int icnss_event_soc_wake_request(struct icnss_priv priv, void data)
	{		{
	int ret = 0;		int ret = 0;
	@@ -1431,6 +1455,9 @@ static void icnss_driver_event_work(struct work_struct *work)
	break;		break;
	case ICNSS_DRIVER_EVENT_M3_DUMP_UPLOAD_REQ:		case ICNSS_DRIVER_EVENT_M3_DUMP_UPLOAD_REQ:
	ret = icnss_m3_dump_upload_req_hdlr(priv, event->data);		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;		break;
	default:		default:
	icnss_pr_err("Invalid Event type: %d", event->type);		icnss_pr_err("Invalid Event type: %d", event->type);

drivers/soc/qcom/icnss2/main.h

+1 −0

Original line number	Original line	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_SAVE,
	ICNSS_DRIVER_EVENT_QDSS_TRACE_FREE,		ICNSS_DRIVER_EVENT_QDSS_TRACE_FREE,
	ICNSS_DRIVER_EVENT_M3_DUMP_UPLOAD_REQ,		ICNSS_DRIVER_EVENT_M3_DUMP_UPLOAD_REQ,
			ICNSS_DRIVER_EVENT_QDSS_TRACE_REQ_DATA,
	ICNSS_DRIVER_EVENT_MAX,		ICNSS_DRIVER_EVENT_MAX,
	};		};

drivers/soc/qcom/icnss2/qmi.c

+246 −6

Original line number	Original line	Diff line number	Diff line
	@@ -28,6 +28,7 @@
	#include "main.h"		#include "main.h"
	#include "qmi.h"		#include "qmi.h"
	#include "debug.h"		#include "debug.h"
			#include "genl.h"

	#define WLFW_SERVICE_WCN_INS_ID_V01 3		#define WLFW_SERVICE_WCN_INS_ID_V01 3
	#define WLFW_SERVICE_INS_ID_V01 0		#define WLFW_SERVICE_INS_ID_V01 0
	@@ -43,6 +44,8 @@
	#define REGDB_FILE_NAME "regdb.bin"		#define REGDB_FILE_NAME "regdb.bin"
	#define DUMMY_BDF_FILE_NAME "bdwlan.dmy"		#define DUMMY_BDF_FILE_NAME "bdwlan.dmy"

			#define QDSS_TRACE_CONFIG_FILE "qdss_trace_config.cfg"

	#define DEVICE_BAR_SIZE 0x200000		#define DEVICE_BAR_SIZE 0x200000
	#define M3_SEGMENT_ADDR_MASK 0xFFFFFFFF		#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;		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,		int wlfw_wlan_mode_send_sync_msg(struct icnss_priv *priv,
	enum wlfw_driver_mode_enum_v01 mode)		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->source, ind_msg->total_size,
	ind_msg->file_name_valid, ind_msg->file_name);		ind_msg->file_name_valid, ind_msg->file_name);

	if (ind_msg->source == 1)
	return;

	event_data = kzalloc(sizeof(*event_data), GFP_KERNEL);		event_data = kzalloc(sizeof(*event_data), GFP_KERNEL);
	if (!event_data)		if (!event_data)
	return;		return;
	@@ -1967,12 +2199,20 @@ static void wlfw_qdss_trace_save_ind_cb(struct qmi_handle *qmi,
	if (ind_msg->file_name_valid)		if (ind_msg->file_name_valid)
	strlcpy(event_data->file_name, ind_msg->file_name,		strlcpy(event_data->file_name, ind_msg->file_name,
	QDSS_TRACE_FILE_NAME_MAX + 1);		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,		icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_QDSS_TRACE_SAVE,
	0, event_data);		0, event_data);
			}

	return;		return;

drivers/soc/qcom/icnss2/qmi.h

+8 −0

Original line number	Original line	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_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		#ifndef CONFIG_ICNSS2_QMI

	static inline int wlfw_ind_register_send_sync_msg(struct icnss_priv *priv)		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,		int wlfw_wlan_mode_send_sync_msg(struct icnss_priv *priv,
	enum wlfw_driver_mode_enum_v01 mode);		enum wlfw_driver_mode_enum_v01 mode);
	int icnss_wlfw_bdf_dnld_send_sync(struct icnss_priv *priv, u32 bdf_type);		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_qdss_trace_mem_info_send_sync(struct icnss_priv *priv);
	int wlfw_power_save_send_msg(struct icnss_priv *priv,		int wlfw_power_save_send_msg(struct icnss_priv *priv,
	enum wlfw_power_save_mode_v01 mode);		enum wlfw_power_save_mode_v01 mode);