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

Commit cd348a49 authored by Karthikeyan Ramasubramanian's avatar Karthikeyan Ramasubramanian
Browse files

slimbus: slim-msm: Update QMI usage 



The interface to QMI has changed considerably. Update the slimbus driver
to use the most recent QMI interface.

Change-Id: Ifcd7a942b27b3f6b6a34a01b02ed94b398fa96de
Signed-off-by: default avatarKarthikeyan Ramasubramanian <kramasub@codeaurora.org>
parent 6f178734

drivers/slimbus/slim-msm-ngd.c

+56 −19
Original line number Diff line number Diff line
@@ -93,6 +93,8 @@ static int ngd_slim_power_up(struct msm_slim_ctrl *dev, bool mdm_restart); 
static void ngd_dom_down(struct msm_slim_ctrl *dev);

static int dsp_domr_notify_cb(struct notifier_block *n, unsigned long code,

				void *_cmd);

static int ngd_slim_qmi_svc_event_init(struct msm_slim_qmi *qmi);

static void ngd_slim_qmi_svc_event_deinit(struct msm_slim_qmi *qmi);



static irqreturn_t ngd_slim_interrupt(int irq, void *d)

{
@@ -162,24 +164,64 @@ static irqreturn_t ngd_slim_interrupt(int irq, void *d) 
	return IRQ_HANDLED;

}



static int ngd_qmi_available(struct notifier_block *n, unsigned long code,

				void *_cmd)

static int ngd_slim_qmi_new_server(struct qmi_handle *hdl,

				   struct qmi_service *service)

{

	struct msm_slim_qmi *qmi = container_of(n, struct msm_slim_qmi, nb);

	struct msm_slim_qmi *qmi =

		container_of(hdl, struct msm_slim_qmi, svc_event_hdl);

	struct msm_slim_ctrl *dev =

		container_of(qmi, struct msm_slim_ctrl, qmi);

	SLIM_INFO(dev, "Slimbus QMI NGD CB received event:%ld\n", code);

	switch (code) {

	case QMI_SERVER_ARRIVE:



	SLIM_INFO(dev, "Slimbus QMI new server event received\n");

	qmi->svc_info.sq_family = AF_QIPCRTR;

	qmi->svc_info.sq_node = service->node;

	qmi->svc_info.sq_port = service->port;

	atomic_set(&dev->ssr_in_progress, 0);

	schedule_work(&dev->dsp.dom_up);

		break;

	default:

		break;

	}



	return 0;

}



static void ngd_slim_qmi_del_server(struct qmi_handle *hdl,

				   struct qmi_service *service)

{

	struct msm_slim_qmi *qmi =

		container_of(hdl, struct msm_slim_qmi, svc_event_hdl);



	qmi->svc_info.sq_node = 0;

	qmi->svc_info.sq_port = 0;

}



static struct qmi_ops ngd_slim_qmi_svc_event_ops = {

	.new_server = ngd_slim_qmi_new_server,

	.del_server = ngd_slim_qmi_del_server,

};



static int ngd_slim_qmi_svc_event_init(struct msm_slim_qmi *qmi)

{

	int ret = 0;



	ret = qmi_handle_init(&qmi->svc_event_hdl, 0,

				&ngd_slim_qmi_svc_event_ops, NULL);

	if (ret < 0) {

		pr_err("%s: qmi_handle_init failed: %d\n", __func__, ret);

		return ret;

	}



	ret = qmi_add_lookup(&qmi->svc_event_hdl, SLIMBUS_QMI_SVC_ID,

				SLIMBUS_QMI_SVC_V1, SLIMBUS_QMI_INS_ID);

	if (ret < 0) {

		pr_err("%s: qmi_add_lookup failed: %d\n", __func__, ret);

		qmi_handle_release(&qmi->svc_event_hdl);

	}

	return ret;

}



static void ngd_slim_qmi_svc_event_deinit(struct msm_slim_qmi *qmi)

{

	qmi_handle_release(&qmi->svc_event_hdl);

}



