1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2020-2023 Intel Corporation
4  */
5 
6 #include "ivpu_drv.h"
7 #include "ivpu_ipc.h"
8 #include "ivpu_jsm_msg.h"
9 
10 int ivpu_jsm_register_db(struct ivpu_device *vdev, u32 ctx_id, u32 db_id,
11 			 u64 jobq_base, u32 jobq_size)
12 {
13 	struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_REGISTER_DB };
14 	struct vpu_jsm_msg resp;
15 	int ret = 0;
16 
17 	req.payload.register_db.db_idx = db_id;
18 	req.payload.register_db.jobq_base = jobq_base;
19 	req.payload.register_db.jobq_size = jobq_size;
20 	req.payload.register_db.host_ssid = ctx_id;
21 
22 	ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_REGISTER_DB_DONE, &resp,
23 				    VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm);
24 	if (ret) {
25 		ivpu_err(vdev, "Failed to register doorbell %d: %d\n", db_id, ret);
26 		return ret;
27 	}
28 
29 	ivpu_dbg(vdev, JSM, "Doorbell %d registered to context %d\n", db_id, ctx_id);
30 
31 	return 0;
32 }
33 
34 int ivpu_jsm_unregister_db(struct ivpu_device *vdev, u32 db_id)
35 {
36 	struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_UNREGISTER_DB };
37 	struct vpu_jsm_msg resp;
38 	int ret = 0;
39 
40 	req.payload.unregister_db.db_idx = db_id;
41 
42 	ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_UNREGISTER_DB_DONE, &resp,
43 				    VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm);
44 	if (ret) {
45 		ivpu_warn(vdev, "Failed to unregister doorbell %d: %d\n", db_id, ret);
46 		return ret;
47 	}
48 
49 	ivpu_dbg(vdev, JSM, "Doorbell %d unregistered\n", db_id);
50 
51 	return 0;
52 }
53 
54 int ivpu_jsm_get_heartbeat(struct ivpu_device *vdev, u32 engine, u64 *heartbeat)
55 {
56 	struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_QUERY_ENGINE_HB };
57 	struct vpu_jsm_msg resp;
58 	int ret;
59 
60 	if (engine > VPU_ENGINE_COPY)
61 		return -EINVAL;
62 
63 	req.payload.query_engine_hb.engine_idx = engine;
64 
65 	ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_QUERY_ENGINE_HB_DONE, &resp,
66 				    VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm);
67 	if (ret) {
68 		ivpu_err(vdev, "Failed to get heartbeat from engine %d: %d\n", engine, ret);
69 		return ret;
70 	}
71 
72 	*heartbeat = resp.payload.query_engine_hb_done.heartbeat;
73 	return ret;
74 }
75 
76 int ivpu_jsm_reset_engine(struct ivpu_device *vdev, u32 engine)
77 {
78 	struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_ENGINE_RESET };
79 	struct vpu_jsm_msg resp;
80 	int ret;
81 
82 	if (engine > VPU_ENGINE_COPY)
83 		return -EINVAL;
84 
85 	req.payload.engine_reset.engine_idx = engine;
86 
87 	ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_ENGINE_RESET_DONE, &resp,
88 				    VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm);
89 	if (ret)
90 		ivpu_err(vdev, "Failed to reset engine %d: %d\n", engine, ret);
91 
92 	return ret;
93 }
94 
95 int ivpu_jsm_preempt_engine(struct ivpu_device *vdev, u32 engine, u32 preempt_id)
96 {
97 	struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_ENGINE_PREEMPT };
98 	struct vpu_jsm_msg resp;
99 	int ret;
100 
101 	if (engine > VPU_ENGINE_COPY)
102 		return -EINVAL;
103 
104 	req.payload.engine_preempt.engine_idx = engine;
105 	req.payload.engine_preempt.preempt_id = preempt_id;
106 
107 	ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_ENGINE_PREEMPT_DONE, &resp,
108 				    VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm);
109 	if (ret)
110 		ivpu_err(vdev, "Failed to preempt engine %d: %d\n", engine, ret);
111 
112 	return ret;
113 }
114 
115 int ivpu_jsm_dyndbg_control(struct ivpu_device *vdev, char *command, size_t size)
116 {
117 	struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_DYNDBG_CONTROL };
118 	struct vpu_jsm_msg resp;
119 	int ret;
120 
121 	strscpy(req.payload.dyndbg_control.dyndbg_cmd, command, VPU_DYNDBG_CMD_MAX_LEN);
122 
123 	ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_DYNDBG_CONTROL_RSP, &resp,
124 				    VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm);
125 	if (ret)
126 		ivpu_warn(vdev, "Failed to send command \"%s\": ret %d\n", command, ret);
127 
128 	return ret;
129 }
130 
131 int ivpu_jsm_trace_get_capability(struct ivpu_device *vdev, u32 *trace_destination_mask,
132 				  u64 *trace_hw_component_mask)
133 {
134 	struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_TRACE_GET_CAPABILITY };
135 	struct vpu_jsm_msg resp;
136 	int ret;
137 
138 	ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_TRACE_GET_CAPABILITY_RSP, &resp,
139 				    VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm);
140 	if (ret) {
141 		ivpu_warn(vdev, "Failed to get trace capability: %d\n", ret);
142 		return ret;
143 	}
144 
145 	*trace_destination_mask = resp.payload.trace_capability.trace_destination_mask;
146 	*trace_hw_component_mask = resp.payload.trace_capability.trace_hw_component_mask;
147 
148 	return ret;
149 }
150 
151 int ivpu_jsm_trace_set_config(struct ivpu_device *vdev, u32 trace_level, u32 trace_destination_mask,
152 			      u64 trace_hw_component_mask)
153 {
154 	struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_TRACE_SET_CONFIG };
155 	struct vpu_jsm_msg resp;
156 	int ret;
157 
158 	req.payload.trace_config.trace_level = trace_level;
159 	req.payload.trace_config.trace_destination_mask = trace_destination_mask;
160 	req.payload.trace_config.trace_hw_component_mask = trace_hw_component_mask;
161 
162 	ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_TRACE_SET_CONFIG_RSP, &resp,
163 				    VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm);
164 	if (ret)
165 		ivpu_warn(vdev, "Failed to set config: %d\n", ret);
166 
167 	return ret;
168 }
169 
170 int ivpu_jsm_context_release(struct ivpu_device *vdev, u32 host_ssid)
171 {
172 	struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_SSID_RELEASE };
173 	struct vpu_jsm_msg resp;
174 
175 	req.payload.ssid_release.host_ssid = host_ssid;
176 
177 	return ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_SSID_RELEASE_DONE, &resp,
178 				     VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm);
179 }
180