static int test_qmi_ping_pong_send_sync_msg(void)
{
struct test_ping_req_msg_v01 req;
struct test_ping_resp_msg_v01 resp;
struct msg_desc req_desc, resp_desc;
int rc;
memcpy(req.ping, "ping", sizeof(req.ping));
req.client_name_valid = 0;
req_desc.max_msg_len = TEST_PING_REQ_MAX_MSG_LEN_V01;
req_desc.msg_id = TEST_PING_REQ_MSG_ID_V01;
req_desc.ei_array = test_ping_req_msg_v01_ei;
resp_desc.max_msg_len = TEST_PING_REQ_MAX_MSG_LEN_V01;
resp_desc.msg_id = TEST_PING_REQ_MSG_ID_V01;
resp_desc.ei_array = test_ping_resp_msg_v01_ei;
rc = qmi_send_req_wait(test_clnt, &req_desc, &req, sizeof(req),
&resp_desc, &resp, sizeof(resp), 0);
if (rc < 0) {
pr_err("%s: send req failed %d\n", __func__, rc);
return rc;
}
D("%s: Received %s response\n", __func__, resp.pong);
return rc;
}
/* sending filter-install-request to modem*/
int qmi_filter_request_send(struct ipa_install_fltr_rule_req_msg_v01 *req)
{
struct ipa_install_fltr_rule_resp_msg_v01 resp;
struct msg_desc req_desc, resp_desc;
int rc;
/* check if the filter rules from IPACM is valid */
if (req->filter_spec_list_len == 0) {
IPAWANDBG("IPACM pass zero rules to Q6\n");
} else {
IPAWANDBG("IPACM pass %d rules to Q6\n",
req->filter_spec_list_len);
}
req_desc.max_msg_len = QMI_IPA_INSTALL_FILTER_RULE_REQ_MAX_MSG_LEN_V01;
req_desc.msg_id = QMI_IPA_INSTALL_FILTER_RULE_REQ_V01;
req_desc.ei_array = ipa_install_fltr_rule_req_msg_data_v01_ei;
memset(&resp, 0, sizeof(struct ipa_install_fltr_rule_resp_msg_v01));
resp_desc.max_msg_len =
QMI_IPA_INSTALL_FILTER_RULE_RESP_MAX_MSG_LEN_V01;
resp_desc.msg_id = QMI_IPA_INSTALL_FILTER_RULE_RESP_V01;
resp_desc.ei_array = ipa_install_fltr_rule_resp_msg_data_v01_ei;
rc = qmi_send_req_wait(ipa_q6_clnt, &req_desc,
req,
sizeof(struct ipa_install_fltr_rule_req_msg_v01),
&resp_desc, &resp, sizeof(resp),
QMI_SEND_REQ_TIMEOUT_MS);
return ipa_check_qmi_response(rc,
QMI_IPA_INSTALL_FILTER_RULE_REQ_V01, resp.resp.result,
resp.resp.error, "ipa_install_filter");
}
/* sending filter-installed-notify-request to modem*/
int qmi_filter_notify_send(struct ipa_fltr_installed_notif_req_msg_v01 *req)
{
struct ipa_fltr_installed_notif_resp_msg_v01 resp;
struct msg_desc req_desc, resp_desc;
int rc = 0, i = 0;
/* check if the filter rules from IPACM is valid */
if (req->filter_index_list_len == 0) {
IPAWANERR(" delete UL filter rule for pipe %d\n",
req->source_pipe_index);
return -EINVAL;
} else if (req->filter_index_list[0].filter_index == 0 &&
req->source_pipe_index !=
ipa_get_ep_mapping(IPA_CLIENT_APPS_LAN_WAN_PROD)) {
IPAWANERR(" get index wrong for pipe %d\n",
req->source_pipe_index);
for (i = 0; i < req->filter_index_list_len; i++)
IPAWANERR(" %d-st handle %d index %d\n",
i,
req->filter_index_list[i].filter_handle,
req->filter_index_list[i].filter_index);
return -EINVAL;
}
mutex_lock(&ipa_qmi_lock);
if (ipa_qmi_ctx != NULL) {
/* cache the qmi_filter_request */
memcpy(&(ipa_qmi_ctx->ipa_fltr_installed_notif_req_msg_cache[
ipa_qmi_ctx->num_ipa_fltr_installed_notif_req_msg]),
req,
sizeof(struct ipa_fltr_installed_notif_req_msg_v01));
ipa_qmi_ctx->num_ipa_fltr_installed_notif_req_msg++;
ipa_qmi_ctx->num_ipa_fltr_installed_notif_req_msg %= 10;
}
mutex_unlock(&ipa_qmi_lock);
req_desc.max_msg_len =
QMI_IPA_FILTER_INSTALLED_NOTIF_REQ_MAX_MSG_LEN_V01;
req_desc.msg_id = QMI_IPA_FILTER_INSTALLED_NOTIF_REQ_V01;
req_desc.ei_array = ipa_fltr_installed_notif_req_msg_data_v01_ei;
memset(&resp, 0, sizeof(struct ipa_fltr_installed_notif_resp_msg_v01));
resp_desc.max_msg_len =
QMI_IPA_FILTER_INSTALLED_NOTIF_RESP_MAX_MSG_LEN_V01;
resp_desc.msg_id = QMI_IPA_FILTER_INSTALLED_NOTIF_RESP_V01;
resp_desc.ei_array = ipa_fltr_installed_notif_resp_msg_data_v01_ei;
rc = qmi_send_req_wait(ipa_q6_clnt,
&req_desc,
req,
sizeof(struct ipa_fltr_installed_notif_req_msg_v01),
&resp_desc, &resp, sizeof(resp),
QMI_SEND_REQ_TIMEOUT_MS);
return ipa_check_qmi_response(rc,
QMI_IPA_FILTER_INSTALLED_NOTIF_REQ_V01, resp.resp.result,
resp.resp.error, "ipa_fltr_installed_notif_resp");
}
static void audio_etm_disable(struct coresight_device *csdev)
{
struct audio_etm_drvdata *drvdata =
dev_get_drvdata(csdev->dev.parent);
struct coresight_set_etm_req_msg_v01 req;
struct coresight_set_etm_resp_msg_v01 resp = { { 0, 0 } };
struct msg_desc req_desc, resp_desc;
int ret;
mutex_lock(&drvdata->mutex);
if (!drvdata->handle) {
dev_info(drvdata->dev,
"%s: QMI service unavailable. Skipping QMI requests\n",
__func__);
goto out;
}
req.state = CORESIGHT_ETM_STATE_DISABLED_V01;
req_desc.msg_id = CORESIGHT_QMI_SET_ETM_REQ_V01;
req_desc.max_msg_len = CORESIGHT_QMI_SET_ETM_REQ_MAX_LEN;
req_desc.ei_array = coresight_set_etm_req_msg_v01_ei;
resp_desc.msg_id = CORESIGHT_QMI_SET_ETM_RESP_V01;
resp_desc.max_msg_len = CORESIGHT_QMI_SET_ETM_RESP_MAX_LEN;
resp_desc.ei_array = coresight_set_etm_resp_msg_v01_ei;
ret = qmi_send_req_wait(drvdata->handle, &req_desc, &req, sizeof(req),
&resp_desc, &resp, sizeof(resp), TIMEOUT_MS);
if (ret < 0) {
dev_err(drvdata->dev, "%s: QMI send req failed %d\n", __func__,
ret);
goto err;
}
if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
dev_err(drvdata->dev, "%s: QMI request failed %d %d\n",
__func__, resp.resp.result, resp.resp.error);
goto err;
}
out:
mutex_unlock(&drvdata->mutex);
dev_info(drvdata->dev, "Audio ETM tracing disabled\n");
return;
err:
mutex_unlock(&drvdata->mutex);
}
static int test_qmi_data_send_sync_msg(unsigned int data_len)
{
struct test_data_req_msg_v01 *req;
struct test_data_resp_msg_v01 *resp;
struct msg_desc req_desc, resp_desc;
int rc, i;
req = kzalloc(sizeof(struct test_data_req_msg_v01), GFP_KERNEL);
if (!req) {
pr_err("%s: Data req msg alloc failed\n", __func__);
return -ENOMEM;
}
resp = kzalloc(sizeof(struct test_data_resp_msg_v01), GFP_KERNEL);
if (!resp) {
pr_err("%s: Data resp msg alloc failed\n", __func__);
kfree(req);
return -ENOMEM;
}
req->data_len = data_len;
for (i = 0; i < data_len; i = i + sizeof(int))
memcpy(req->data + i, (uint8_t *)&i, sizeof(int));
req->client_name_valid = 0;
req_desc.max_msg_len = TEST_DATA_REQ_MAX_MSG_LEN_V01;
req_desc.msg_id = TEST_DATA_REQ_MSG_ID_V01;
req_desc.ei_array = test_data_req_msg_v01_ei;
resp_desc.max_msg_len = TEST_DATA_REQ_MAX_MSG_LEN_V01;
resp_desc.msg_id = TEST_DATA_REQ_MSG_ID_V01;
resp_desc.ei_array = test_data_resp_msg_v01_ei;
rc = qmi_send_req_wait(test_clnt, &req_desc, req, sizeof(*req),
&resp_desc, resp, sizeof(*resp), 0);
if (rc < 0) {
pr_err("%s: send req failed\n", __func__);
goto data_send_err;
}
D("%s: data_valid %d\n", __func__, resp->data_valid);
D("%s: data_len %d\n", __func__, resp->data_len);
data_send_err:
kfree(resp);
kfree(req);
return rc;
}
int qmi_disable_force_clear_datapath_send(
struct ipa_disable_force_clear_datapath_req_msg_v01 *req)
{
struct ipa_disable_force_clear_datapath_resp_msg_v01 resp;
struct msg_desc req_desc, resp_desc;
int rc = 0;
if (!req) {
IPAWANERR("invalid params\n");
return -EINVAL;
}
req_desc.max_msg_len =
QMI_IPA_DISABLE_FORCE_CLEAR_DATAPATH_REQ_MAX_MSG_LEN_V01;
req_desc.msg_id = QMI_IPA_DISABLE_FORCE_CLEAR_DATAPATH_REQ_V01;
req_desc.ei_array =
ipa_disable_force_clear_datapath_req_msg_data_v01_ei;
memset(&resp, 0, sizeof(struct ipa_fltr_installed_notif_resp_msg_v01));
resp_desc.max_msg_len =
QMI_IPA_DISABLE_FORCE_CLEAR_DATAPATH_RESP_MAX_MSG_LEN_V01;
resp_desc.msg_id = QMI_IPA_DISABLE_FORCE_CLEAR_DATAPATH_RESP_V01;
resp_desc.ei_array =
ipa_disable_force_clear_datapath_resp_msg_data_v01_ei;
rc = qmi_send_req_wait(ipa_q6_clnt,
&req_desc,
req,
sizeof(*req),
&resp_desc, &resp, sizeof(resp), 0);
if (rc < 0) {
IPAWANERR("send req failed %d\n", rc);
return rc;
}
if (resp.resp.result != IPA_QMI_RESULT_SUCCESS_V01) {
IPAWANERR("filter_notify failed %d\n",
resp.resp.result);
return resp.resp.result;
}
IPAWANDBG("SUCCESS\n");
return rc;
}
static int qmi_init_modem_send_sync_msg(void)
{
struct ipa_init_modem_driver_req_msg_v01 req;
struct ipa_init_modem_driver_resp_msg_v01 resp;
struct msg_desc req_desc, resp_desc;
int rc;
u16 smem_restr_bytes = ipa_get_smem_restr_bytes();
memset(&req, 0, sizeof(struct ipa_init_modem_driver_req_msg_v01));
memset(&resp, 0, sizeof(struct ipa_init_modem_driver_resp_msg_v01));
req.platform_type_valid = true;
req.platform_type = ipa_wan_platform;
req.hdr_tbl_info_valid = true;
req.hdr_tbl_info.modem_offset_start =
IPA_MEM_PART(modem_hdr_ofst) + smem_restr_bytes;
req.hdr_tbl_info.modem_offset_end = IPA_MEM_PART(modem_hdr_ofst) +
smem_restr_bytes + IPA_MEM_PART(modem_hdr_size) - 1;
req.v4_route_tbl_info_valid = true;
req.v4_route_tbl_info.route_tbl_start_addr = IPA_MEM_PART(v4_rt_ofst) +
smem_restr_bytes;
req.v4_route_tbl_info.num_indices = IPA_MEM_PART(v4_modem_rt_index_hi);
req.v6_route_tbl_info_valid = true;
req.v6_route_tbl_info.route_tbl_start_addr = IPA_MEM_PART(v6_rt_ofst) +
smem_restr_bytes;
req.v6_route_tbl_info.num_indices = IPA_MEM_PART(v6_modem_rt_index_hi);
req.v4_filter_tbl_start_addr_valid = true;
req.v4_filter_tbl_start_addr =
IPA_MEM_PART(v4_flt_ofst) + smem_restr_bytes;
req.v6_filter_tbl_start_addr_valid = true;
req.v6_filter_tbl_start_addr =
IPA_MEM_PART(v6_flt_ofst) + smem_restr_bytes;
req.modem_mem_info_valid = true;
req.modem_mem_info.block_start_addr =
IPA_MEM_PART(modem_ofst) + smem_restr_bytes;
req.modem_mem_info.size = IPA_MEM_PART(modem_size);
req.ctrl_comm_dest_end_pt_valid = true;
req.ctrl_comm_dest_end_pt =
ipa_get_ep_mapping(IPA_CLIENT_APPS_WAN_CONS);
req.hdr_proc_ctx_tbl_info_valid = true;
req.hdr_proc_ctx_tbl_info.modem_offset_start =
IPA_MEM_PART(modem_hdr_proc_ctx_ofst) + smem_restr_bytes;
req.hdr_proc_ctx_tbl_info.modem_offset_end =
IPA_MEM_PART(modem_hdr_proc_ctx_ofst) +
IPA_MEM_PART(modem_hdr_proc_ctx_size) + smem_restr_bytes - 1;
if (is_load_uc) { /* First time boot */
req.is_ssr_bootup_valid = false;
req.is_ssr_bootup = 0;
} else { /* After SSR boot */
req.is_ssr_bootup_valid = true;
req.is_ssr_bootup = 1;
}
IPAWANDBG("platform_type %d\n", req.platform_type);
IPAWANDBG("hdr_tbl_info.modem_offset_start %d\n",
req.hdr_tbl_info.modem_offset_start);
IPAWANDBG("hdr_tbl_info.modem_offset_end %d\n",
req.hdr_tbl_info.modem_offset_end);
IPAWANDBG("v4_route_tbl_info.route_tbl_start_addr %d\n",
req.v4_route_tbl_info.route_tbl_start_addr);
IPAWANDBG("v4_route_tbl_info.num_indices %d\n",
req.v4_route_tbl_info.num_indices);
IPAWANDBG("v6_route_tbl_info.route_tbl_start_addr %d\n",
req.v6_route_tbl_info.route_tbl_start_addr);
IPAWANDBG("v6_route_tbl_info.num_indices %d\n",
req.v6_route_tbl_info.num_indices);
IPAWANDBG("v4_filter_tbl_start_addr %d\n",
req.v4_filter_tbl_start_addr);
IPAWANDBG("v6_filter_tbl_start_addr %d\n",
req.v6_filter_tbl_start_addr);
IPAWANDBG("modem_mem_info.block_start_addr %d\n",
req.modem_mem_info.block_start_addr);
IPAWANDBG("modem_mem_info.size %d\n",
req.modem_mem_info.size);
IPAWANDBG("ctrl_comm_dest_end_pt %d\n",
req.ctrl_comm_dest_end_pt);
IPAWANDBG("is_ssr_bootup %d\n",
req.is_ssr_bootup);
req_desc.max_msg_len = QMI_IPA_INIT_MODEM_DRIVER_REQ_MAX_MSG_LEN_V01;
req_desc.msg_id = QMI_IPA_INIT_MODEM_DRIVER_REQ_V01;
req_desc.ei_array = ipa_init_modem_driver_req_msg_data_v01_ei;
resp_desc.max_msg_len = QMI_IPA_INIT_MODEM_DRIVER_RESP_MAX_MSG_LEN_V01;
resp_desc.msg_id = QMI_IPA_INIT_MODEM_DRIVER_RESP_V01;
resp_desc.ei_array = ipa_init_modem_driver_resp_msg_data_v01_ei;
pr_info("Sending QMI_IPA_INIT_MODEM_DRIVER_REQ_V01\n");
rc = qmi_send_req_wait(ipa_q6_clnt, &req_desc, &req, sizeof(req),
&resp_desc, &resp, sizeof(resp),
QMI_SEND_REQ_TIMEOUT_MS);
pr_info("QMI_IPA_INIT_MODEM_DRIVER_REQ_V01 response received\n");
return ipa_check_qmi_response(rc,
QMI_IPA_INIT_MODEM_DRIVER_REQ_V01, resp.resp.result,
resp.resp.error, "ipa_init_modem_driver_resp_msg_v01");
}
static int audio_etm_enable(struct coresight_device *csdev)
{
struct audio_etm_drvdata *drvdata =
dev_get_drvdata(csdev->dev.parent);
struct coresight_set_etm_req_msg_v01 req;
struct coresight_set_etm_resp_msg_v01 resp = { { 0, 0 } };
struct msg_desc req_desc, resp_desc;
int ret;
mutex_lock(&drvdata->mutex);
/*
* The QMI handle may be NULL in the following scenarios:
* 1. QMI service is not present
* 2. QMI service is present but attempt to enable remote ETM is earlier
* than service is ready to handle request
* 3. Connection between QMI client and QMI service failed
*
* Enable CoreSight without processing further QMI commands which
* provides the option to enable remote ETM by other means.
*/
if (!drvdata->handle) {
dev_info(drvdata->dev,
"%s: QMI service unavailable. Skipping QMI requests\n",
__func__);
goto out;
}
req.state = CORESIGHT_ETM_STATE_ENABLED_V01;
req_desc.msg_id = CORESIGHT_QMI_SET_ETM_REQ_V01;
req_desc.max_msg_len = CORESIGHT_QMI_SET_ETM_REQ_MAX_LEN;
req_desc.ei_array = coresight_set_etm_req_msg_v01_ei;
resp_desc.msg_id = CORESIGHT_QMI_SET_ETM_RESP_V01;
resp_desc.max_msg_len = CORESIGHT_QMI_SET_ETM_RESP_MAX_LEN;
resp_desc.ei_array = coresight_set_etm_resp_msg_v01_ei;
ret = qmi_send_req_wait(drvdata->handle, &req_desc, &req, sizeof(req),
&resp_desc, &resp, sizeof(resp), TIMEOUT_MS);
if (ret < 0) {
dev_err(drvdata->dev, "%s: QMI send req failed %d\n", __func__,
ret);
goto err;
}
if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
dev_err(drvdata->dev, "%s: QMI request failed %d %d\n",
__func__, resp.resp.result, resp.resp.error);
ret = -EREMOTEIO;
goto err;
}
out:
mutex_unlock(&drvdata->mutex);
dev_info(drvdata->dev, "Audio ETM tracing enabled\n");
return 0;
err:
mutex_unlock(&drvdata->mutex);
return ret;
}