static void ngd_reg_ssr(struct msm_slim_ctrl *dev)

{

	int ret;
@@ -1572,9 +1614,7 @@ static int ngd_notify_slaves(void *data) 
	struct list_head *pos, *next;

	int ret, i = 0;



	ret = qmi_svc_event_notifier_register(SLIMBUS_QMI_SVC_ID,

				SLIMBUS_QMI_SVC_V1,

				SLIMBUS_QMI_INS_ID, &dev->qmi.nb);

	ret = ngd_slim_qmi_svc_event_init(&dev->qmi);

	if (ret) {

		pr_err("Slimbus QMI service registration failed:%d", ret);

		return ret;
@@ -1927,7 +1967,6 @@ static int ngd_slim_probe(struct platform_device *pdev) 
	}



	INIT_WORK(&dev->dsp.dom_up, ngd_dom_up);

	dev->qmi.nb.notifier_call = ngd_qmi_available;

	pm_runtime_get_noresume(dev->dev);



	/* Fire up the Rx message queue thread */
@@ -1982,9 +2021,7 @@ static int ngd_slim_remove(struct platform_device *pdev) 
	if (dev->sysfs_created)

		sysfs_remove_file(&dev->dev->kobj,

				&dev_attr_debug_mask.attr);

	qmi_svc_event_notifier_unregister(SLIMBUS_QMI_SVC_ID,

				SLIMBUS_QMI_SVC_V1,

				SLIMBUS_QMI_INS_ID, &dev->qmi.nb);

	ngd_slim_qmi_svc_event_deinit(&dev->qmi);

	pm_runtime_disable(&pdev->dev);

	if (dev->dsp.dom_t == MSM_SLIM_DOM_SS)

		subsys_notif_unregister_notifier(dev->dsp.domr,

drivers/slimbus/slim-msm.c

+137 −132
Original line number Diff line number Diff line
@@ -1408,7 +1408,7 @@ struct slimbus_deferred_status_resp { 
	struct qmi_response_type_v01 resp;

};



static struct elem_info slimbus_select_inst_req_msg_v01_ei[] = {

static struct qmi_elem_info slimbus_select_inst_req_msg_v01_ei[] = {

	{

		.data_type = QMI_UNSIGNED_4_BYTE,

		.elem_len  = 1,
@@ -1450,7 +1450,7 @@ static struct elem_info slimbus_select_inst_req_msg_v01_ei[] = { 
	},

};



static struct elem_info slimbus_select_inst_resp_msg_v01_ei[] = {

static struct qmi_elem_info slimbus_select_inst_resp_msg_v01_ei[] = {

	{

		.data_type = QMI_STRUCT,

		.elem_len  = 1,
@@ -1459,7 +1459,7 @@ static struct elem_info slimbus_select_inst_resp_msg_v01_ei[] = { 
		.tlv_type  = 0x02,

		.offset    = offsetof(struct slimbus_select_inst_resp_msg_v01,

				      resp),

		.ei_array  = get_qmi_response_type_v01_ei(),

		.ei_array  = qmi_response_type_v01_ei,

	},

	{

		.data_type = QMI_EOTI,
@@ -1472,7 +1472,7 @@ static struct elem_info slimbus_select_inst_resp_msg_v01_ei[] = { 
	},

};



static struct elem_info slimbus_power_req_msg_v01_ei[] = {

static struct qmi_elem_info slimbus_power_req_msg_v01_ei[] = {

	{

		.data_type = QMI_UNSIGNED_4_BYTE,

		.elem_len  = 1,
@@ -1511,7 +1511,7 @@ static struct elem_info slimbus_power_req_msg_v01_ei[] = { 
	},

};



static struct elem_info slimbus_power_resp_msg_v01_ei[] = {

static struct qmi_elem_info slimbus_power_resp_msg_v01_ei[] = {

	{

		.data_type = QMI_STRUCT,

		.elem_len  = 1,
@@ -1519,7 +1519,7 @@ static struct elem_info slimbus_power_resp_msg_v01_ei[] = { 
		.is_array  = NO_ARRAY,

		.tlv_type  = 0x02,

		.offset    = offsetof(struct slimbus_power_resp_msg_v01, resp),

		.ei_array  = get_qmi_response_type_v01_ei(),

		.ei_array  = qmi_response_type_v01_ei,

	},

	{

		.data_type = QMI_EOTI,
@@ -1532,7 +1532,7 @@ static struct elem_info slimbus_power_resp_msg_v01_ei[] = { 
	},

};



static struct elem_info slimbus_chkfrm_resp_msg_v01_ei[] = {

static struct qmi_elem_info slimbus_chkfrm_resp_msg_v01_ei[] = {

	{

		.data_type = QMI_STRUCT,

		.elem_len  = 1,
@@ -1540,7 +1540,7 @@ static struct elem_info slimbus_chkfrm_resp_msg_v01_ei[] = { 
		.is_array  = NO_ARRAY,

		.tlv_type  = 0x02,

		.offset    = offsetof(struct slimbus_chkfrm_resp_msg, resp),

		.ei_array  = get_qmi_response_type_v01_ei(),

		.ei_array  = qmi_response_type_v01_ei,

	},

	{

		.data_type = QMI_EOTI,
@@ -1553,7 +1553,7 @@ static struct elem_info slimbus_chkfrm_resp_msg_v01_ei[] = { 
	},

};



static struct elem_info slimbus_deferred_status_resp_msg_v01_ei[] = {

static struct qmi_elem_info slimbus_deferred_status_resp_msg_v01_ei[] = {

	{

		.data_type      = QMI_STRUCT,

		.elem_len       = 1,
@@ -1562,41 +1562,27 @@ static struct elem_info slimbus_deferred_status_resp_msg_v01_ei[] = { 
		.tlv_type       = 0x02,

		.offset         = offsetof(struct slimbus_deferred_status_resp,

					   resp),

		.ei_array      = get_qmi_response_type_v01_ei(),

		.ei_array      = qmi_response_type_v01_ei,

	},

	{

		.data_type      = QMI_EOTI,

		.is_array       = NO_ARRAY,

	},

};

static void msm_slim_qmi_recv_msg(struct kthread_work *work)

{

	int rc;

	struct msm_slim_qmi *qmi =

			container_of(work, struct msm_slim_qmi, kwork);



	/* Drain all packets received */

	do {

		rc = qmi_recv_msg(qmi->handle);

	} while (rc == 0);

	if (rc != -ENOMSG)

		pr_err("%s: Error receiving QMI message:%d\n", __func__, rc);

}

static void msm_slim_qmi_power_resp_cb(struct qmi_handle *handle,

	struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data);



static void msm_slim_qmi_notify(struct qmi_handle *handle,

				enum qmi_event_type event, void *notify_priv)

static struct qmi_msg_handler msm_slim_qmi_msg_handlers[] = {

	{

	struct msm_slim_ctrl *dev = notify_priv;

	struct msm_slim_qmi *qmi = &dev->qmi;



	switch (event) {

	case QMI_RECV_MSG:

		kthread_queue_work(&qmi->kworker, &qmi->kwork);

		break;

	default:

		break;

	}

}

		.type = QMI_RESPONSE,

		.msg_id = SLIMBUS_QMI_POWER_RESP_V01,

		.ei = slimbus_power_resp_msg_v01_ei,

		.decoded_size = sizeof(struct slimbus_power_resp_msg_v01),

		.fn = msm_slim_qmi_power_resp_cb,

	},

	{}

};



static const char *get_qmi_error(struct qmi_response_type_v01 *r)

{
@@ -1618,24 +1604,31 @@ static int msm_slim_qmi_send_select_inst_req(struct msm_slim_ctrl *dev, 
				struct slimbus_select_inst_req_msg_v01 *req)

{

	struct slimbus_select_inst_resp_msg_v01 resp = { { 0, 0 } };

	struct msg_desc req_desc, resp_desc;

	struct qmi_txn txn;

	int rc;



	req_desc.msg_id = SLIMBUS_QMI_SELECT_INSTANCE_REQ_V01;

	req_desc.max_msg_len = SLIMBUS_QMI_SELECT_INSTANCE_REQ_MAX_MSG_LEN;

	req_desc.ei_array = slimbus_select_inst_req_msg_v01_ei;



	resp_desc.msg_id = SLIMBUS_QMI_SELECT_INSTANCE_RESP_V01;

	resp_desc.max_msg_len = SLIMBUS_QMI_SELECT_INSTANCE_RESP_MAX_MSG_LEN;

	resp_desc.ei_array = slimbus_select_inst_resp_msg_v01_ei;

	rc = qmi_txn_init(dev->qmi.handle, &txn,

				slimbus_select_inst_resp_msg_v01_ei, &resp);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI TXN init failed: %d\n", __func__, rc);

		return rc;

	}



	rc = qmi_send_req_wait(dev->qmi.handle, &req_desc, req, sizeof(*req),

			&resp_desc, &resp, sizeof(resp), SLIM_QMI_RESP_TOUT);

	rc = qmi_send_request(dev->qmi.handle, NULL, &txn,

				SLIMBUS_QMI_SELECT_INSTANCE_REQ_V01,

				SLIMBUS_QMI_SELECT_INSTANCE_REQ_MAX_MSG_LEN,

				slimbus_select_inst_req_msg_v01_ei, req);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI send req failed %d\n", __func__, rc);

		qmi_txn_cancel(&txn);

		return rc;

	}



	rc = qmi_txn_wait(&txn, SLIM_QMI_RESP_TOUT);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI TXN wait failed: %d\n", __func__, rc);

		return rc;

	}

	/* Check the response */

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

		SLIM_ERR(dev, "%s: QMI request failed 0x%x (%s)\n", __func__,
@@ -1646,56 +1639,65 @@ static int msm_slim_qmi_send_select_inst_req(struct msm_slim_ctrl *dev, 
	return 0;

}



static void slim_qmi_resp_cb(struct qmi_handle *handle, unsigned int msg_id,

			     void *msg, void *resp_cb_data, int stat)

static void msm_slim_qmi_power_resp_cb(struct qmi_handle *handle,

	struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data)

{

	struct slimbus_power_resp_msg_v01 *resp = msg;

	struct msm_slim_ctrl *dev = resp_cb_data;

	struct slimbus_power_resp_msg_v01 *resp =

				(struct slimbus_power_resp_msg_v01 *)data;



	if (!txn) {

		pr_err("%s: with a NULL txn\n", __func__);

		return;

	}



	if (msg_id != SLIMBUS_QMI_POWER_RESP_V01)

		SLIM_WARN(dev, "incorrect msg id in qmi-resp CB:0x%x", msg_id);

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

		SLIM_ERR(dev, "%s: QMI power failed 0x%x (%s)\n", __func__,

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

		pr_err("%s: QMI power request failed 0x%x (%s)\n", __func__,

				resp->resp.result, get_qmi_error(&resp->resp));

	}



	complete(&dev->qmi.defer_comp);

	complete(&txn->completion);

}



static int msm_slim_qmi_send_power_request(struct msm_slim_ctrl *dev,

				struct slimbus_power_req_msg_v01 *req)

{

	struct slimbus_power_resp_msg_v01 *resp =

		(struct slimbus_power_resp_msg_v01 *)&dev->qmi.resp;

	struct msg_desc req_desc;

	struct msg_desc *resp_desc = &dev->qmi.resp_desc;

	struct slimbus_power_resp_msg_v01 resp = { { 0, 0 } };

	struct qmi_txn txn;

	struct qmi_txn *temp;

	int rc;



	req_desc.msg_id = SLIMBUS_QMI_POWER_REQ_V01;

	req_desc.max_msg_len = SLIMBUS_QMI_POWER_REQ_MAX_MSG_LEN;

	req_desc.ei_array = slimbus_power_req_msg_v01_ei;



	resp_desc->msg_id = SLIMBUS_QMI_POWER_RESP_V01;

	resp_desc->max_msg_len = SLIMBUS_QMI_POWER_RESP_MAX_MSG_LEN;

	resp_desc->ei_array = slimbus_power_resp_msg_v01_ei;

	if (dev->qmi.deferred_resp) {

		rc = qmi_txn_init(dev->qmi.handle, &dev->qmi.deferred_txn,

								NULL, NULL);

		temp = &dev->qmi.deferred_txn;

	} else {

		rc = qmi_txn_init(dev->qmi.handle, &txn,

				slimbus_power_resp_msg_v01_ei, &resp);

		temp = &txn;

	}



	if (dev->qmi.deferred_resp)

		rc = qmi_send_req_nowait(dev->qmi.handle, &req_desc, req,

				       sizeof(*req), resp_desc, resp,

				       sizeof(*resp), slim_qmi_resp_cb, dev);

	else

		rc = qmi_send_req_wait(dev->qmi.handle, &req_desc, req,

				       sizeof(*req), resp_desc, resp,

				       sizeof(*resp), SLIM_QMI_RESP_TOUT);

	if (rc < 0)

	rc = qmi_send_request(dev->qmi.handle, NULL, temp,

				SLIMBUS_QMI_POWER_REQ_V01,

				SLIMBUS_QMI_POWER_REQ_MAX_MSG_LEN,

				slimbus_power_req_msg_v01_ei, req);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI send req failed %d\n", __func__, rc);

		qmi_txn_cancel(temp);

	}



	if (rc < 0 || dev->qmi.deferred_resp)

		return rc;



	rc = qmi_txn_wait(temp, SLIM_QMI_RESP_TOUT);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI TXN wait failed: %d\n", __func__, rc);

		return rc;

	}



	/* Check the response */

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

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

		SLIM_ERR(dev, "%s: QMI request failed 0x%x (%s)\n", __func__,

				resp->resp.result, get_qmi_error(&resp->resp));

				resp.resp.result, get_qmi_error(&resp.resp));

		return -EREMOTEIO;

	}
@@ -1708,31 +1710,22 @@ int msm_slim_qmi_init(struct msm_slim_ctrl *dev, bool apps_is_master) 
	struct qmi_handle *handle;

	struct slimbus_select_inst_req_msg_v01 req;



	kthread_init_worker(&dev->qmi.kworker);

	init_completion(&dev->qmi.defer_comp);



	dev->qmi.task = kthread_run(kthread_worker_fn,

			&dev->qmi.kworker, "msm_slim_qmi_clnt%d", dev->ctrl.nr);



	if (IS_ERR(dev->qmi.task)) {

		pr_err("%s: Failed to create QMI client kthread\n", __func__);

	handle = devm_kzalloc(dev->dev, sizeof(*handle), GFP_KERNEL);

	if (!handle)

		return -ENOMEM;

	}



	kthread_init_work(&dev->qmi.kwork, msm_slim_qmi_recv_msg);



	handle = qmi_handle_create(msm_slim_qmi_notify, dev);

	if (!handle) {

		rc = -ENOMEM;

		pr_err("%s: QMI client handle alloc failed\n", __func__);

		goto qmi_handle_create_failed;

	rc = qmi_handle_init(handle, SLIMBUS_QMI_POWER_REQ_MAX_MSG_LEN,

				NULL, msm_slim_qmi_msg_handlers);

	if (rc < 0) {

		pr_err("%s: QMI client init failed: %d\n", __func__, rc);

		goto qmi_handle_init_failed;

	}



	rc = qmi_connect_to_service(handle, SLIMBUS_QMI_SVC_ID,

						SLIMBUS_QMI_SVC_V1,

						SLIMBUS_QMI_INS_ID);

	rc = kernel_connect(handle->sock, (struct sockaddr *)&dev->qmi.svc_info,

				sizeof(dev->qmi.svc_info), 0);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI server not found\n", __func__);

		SLIM_ERR(dev, "%s: Remote Service connect failed: %d\n",

								__func__, rc);

		goto qmi_connect_to_service_failed;

	}
@@ -1759,22 +1752,19 @@ int msm_slim_qmi_init(struct msm_slim_ctrl *dev, bool apps_is_master) 
qmi_select_instance_failed:

	dev->qmi.handle = NULL;

qmi_connect_to_service_failed:

	qmi_handle_destroy(handle);

qmi_handle_create_failed:

	kthread_flush_worker(&dev->qmi.kworker);

	kthread_stop(dev->qmi.task);

	dev->qmi.task = NULL;

	qmi_handle_release(handle);

qmi_handle_init_failed:

	devm_kfree(dev->dev, handle);

	return rc;

}



void msm_slim_qmi_exit(struct msm_slim_ctrl *dev)

{

	if (!dev->qmi.handle || !dev->qmi.task)

	if (!dev->qmi.handle)

		return;

	qmi_handle_destroy(dev->qmi.handle);

	kthread_flush_worker(&dev->qmi.kworker);

	kthread_stop(dev->qmi.task);

	dev->qmi.task = NULL;



	qmi_handle_release(dev->qmi.handle);

	devm_kfree(dev->dev, dev->qmi.handle);

	dev->qmi.handle = NULL;

}
@@ -1800,23 +1790,31 @@ int msm_slim_qmi_power_request(struct msm_slim_ctrl *dev, bool active) 
int msm_slim_qmi_check_framer_request(struct msm_slim_ctrl *dev)

{

	struct slimbus_chkfrm_resp_msg resp = { { 0, 0 } };

	struct msg_desc req_desc, resp_desc;

	struct qmi_txn txn;

	int rc;



	req_desc.msg_id = SLIMBUS_QMI_CHECK_FRAMER_STATUS_REQ;

	req_desc.max_msg_len = 0;

	req_desc.ei_array = NULL;



	resp_desc.msg_id = SLIMBUS_QMI_CHECK_FRAMER_STATUS_RESP;

	resp_desc.max_msg_len = SLIMBUS_QMI_CHECK_FRAMER_STAT_RESP_MAX_MSG_LEN;

	resp_desc.ei_array = slimbus_chkfrm_resp_msg_v01_ei;

	rc = qmi_txn_init(dev->qmi.handle, &txn,

			slimbus_chkfrm_resp_msg_v01_ei, &resp);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI TXN init failed: %d\n", __func__, rc);

		return rc;

	}



	rc = qmi_send_req_wait(dev->qmi.handle, &req_desc, NULL, 0,

		&resp_desc, &resp, sizeof(resp), SLIM_QMI_RESP_TOUT);

	rc = qmi_send_request(dev->qmi.handle, NULL, &txn,

				SLIMBUS_QMI_CHECK_FRAMER_STATUS_REQ, 0,

				NULL, NULL);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI send req failed %d\n", __func__, rc);

		qmi_txn_cancel(&txn);

		return rc;

	}



	rc = qmi_txn_wait(&txn, SLIM_QMI_RESP_TOUT);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI TXN wait failed: %d\n", __func__, rc);

		return rc;

	}



	/* Check the response */

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

		SLIM_ERR(dev, "%s: QMI request failed 0x%x (%s)\n",
@@ -1829,24 +1827,31 @@ int msm_slim_qmi_check_framer_request(struct msm_slim_ctrl *dev) 
int msm_slim_qmi_deferred_status_req(struct msm_slim_ctrl *dev)

{

	struct slimbus_deferred_status_resp resp = { { 0, 0 } };

	struct msg_desc req_desc, resp_desc;

	struct qmi_txn txn;

	int rc;



	req_desc.msg_id = SLIMBUS_QMI_DEFERRED_STATUS_REQ;

	req_desc.max_msg_len = 0;

	req_desc.ei_array = NULL;



	resp_desc.msg_id = SLIMBUS_QMI_DEFERRED_STATUS_RESP;

	resp_desc.max_msg_len =

		SLIMBUS_QMI_DEFERRED_STATUS_RESP_STAT_MSG_MAX_MSG_LEN;

	resp_desc.ei_array = slimbus_deferred_status_resp_msg_v01_ei;

	rc = qmi_txn_init(dev->qmi.handle, &txn,

			slimbus_deferred_status_resp_msg_v01_ei, &resp);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI TXN init failed: %d\n", __func__, rc);

		return rc;

	}



	rc = qmi_send_req_wait(dev->qmi.handle, &req_desc, NULL, 0,

		&resp_desc, &resp, sizeof(resp), SLIM_QMI_RESP_TOUT);

	rc = qmi_send_request(dev->qmi.handle, NULL, &txn,

				SLIMBUS_QMI_DEFERRED_STATUS_REQ, 0,

				NULL, NULL);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI send req failed %d\n", __func__, rc);

		qmi_txn_cancel(&txn);

		return rc;

	}



	rc = qmi_txn_wait(&txn, SLIM_QMI_RESP_TOUT);

	if (rc < 0) {

		SLIM_ERR(dev, "%s: QMI TXN wait failed: %d\n", __func__, rc);

		return rc;

	}



	/* Check the response */

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

		SLIM_ERR(dev, "%s: QMI request failed 0x%x (%s)\n",
@@ -1855,10 +1860,10 @@ int msm_slim_qmi_deferred_status_req(struct msm_slim_ctrl *dev) 
	}



	/* wait for the deferred response */

	rc = wait_for_completion_timeout(&dev->qmi.defer_comp, HZ);

	if (rc == 0) {

	rc = qmi_txn_wait(&dev->qmi.deferred_txn, SLIM_QMI_RESP_TOUT);

	if (rc < 0) {

		SLIM_WARN(dev, "slimbus power deferred response not rcvd\n");

		return -ETIMEDOUT;

		return rc;

	}

	/* Check what response we got in callback */

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

drivers/slimbus/slim-msm.h

+9 −10
Original line number Diff line number Diff line
@@ -13,10 +13,12 @@ 
#ifndef _SLIM_MSM_H

#define _SLIM_MSM_H



#include <linux/ipc_logging.h>

#include <linux/irq.h>

#include <linux/kthread.h>

#include <soc/qcom/msm_qmi_interface.h>

#include <linux/ipc_logging.h>

#include <linux/qrtr.h>

#include <linux/soc/qcom/qmi.h>

#include <net/sock.h>



/* Per spec.max 40 bytes per received message */

#define SLIM_MSGQ_BUF_LEN	40
@@ -94,8 +96,8 @@ 
#define SLIMBUS_QMI_SVC_V1 1

#define SLIMBUS_QMI_INS_ID 0



/* QMI response timeout of 500ms */

#define SLIM_QMI_RESP_TOUT 1000

/* QMI response timeout of 1000ms */

#define SLIM_QMI_RESP_TOUT (HZ)



#define PGD_THIS_EE(r, v) ((v) ? PGD_THIS_EE_V2(r) : PGD_THIS_EE_V1(r))

#define PGD_PORT(r, p, v) ((v) ? PGD_PORT_V2(r, p) : PGD_PORT_V1(r, p))
@@ -221,17 +223,14 @@ struct msm_slim_endp { 


struct msm_slim_qmi {

	struct qmi_handle		*handle;

	struct task_struct		*task;

	struct sockaddr_qrtr		svc_info;

	struct task_struct		*slave_thread;

	struct completion		slave_notify;

	struct kthread_work		kwork;

	struct kthread_worker		kworker;

	struct completion		qmi_comp;

	struct notifier_block		nb;

	struct qmi_handle		svc_event_hdl;

	bool				deferred_resp;

	struct qmi_response_type_v01	resp;

	struct msg_desc			resp_desc;

	struct completion		defer_comp;

	struct qmi_txn			deferred_txn;

};



enum msm_slim_dom {