A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-08 12:58:12 -04:00
Code Issues Projects Releases Packages Wiki Activity

icnss: Add code to downdload qdss trace config

Browse source 
Add code to download qdss trace config to FW and qdss trace
data from FW when source=0, i.e etb_soc or etb_wcss.

Change-Id: I18bbd74d1f4460d0232c7b3d099eb8525b406e2e
Signed-off-by: Aasir Rasheed <arasheed@codeaurora.org>
This commit is contained in:
Aasir Rasheed 2020-10-05 16:58:49 +05:30 • committed by Naman Padhiar
commit 6401bedb03
4 changed files with 280 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

27
drivers/soc/qcom/icnss2/main.c
View file

@ -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";
}
@ -833,6 +835,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);
@ -1008,6 +1013,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;
@ -1432,6 +1456,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);

1
drivers/soc/qcom/icnss2/main.h
View file

@ -57,6 +57,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,
};

250
drivers/soc/qcom/icnss2/qmi.c
View file

@ -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
@ -42,6 +43,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
@ -891,6 +894,236 @@ err_req_fw:
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) {
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)
{
@ -1951,9 +2184,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;
@ -1981,12 +2211,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;

8
drivers/soc/qcom/icnss2/qmi.h
View file

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