1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2020-2026 Intel Corporation 4 */ 5 6 #include "ivpu_drv.h" 7 #include "ivpu_hw.h" 8 #include "ivpu_ipc.h" 9 #include "ivpu_jsm_msg.h" 10 #include "ivpu_pm.h" 11 #include "vpu_jsm_api.h" 12 13 const char *ivpu_jsm_msg_type_to_str(enum vpu_ipc_msg_type type) 14 { 15 #define IVPU_CASE_TO_STR(x) case x: return #x 16 switch (type) { 17 IVPU_CASE_TO_STR(VPU_JSM_MSG_UNKNOWN); 18 IVPU_CASE_TO_STR(VPU_JSM_MSG_ENGINE_RESET); 19 IVPU_CASE_TO_STR(VPU_JSM_MSG_ENGINE_PREEMPT); 20 IVPU_CASE_TO_STR(VPU_JSM_MSG_REGISTER_DB); 21 IVPU_CASE_TO_STR(VPU_JSM_MSG_UNREGISTER_DB); 22 IVPU_CASE_TO_STR(VPU_JSM_MSG_QUERY_ENGINE_HB); 23 IVPU_CASE_TO_STR(VPU_JSM_MSG_GET_POWER_LEVEL_COUNT); 24 IVPU_CASE_TO_STR(VPU_JSM_MSG_GET_POWER_LEVEL); 25 IVPU_CASE_TO_STR(VPU_JSM_MSG_SET_POWER_LEVEL); 26 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_OPEN); 27 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_CLOSE); 28 IVPU_CASE_TO_STR(VPU_JSM_MSG_TRACE_SET_CONFIG); 29 IVPU_CASE_TO_STR(VPU_JSM_MSG_TRACE_GET_CONFIG); 30 IVPU_CASE_TO_STR(VPU_JSM_MSG_TRACE_GET_CAPABILITY); 31 IVPU_CASE_TO_STR(VPU_JSM_MSG_TRACE_GET_NAME); 32 IVPU_CASE_TO_STR(VPU_JSM_MSG_SSID_RELEASE); 33 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_START); 34 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_STOP); 35 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_UPDATE); 36 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_INFO); 37 IVPU_CASE_TO_STR(VPU_JSM_MSG_SET_PRIORITY_BAND_SETUP); 38 IVPU_CASE_TO_STR(VPU_JSM_MSG_CREATE_CMD_QUEUE); 39 IVPU_CASE_TO_STR(VPU_JSM_MSG_DESTROY_CMD_QUEUE); 40 IVPU_CASE_TO_STR(VPU_JSM_MSG_SET_CONTEXT_SCHED_PROPERTIES); 41 IVPU_CASE_TO_STR(VPU_JSM_MSG_HWS_REGISTER_DB); 42 IVPU_CASE_TO_STR(VPU_JSM_MSG_HWS_RESUME_CMDQ); 43 IVPU_CASE_TO_STR(VPU_JSM_MSG_HWS_SUSPEND_CMDQ); 44 IVPU_CASE_TO_STR(VPU_JSM_MSG_HWS_RESUME_CMDQ_RSP); 45 IVPU_CASE_TO_STR(VPU_JSM_MSG_HWS_SUSPEND_CMDQ_DONE); 46 IVPU_CASE_TO_STR(VPU_JSM_MSG_HWS_SET_SCHEDULING_LOG); 47 IVPU_CASE_TO_STR(VPU_JSM_MSG_HWS_SET_SCHEDULING_LOG_RSP); 48 IVPU_CASE_TO_STR(VPU_JSM_MSG_HWS_SCHEDULING_LOG_NOTIFICATION); 49 IVPU_CASE_TO_STR(VPU_JSM_MSG_HWS_ENGINE_RESUME); 50 IVPU_CASE_TO_STR(VPU_JSM_MSG_HWS_RESUME_ENGINE_DONE); 51 IVPU_CASE_TO_STR(VPU_JSM_MSG_STATE_DUMP); 52 IVPU_CASE_TO_STR(VPU_JSM_MSG_STATE_DUMP_RSP); 53 IVPU_CASE_TO_STR(VPU_JSM_MSG_BLOB_DEINIT_DEPRECATED); 54 IVPU_CASE_TO_STR(VPU_JSM_MSG_DYNDBG_CONTROL); 55 IVPU_CASE_TO_STR(VPU_JSM_MSG_JOB_DONE); 56 IVPU_CASE_TO_STR(VPU_JSM_MSG_NATIVE_FENCE_SIGNALLED); 57 IVPU_CASE_TO_STR(VPU_JSM_MSG_ENGINE_RESET_DONE); 58 IVPU_CASE_TO_STR(VPU_JSM_MSG_ENGINE_PREEMPT_DONE); 59 IVPU_CASE_TO_STR(VPU_JSM_MSG_REGISTER_DB_DONE); 60 IVPU_CASE_TO_STR(VPU_JSM_MSG_UNREGISTER_DB_DONE); 61 IVPU_CASE_TO_STR(VPU_JSM_MSG_QUERY_ENGINE_HB_DONE); 62 IVPU_CASE_TO_STR(VPU_JSM_MSG_GET_POWER_LEVEL_COUNT_DONE); 63 IVPU_CASE_TO_STR(VPU_JSM_MSG_GET_POWER_LEVEL_DONE); 64 IVPU_CASE_TO_STR(VPU_JSM_MSG_SET_POWER_LEVEL_DONE); 65 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_OPEN_DONE); 66 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_CLOSE_DONE); 67 IVPU_CASE_TO_STR(VPU_JSM_MSG_TRACE_SET_CONFIG_RSP); 68 IVPU_CASE_TO_STR(VPU_JSM_MSG_TRACE_GET_CONFIG_RSP); 69 IVPU_CASE_TO_STR(VPU_JSM_MSG_TRACE_GET_CAPABILITY_RSP); 70 IVPU_CASE_TO_STR(VPU_JSM_MSG_TRACE_GET_NAME_RSP); 71 IVPU_CASE_TO_STR(VPU_JSM_MSG_SSID_RELEASE_DONE); 72 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_START_DONE); 73 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_STOP_DONE); 74 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_UPDATE_DONE); 75 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_INFO_DONE); 76 IVPU_CASE_TO_STR(VPU_JSM_MSG_METRIC_STREAMER_NOTIFICATION); 77 IVPU_CASE_TO_STR(VPU_JSM_MSG_SET_PRIORITY_BAND_SETUP_RSP); 78 IVPU_CASE_TO_STR(VPU_JSM_MSG_CREATE_CMD_QUEUE_RSP); 79 IVPU_CASE_TO_STR(VPU_JSM_MSG_DESTROY_CMD_QUEUE_RSP); 80 IVPU_CASE_TO_STR(VPU_JSM_MSG_SET_CONTEXT_SCHED_PROPERTIES_RSP); 81 IVPU_CASE_TO_STR(VPU_JSM_MSG_BLOB_DEINIT_DONE); 82 IVPU_CASE_TO_STR(VPU_JSM_MSG_DYNDBG_CONTROL_RSP); 83 IVPU_CASE_TO_STR(VPU_JSM_MSG_PWR_D0I3_ENTER); 84 IVPU_CASE_TO_STR(VPU_JSM_MSG_PWR_D0I3_ENTER_DONE); 85 IVPU_CASE_TO_STR(VPU_JSM_MSG_DCT_ENABLE); 86 IVPU_CASE_TO_STR(VPU_JSM_MSG_DCT_ENABLE_DONE); 87 IVPU_CASE_TO_STR(VPU_JSM_MSG_DCT_DISABLE); 88 IVPU_CASE_TO_STR(VPU_JSM_MSG_DCT_DISABLE_DONE); 89 IVPU_CASE_TO_STR(VPU_JSM_MSG_FREQ_CONFIG); 90 IVPU_CASE_TO_STR(VPU_JSM_MSG_FREQ_CONFIG_RSP); 91 IVPU_CASE_TO_STR(VPU_JSM_MSG_RESERVED_111E); 92 } 93 #undef IVPU_CASE_TO_STR 94 95 return "Unknown JSM message type"; 96 } 97 98 int ivpu_jsm_register_db(struct ivpu_device *vdev, u32 ctx_id, u32 db_id, 99 u64 jobq_base, u32 jobq_size) 100 { 101 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_REGISTER_DB }; 102 struct vpu_jsm_msg resp; 103 int ret = 0; 104 105 req.payload.register_db.db_idx = db_id; 106 req.payload.register_db.jobq_base = jobq_base; 107 req.payload.register_db.jobq_size = jobq_size; 108 req.payload.register_db.host_ssid = ctx_id; 109 110 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_REGISTER_DB_DONE, &resp, 111 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 112 if (ret) 113 ivpu_err_ratelimited(vdev, "Failed to register doorbell %u: %d\n", db_id, ret); 114 115 return ret; 116 } 117 118 int ivpu_jsm_unregister_db(struct ivpu_device *vdev, u32 db_id) 119 { 120 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_UNREGISTER_DB }; 121 struct vpu_jsm_msg resp; 122 int ret = 0; 123 124 req.payload.unregister_db.db_idx = db_id; 125 126 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_UNREGISTER_DB_DONE, &resp, 127 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 128 if (ret) 129 ivpu_warn_ratelimited(vdev, "Failed to unregister doorbell %u: %d\n", db_id, ret); 130 131 return ret; 132 } 133 134 int ivpu_jsm_get_heartbeat(struct ivpu_device *vdev, u32 engine, u64 *heartbeat) 135 { 136 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_QUERY_ENGINE_HB }; 137 struct vpu_jsm_msg resp; 138 int ret; 139 140 if (engine != VPU_ENGINE_COMPUTE) 141 return -EINVAL; 142 143 req.payload.query_engine_hb.engine_idx = engine; 144 145 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_QUERY_ENGINE_HB_DONE, &resp, 146 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 147 if (ret) { 148 ivpu_err_ratelimited(vdev, "Failed to get heartbeat from engine %d: %d\n", 149 engine, ret); 150 return ret; 151 } 152 153 *heartbeat = resp.payload.query_engine_hb_done.heartbeat; 154 return ret; 155 } 156 157 int ivpu_jsm_reset_engine(struct ivpu_device *vdev, u32 engine, struct vpu_jsm_msg *resp) 158 { 159 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_ENGINE_RESET }; 160 int ret; 161 162 if (engine != VPU_ENGINE_COMPUTE) 163 return -EINVAL; 164 165 req.payload.engine_reset.engine_idx = engine; 166 167 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_ENGINE_RESET_DONE, resp, 168 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 169 if (ret) { 170 ivpu_err_ratelimited(vdev, "Failed to reset engine %d: %d\n", engine, ret); 171 ivpu_pm_trigger_recovery(vdev, "Engine reset failed"); 172 return ret; 173 } 174 175 atomic_inc(&vdev->pm->engine_reset_counter); 176 177 return 0; 178 } 179 180 int ivpu_jsm_preempt_engine(struct ivpu_device *vdev, u32 engine, u32 preempt_id) 181 { 182 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_ENGINE_PREEMPT }; 183 struct vpu_jsm_msg resp; 184 int ret; 185 186 if (engine != VPU_ENGINE_COMPUTE) 187 return -EINVAL; 188 189 req.payload.engine_preempt.engine_idx = engine; 190 req.payload.engine_preempt.preempt_id = preempt_id; 191 192 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_ENGINE_PREEMPT_DONE, &resp, 193 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 194 if (ret) 195 ivpu_err_ratelimited(vdev, "Failed to preempt engine %d: %d\n", engine, ret); 196 197 return ret; 198 } 199 200 int ivpu_jsm_dyndbg_control(struct ivpu_device *vdev, char *command, size_t size) 201 { 202 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_DYNDBG_CONTROL }; 203 struct vpu_jsm_msg resp; 204 int ret; 205 206 strscpy(req.payload.dyndbg_control.dyndbg_cmd, command, VPU_DYNDBG_CMD_MAX_LEN); 207 208 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_DYNDBG_CONTROL_RSP, &resp, 209 VPU_IPC_CHAN_GEN_CMD, vdev->timeout.jsm); 210 if (ret) 211 ivpu_warn_ratelimited(vdev, "Failed to send command \"%s\": ret %d\n", 212 command, ret); 213 214 return ret; 215 } 216 217 int ivpu_jsm_trace_get_capability(struct ivpu_device *vdev, u32 *trace_destination_mask, 218 u64 *trace_hw_component_mask) 219 { 220 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_TRACE_GET_CAPABILITY }; 221 struct vpu_jsm_msg resp; 222 int ret; 223 224 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_TRACE_GET_CAPABILITY_RSP, &resp, 225 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 226 if (ret) { 227 ivpu_warn_ratelimited(vdev, "Failed to get trace capability: %d\n", ret); 228 return ret; 229 } 230 231 *trace_destination_mask = resp.payload.trace_capability.trace_destination_mask; 232 *trace_hw_component_mask = resp.payload.trace_capability.trace_hw_component_mask; 233 234 return ret; 235 } 236 237 int ivpu_jsm_trace_set_config(struct ivpu_device *vdev, u32 trace_level, u32 trace_destination_mask, 238 u64 trace_hw_component_mask) 239 { 240 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_TRACE_SET_CONFIG }; 241 struct vpu_jsm_msg resp; 242 int ret; 243 244 req.payload.trace_config.trace_level = trace_level; 245 req.payload.trace_config.trace_destination_mask = trace_destination_mask; 246 req.payload.trace_config.trace_hw_component_mask = trace_hw_component_mask; 247 248 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_TRACE_SET_CONFIG_RSP, &resp, 249 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 250 if (ret) 251 ivpu_warn_ratelimited(vdev, "Failed to set config: %d\n", ret); 252 253 return ret; 254 } 255 256 int ivpu_jsm_context_release(struct ivpu_device *vdev, u32 host_ssid) 257 { 258 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_SSID_RELEASE }; 259 struct vpu_jsm_msg resp; 260 int ret; 261 262 req.payload.ssid_release.host_ssid = host_ssid; 263 264 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_SSID_RELEASE_DONE, &resp, 265 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 266 if (ret) 267 ivpu_warn_ratelimited(vdev, "Failed to release context: %d\n", ret); 268 269 return ret; 270 } 271 272 int ivpu_jsm_pwr_d0i3_enter(struct ivpu_device *vdev) 273 { 274 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_PWR_D0I3_ENTER }; 275 struct vpu_jsm_msg resp; 276 int ret; 277 278 req.payload.pwr_d0i3_enter.send_response = 1; 279 280 ret = ivpu_ipc_send_receive_internal(vdev, &req, VPU_JSM_MSG_PWR_D0I3_ENTER_DONE, &resp, 281 VPU_IPC_CHAN_GEN_CMD, vdev->timeout.d0i3_entry_msg); 282 if (ret) 283 return ret; 284 285 return ivpu_hw_wait_for_idle(vdev); 286 } 287 288 int ivpu_jsm_hws_create_cmdq(struct ivpu_device *vdev, u32 ctx_id, u32 cmdq_group, u32 cmdq_id, 289 u32 pid, u32 engine, u64 cmdq_base, u32 cmdq_size) 290 { 291 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_CREATE_CMD_QUEUE }; 292 struct vpu_jsm_msg resp; 293 int ret; 294 295 req.payload.hws_create_cmdq.host_ssid = ctx_id; 296 req.payload.hws_create_cmdq.process_id = pid; 297 req.payload.hws_create_cmdq.engine_idx = engine; 298 req.payload.hws_create_cmdq.cmdq_group = cmdq_group; 299 req.payload.hws_create_cmdq.cmdq_id = cmdq_id; 300 req.payload.hws_create_cmdq.cmdq_base = cmdq_base; 301 req.payload.hws_create_cmdq.cmdq_size = cmdq_size; 302 303 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_CREATE_CMD_QUEUE_RSP, &resp, 304 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 305 if (ret) 306 ivpu_warn_ratelimited(vdev, "Failed to create command queue: %d\n", ret); 307 308 return ret; 309 } 310 311 int ivpu_jsm_hws_destroy_cmdq(struct ivpu_device *vdev, u32 ctx_id, u32 cmdq_id) 312 { 313 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_DESTROY_CMD_QUEUE }; 314 struct vpu_jsm_msg resp; 315 int ret; 316 317 req.payload.hws_destroy_cmdq.host_ssid = ctx_id; 318 req.payload.hws_destroy_cmdq.cmdq_id = cmdq_id; 319 320 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_DESTROY_CMD_QUEUE_RSP, &resp, 321 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 322 if (ret) 323 ivpu_warn_ratelimited(vdev, "Failed to destroy command queue: %d\n", ret); 324 325 return ret; 326 } 327 328 int ivpu_jsm_hws_register_db(struct ivpu_device *vdev, u32 ctx_id, u32 cmdq_id, u32 db_id, 329 u64 cmdq_base, u32 cmdq_size) 330 { 331 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_HWS_REGISTER_DB }; 332 struct vpu_jsm_msg resp; 333 int ret = 0; 334 335 req.payload.hws_register_db.db_id = db_id; 336 req.payload.hws_register_db.host_ssid = ctx_id; 337 req.payload.hws_register_db.cmdq_id = cmdq_id; 338 req.payload.hws_register_db.cmdq_base = cmdq_base; 339 req.payload.hws_register_db.cmdq_size = cmdq_size; 340 341 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_REGISTER_DB_DONE, &resp, 342 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 343 if (ret) 344 ivpu_err_ratelimited(vdev, "Failed to register doorbell %u: %d\n", db_id, ret); 345 346 return ret; 347 } 348 349 int ivpu_jsm_hws_resume_engine(struct ivpu_device *vdev, u32 engine) 350 { 351 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_HWS_ENGINE_RESUME }; 352 struct vpu_jsm_msg resp; 353 int ret; 354 355 if (engine != VPU_ENGINE_COMPUTE) 356 return -EINVAL; 357 358 req.payload.hws_resume_engine.engine_idx = engine; 359 360 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_HWS_RESUME_ENGINE_DONE, &resp, 361 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 362 if (ret) { 363 ivpu_err_ratelimited(vdev, "Failed to resume engine %d: %d\n", engine, ret); 364 ivpu_pm_trigger_recovery(vdev, "Engine resume failed"); 365 } 366 367 return ret; 368 } 369 370 int ivpu_jsm_hws_set_context_sched_properties(struct ivpu_device *vdev, u32 ctx_id, u32 cmdq_id, 371 u32 priority) 372 { 373 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_SET_CONTEXT_SCHED_PROPERTIES }; 374 struct vpu_jsm_msg resp; 375 int ret; 376 377 req.payload.hws_set_context_sched_properties.host_ssid = ctx_id; 378 req.payload.hws_set_context_sched_properties.cmdq_id = cmdq_id; 379 req.payload.hws_set_context_sched_properties.priority_band = priority; 380 req.payload.hws_set_context_sched_properties.realtime_priority_level = 0; 381 req.payload.hws_set_context_sched_properties.in_process_priority = 0; 382 req.payload.hws_set_context_sched_properties.context_quantum = 20000; 383 req.payload.hws_set_context_sched_properties.grace_period_same_priority = 10000; 384 req.payload.hws_set_context_sched_properties.grace_period_lower_priority = 0; 385 386 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_SET_CONTEXT_SCHED_PROPERTIES_RSP, &resp, 387 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 388 if (ret) 389 ivpu_warn_ratelimited(vdev, "Failed to set context sched properties: %d\n", ret); 390 391 return ret; 392 } 393 394 int ivpu_jsm_hws_set_scheduling_log(struct ivpu_device *vdev, u32 engine_idx, u32 host_ssid, 395 u64 vpu_log_buffer_va) 396 { 397 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_HWS_SET_SCHEDULING_LOG }; 398 struct vpu_jsm_msg resp; 399 int ret; 400 401 req.payload.hws_set_scheduling_log.engine_idx = engine_idx; 402 req.payload.hws_set_scheduling_log.host_ssid = host_ssid; 403 req.payload.hws_set_scheduling_log.vpu_log_buffer_va = vpu_log_buffer_va; 404 req.payload.hws_set_scheduling_log.notify_index = 0; 405 406 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_HWS_SET_SCHEDULING_LOG_RSP, &resp, 407 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 408 if (ret) 409 ivpu_warn_ratelimited(vdev, "Failed to set scheduling log: %d\n", ret); 410 411 return ret; 412 } 413 414 int ivpu_jsm_hws_setup_priority_bands(struct ivpu_device *vdev) 415 { 416 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_SET_PRIORITY_BAND_SETUP }; 417 struct vpu_jsm_msg resp; 418 struct ivpu_hw_info *hw = vdev->hw; 419 struct vpu_ipc_msg_payload_hws_priority_band_setup *setup = 420 &req.payload.hws_priority_band_setup; 421 int ret; 422 423 for (int band = VPU_JOB_SCHEDULING_PRIORITY_BAND_IDLE; 424 band < VPU_JOB_SCHEDULING_PRIORITY_BAND_COUNT; band++) { 425 setup->grace_period[band] = hw->hws.grace_period[band]; 426 setup->process_grace_period[band] = hw->hws.process_grace_period[band]; 427 setup->process_quantum[band] = hw->hws.process_quantum[band]; 428 } 429 setup->normal_band_percentage = 10; 430 431 ret = ivpu_ipc_send_receive_internal(vdev, &req, VPU_JSM_MSG_SET_PRIORITY_BAND_SETUP_RSP, 432 &resp, VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 433 if (ret) 434 ivpu_warn_ratelimited(vdev, "Failed to set priority bands: %d\n", ret); 435 436 return ret; 437 } 438 439 int ivpu_jsm_metric_streamer_start(struct ivpu_device *vdev, u64 metric_group_mask, 440 u64 sampling_rate, u64 buffer_addr, u64 buffer_size) 441 { 442 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_METRIC_STREAMER_START }; 443 struct vpu_jsm_msg resp; 444 int ret; 445 446 req.payload.metric_streamer_start.metric_group_mask = metric_group_mask; 447 req.payload.metric_streamer_start.sampling_rate = sampling_rate; 448 req.payload.metric_streamer_start.buffer_addr = buffer_addr; 449 req.payload.metric_streamer_start.buffer_size = buffer_size; 450 451 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_METRIC_STREAMER_START_DONE, &resp, 452 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 453 if (ret) { 454 ivpu_warn_ratelimited(vdev, "Failed to start metric streamer: ret %d\n", ret); 455 return ret; 456 } 457 458 return ret; 459 } 460 461 int ivpu_jsm_metric_streamer_stop(struct ivpu_device *vdev, u64 metric_group_mask) 462 { 463 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_METRIC_STREAMER_STOP }; 464 struct vpu_jsm_msg resp; 465 int ret; 466 467 req.payload.metric_streamer_stop.metric_group_mask = metric_group_mask; 468 469 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_METRIC_STREAMER_STOP_DONE, &resp, 470 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 471 if (ret) 472 ivpu_warn_ratelimited(vdev, "Failed to stop metric streamer: ret %d\n", ret); 473 474 return ret; 475 } 476 477 int ivpu_jsm_metric_streamer_update(struct ivpu_device *vdev, u64 metric_group_mask, 478 u64 buffer_addr, u64 buffer_size, u64 *bytes_written) 479 { 480 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_METRIC_STREAMER_UPDATE }; 481 struct vpu_jsm_msg resp; 482 int ret; 483 484 req.payload.metric_streamer_update.metric_group_mask = metric_group_mask; 485 req.payload.metric_streamer_update.buffer_addr = buffer_addr; 486 req.payload.metric_streamer_update.buffer_size = buffer_size; 487 488 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_METRIC_STREAMER_UPDATE_DONE, &resp, 489 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 490 if (ret) { 491 ivpu_warn_ratelimited(vdev, "Failed to update metric streamer: ret %d\n", ret); 492 return ret; 493 } 494 495 if (buffer_size && resp.payload.metric_streamer_done.bytes_written > buffer_size) { 496 ivpu_warn_ratelimited(vdev, "MS buffer overflow: bytes_written %#llx > buffer_size %#llx\n", 497 resp.payload.metric_streamer_done.bytes_written, buffer_size); 498 return -EOVERFLOW; 499 } 500 501 *bytes_written = resp.payload.metric_streamer_done.bytes_written; 502 503 return ret; 504 } 505 506 int ivpu_jsm_metric_streamer_info(struct ivpu_device *vdev, u64 metric_group_mask, u64 buffer_addr, 507 u64 buffer_size, u32 *sample_size, u64 *info_size) 508 { 509 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_METRIC_STREAMER_INFO }; 510 struct vpu_jsm_msg resp; 511 int ret; 512 513 req.payload.metric_streamer_start.metric_group_mask = metric_group_mask; 514 req.payload.metric_streamer_start.buffer_addr = buffer_addr; 515 req.payload.metric_streamer_start.buffer_size = buffer_size; 516 517 ret = ivpu_ipc_send_receive(vdev, &req, VPU_JSM_MSG_METRIC_STREAMER_INFO_DONE, &resp, 518 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 519 if (ret) { 520 ivpu_warn_ratelimited(vdev, "Failed to get metric streamer info: ret %d\n", ret); 521 return ret; 522 } 523 524 if (!resp.payload.metric_streamer_done.sample_size) { 525 ivpu_warn_ratelimited(vdev, "Invalid sample size\n"); 526 return -EBADMSG; 527 } 528 529 if (sample_size) 530 *sample_size = resp.payload.metric_streamer_done.sample_size; 531 if (info_size) 532 *info_size = resp.payload.metric_streamer_done.bytes_written; 533 534 return ret; 535 } 536 537 int ivpu_jsm_dct_enable(struct ivpu_device *vdev, u32 active_us, u32 inactive_us) 538 { 539 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_DCT_ENABLE }; 540 struct vpu_jsm_msg resp; 541 542 req.payload.pwr_dct_control.dct_active_us = active_us; 543 req.payload.pwr_dct_control.dct_inactive_us = inactive_us; 544 545 return ivpu_ipc_send_receive_internal(vdev, &req, VPU_JSM_MSG_DCT_ENABLE_DONE, &resp, 546 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 547 } 548 549 int ivpu_jsm_dct_disable(struct ivpu_device *vdev) 550 { 551 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_DCT_DISABLE }; 552 struct vpu_jsm_msg resp; 553 554 return ivpu_ipc_send_receive_internal(vdev, &req, VPU_JSM_MSG_DCT_DISABLE_DONE, &resp, 555 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 556 } 557 558 int ivpu_jsm_state_dump(struct ivpu_device *vdev) 559 { 560 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_STATE_DUMP }; 561 struct vpu_jsm_msg resp; 562 563 return ivpu_ipc_send_receive_internal(vdev, &req, VPU_JSM_MSG_STATE_DUMP_RSP, &resp, 564 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 565 } 566 567 int ivpu_jsm_state_dump_no_reply(struct ivpu_device *vdev) 568 { 569 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_STATE_DUMP }; 570 571 return ivpu_ipc_send_and_wait(vdev, &req, VPU_IPC_CHAN_ASYNC_CMD, 572 vdev->timeout.state_dump_msg); 573 } 574 575 int ivpu_jsm_msg_freq_config(struct ivpu_device *vdev, u16 min_ratio, u16 pn_ratio, u16 max_ratio) 576 { 577 struct vpu_jsm_msg req = { .type = VPU_JSM_MSG_FREQ_CONFIG}; 578 struct vpu_jsm_msg resp; 579 580 req.payload.freq_config.min_freq_pll_ratio = min_ratio; 581 req.payload.freq_config.pn_freq_pll_ratio = pn_ratio; 582 req.payload.freq_config.max_freq_pll_ratio = max_ratio; 583 584 return ivpu_ipc_send_receive_internal(vdev, &req, VPU_JSM_MSG_FREQ_CONFIG_RSP, &resp, 585 VPU_IPC_CHAN_ASYNC_CMD, vdev->timeout.jsm); 586 } 587