Merge "slimbus: slim-msm: Update QMI usage" (103bd295) · Commits · e / devices / android_kernel_oneplus_sm8150

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 {