1 /* SPDX-License-Identifier: MIT */ 2 /* 3 * Copyright (c) 2020-2023, Intel Corporation. 4 */ 5 6 /** 7 * @file 8 * @brief JSM shared definitions 9 * 10 * @ingroup Jsm 11 * @brief JSM shared definitions 12 * @{ 13 */ 14 #ifndef VPU_JSM_API_H 15 #define VPU_JSM_API_H 16 17 /* 18 * Major version changes that break backward compatibility 19 */ 20 #define VPU_JSM_API_VER_MAJOR 3 21 22 /* 23 * Minor version changes when API backward compatibility is preserved. 24 */ 25 #define VPU_JSM_API_VER_MINOR 15 26 27 /* 28 * API header changed (field names, documentation, formatting) but API itself has not been changed 29 */ 30 #define VPU_JSM_API_VER_PATCH 6 31 32 /* 33 * Index in the API version table 34 */ 35 #define VPU_JSM_API_VER_INDEX 4 36 37 /* 38 * Number of Priority Bands for Hardware Scheduling 39 * Bands: RealTime, Focus, Normal, Idle 40 */ 41 #define VPU_HWS_NUM_PRIORITY_BANDS 4 42 43 /* Max number of impacted contexts that can be dealt with the engine reset command */ 44 #define VPU_MAX_ENGINE_RESET_IMPACTED_CONTEXTS 3 45 46 /* 47 * Pack the API structures to enforce binary compatibility 48 * Align to 8 bytes for optimal performance 49 */ 50 #pragma pack(push, 8) 51 52 /* 53 * Engine indexes. 54 */ 55 #define VPU_ENGINE_COMPUTE 0 56 #define VPU_ENGINE_COPY 1 57 #define VPU_ENGINE_NB 2 58 59 /* 60 * VPU status values. 61 */ 62 #define VPU_JSM_STATUS_SUCCESS 0x0U 63 #define VPU_JSM_STATUS_PARSING_ERR 0x1U 64 #define VPU_JSM_STATUS_PROCESSING_ERR 0x2U 65 #define VPU_JSM_STATUS_PREEMPTED 0x3U 66 #define VPU_JSM_STATUS_ABORTED 0x4U 67 #define VPU_JSM_STATUS_USER_CTX_VIOL_ERR 0x5U 68 #define VPU_JSM_STATUS_GLOBAL_CTX_VIOL_ERR 0x6U 69 #define VPU_JSM_STATUS_MVNCI_WRONG_INPUT_FORMAT 0x7U 70 #define VPU_JSM_STATUS_MVNCI_UNSUPPORTED_NETWORK_ELEMENT 0x8U 71 #define VPU_JSM_STATUS_MVNCI_INVALID_HANDLE 0x9U 72 #define VPU_JSM_STATUS_MVNCI_OUT_OF_RESOURCES 0xAU 73 #define VPU_JSM_STATUS_MVNCI_NOT_IMPLEMENTED 0xBU 74 #define VPU_JSM_STATUS_MVNCI_INTERNAL_ERROR 0xCU 75 /* Job status returned when the job was preempted mid-inference */ 76 #define VPU_JSM_STATUS_PREEMPTED_MID_INFERENCE 0xDU 77 78 /* 79 * Host <-> VPU IPC channels. 80 * ASYNC commands use a high priority channel, other messages use low-priority ones. 81 */ 82 #define VPU_IPC_CHAN_ASYNC_CMD 0 83 #define VPU_IPC_CHAN_GEN_CMD 10 84 #define VPU_IPC_CHAN_JOB_RET 11 85 86 /* 87 * Job flags bit masks. 88 */ 89 #define VPU_JOB_FLAGS_NULL_SUBMISSION_MASK 0x00000001 90 #define VPU_JOB_FLAGS_PRIVATE_DATA_MASK 0xFF000000 91 92 /* 93 * Sizes of the reserved areas in jobs, in bytes. 94 */ 95 #define VPU_JOB_RESERVED_BYTES 8 96 97 /* 98 * Sizes of the reserved areas in job queues, in bytes. 99 */ 100 #define VPU_JOB_QUEUE_RESERVED_BYTES 52 101 102 /* 103 * Max length (including trailing NULL char) of trace entity name (e.g., the 104 * name of a logging destination or a loggable HW component). 105 */ 106 #define VPU_TRACE_ENTITY_NAME_MAX_LEN 32 107 108 /* 109 * Max length (including trailing NULL char) of a dyndbg command. 110 * 111 * NOTE: 96 is used so that the size of 'struct vpu_ipc_msg' in the JSM API is 112 * 128 bytes (multiple of 64 bytes, the cache line size). 113 */ 114 #define VPU_DYNDBG_CMD_MAX_LEN 96 115 116 /* 117 * For HWS command queue scheduling, we can prioritise command queues inside the 118 * same process with a relative in-process priority. Valid values for relative 119 * priority are given below - max and min. 120 */ 121 #define VPU_HWS_COMMAND_QUEUE_MAX_IN_PROCESS_PRIORITY 7 122 #define VPU_HWS_COMMAND_QUEUE_MIN_IN_PROCESS_PRIORITY -7 123 124 /* 125 * For HWS priority scheduling, we can have multiple realtime priority bands. 126 * They are numbered 0 to a MAX. 127 */ 128 #define VPU_HWS_MAX_REALTIME_PRIORITY_LEVEL 31U 129 130 /* 131 * vpu_jsm_engine_reset_context flag definitions 132 */ 133 #define VPU_ENGINE_RESET_CONTEXT_FLAG_COLLATERAL_DAMAGE_MASK BIT(0) 134 #define VPU_ENGINE_RESET_CONTEXT_HANG_PRIMARY_CAUSE 0 135 #define VPU_ENGINE_RESET_CONTEXT_COLLATERAL_DAMAGE 1 136 137 /* 138 * Invalid command queue handle identifier. Applies to cmdq_id and cmdq_group 139 * in this API. 140 */ 141 #define VPU_HWS_INVALID_CMDQ_HANDLE 0ULL 142 143 /* 144 * Job format. 145 */ 146 struct vpu_job_queue_entry { 147 u64 batch_buf_addr; /**< Address of VPU commands batch buffer */ 148 u32 job_id; /**< Job ID */ 149 u32 flags; /**< Flags bit field, see VPU_JOB_FLAGS_* above */ 150 u64 root_page_table_addr; /**< Address of root page table to use for this job */ 151 u64 root_page_table_update_counter; /**< Page tables update events counter */ 152 u64 primary_preempt_buf_addr; 153 /**< Address of the primary preemption buffer to use for this job */ 154 u32 primary_preempt_buf_size; 155 /**< Size of the primary preemption buffer to use for this job */ 156 u32 secondary_preempt_buf_size; 157 /**< Size of secondary preemption buffer to use for this job */ 158 u64 secondary_preempt_buf_addr; 159 /**< Address of secondary preemption buffer to use for this job */ 160 u8 reserved_0[VPU_JOB_RESERVED_BYTES]; 161 }; 162 163 /* 164 * Job queue control registers. 165 */ 166 struct vpu_job_queue_header { 167 u32 engine_idx; 168 u32 head; 169 u32 tail; 170 u8 reserved_0[VPU_JOB_QUEUE_RESERVED_BYTES]; 171 }; 172 173 /* 174 * Job queue format. 175 */ 176 struct vpu_job_queue { 177 struct vpu_job_queue_header header; 178 struct vpu_job_queue_entry job[]; 179 }; 180 181 /** 182 * Logging entity types. 183 * 184 * This enum defines the different types of entities involved in logging. 185 */ 186 enum vpu_trace_entity_type { 187 /** Logging destination (entity where logs can be stored / printed). */ 188 VPU_TRACE_ENTITY_TYPE_DESTINATION = 1, 189 /** Loggable HW component (HW entity that can be logged). */ 190 VPU_TRACE_ENTITY_TYPE_HW_COMPONENT = 2, 191 }; 192 193 /* 194 * HWS specific log buffer header details. 195 * Total size is 32 bytes. 196 */ 197 struct vpu_hws_log_buffer_header { 198 /* Written by VPU after adding a log entry. Initialised by host to 0. */ 199 u32 first_free_entry_index; 200 /* Incremented by VPU every time the VPU overwrites the 0th entry; 201 * initialised by host to 0. 202 */ 203 u32 wraparound_count; 204 /* 205 * This is the number of buffers that can be stored in the log buffer provided by the host. 206 * It is written by host before passing buffer to VPU. VPU should consider it read-only. 207 */ 208 u64 num_of_entries; 209 u64 reserved[2]; 210 }; 211 212 /* 213 * HWS specific log buffer entry details. 214 * Total size is 32 bytes. 215 */ 216 struct vpu_hws_log_buffer_entry { 217 /* VPU timestamp must be an invariant timer tick (not impacted by DVFS) */ 218 u64 vpu_timestamp; 219 /* 220 * Operation type: 221 * 0 - context state change 222 * 1 - queue new work 223 * 2 - queue unwait sync object 224 * 3 - queue no more work 225 * 4 - queue wait sync object 226 */ 227 u32 operation_type; 228 u32 reserved; 229 /* Operation data depends on operation type */ 230 u64 operation_data[2]; 231 }; 232 233 /* 234 * Host <-> VPU IPC messages types. 235 */ 236 enum vpu_ipc_msg_type { 237 VPU_JSM_MSG_UNKNOWN = 0xFFFFFFFF, 238 /* IPC Host -> Device, Async commands */ 239 VPU_JSM_MSG_ASYNC_CMD = 0x1100, 240 VPU_JSM_MSG_ENGINE_RESET = VPU_JSM_MSG_ASYNC_CMD, 241 VPU_JSM_MSG_ENGINE_PREEMPT = 0x1101, 242 VPU_JSM_MSG_REGISTER_DB = 0x1102, 243 VPU_JSM_MSG_UNREGISTER_DB = 0x1103, 244 VPU_JSM_MSG_QUERY_ENGINE_HB = 0x1104, 245 VPU_JSM_MSG_GET_POWER_LEVEL_COUNT = 0x1105, 246 VPU_JSM_MSG_GET_POWER_LEVEL = 0x1106, 247 VPU_JSM_MSG_SET_POWER_LEVEL = 0x1107, 248 /* @deprecated */ 249 VPU_JSM_MSG_METRIC_STREAMER_OPEN = 0x1108, 250 /* @deprecated */ 251 VPU_JSM_MSG_METRIC_STREAMER_CLOSE = 0x1109, 252 /** Configure logging (used to modify configuration passed in boot params). */ 253 VPU_JSM_MSG_TRACE_SET_CONFIG = 0x110a, 254 /** Return current logging configuration. */ 255 VPU_JSM_MSG_TRACE_GET_CONFIG = 0x110b, 256 /** 257 * Get masks of destinations and HW components supported by the firmware 258 * (may vary between HW generations and FW compile 259 * time configurations) 260 */ 261 VPU_JSM_MSG_TRACE_GET_CAPABILITY = 0x110c, 262 /** Get the name of a destination or HW component. */ 263 VPU_JSM_MSG_TRACE_GET_NAME = 0x110d, 264 /** 265 * Release resource associated with host ssid . All jobs that belong to the host_ssid 266 * aborted and removed from internal scheduling queues. All doorbells assigned 267 * to the host_ssid are unregistered and any internal FW resources belonging to 268 * the host_ssid are released. 269 */ 270 VPU_JSM_MSG_SSID_RELEASE = 0x110e, 271 /** 272 * Start collecting metric data. 273 * @see vpu_jsm_metric_streamer_start 274 */ 275 VPU_JSM_MSG_METRIC_STREAMER_START = 0x110f, 276 /** 277 * Stop collecting metric data. This command will return success if it is called 278 * for a metric stream that has already been stopped or was never started. 279 * @see vpu_jsm_metric_streamer_stop 280 */ 281 VPU_JSM_MSG_METRIC_STREAMER_STOP = 0x1110, 282 /** 283 * Update current and next buffer for metric data collection. This command can 284 * also be used to request information about the number of collected samples 285 * and the amount of data written to the buffer. 286 * @see vpu_jsm_metric_streamer_update 287 */ 288 VPU_JSM_MSG_METRIC_STREAMER_UPDATE = 0x1111, 289 /** 290 * Request description of selected metric groups and metric counters within 291 * each group. The VPU will write the description of groups and counters to 292 * the buffer specified in the command structure. 293 * @see vpu_jsm_metric_streamer_start 294 */ 295 VPU_JSM_MSG_METRIC_STREAMER_INFO = 0x1112, 296 /** Control command: Priority band setup */ 297 VPU_JSM_MSG_SET_PRIORITY_BAND_SETUP = 0x1113, 298 /** Control command: Create command queue */ 299 VPU_JSM_MSG_CREATE_CMD_QUEUE = 0x1114, 300 /** Control command: Destroy command queue */ 301 VPU_JSM_MSG_DESTROY_CMD_QUEUE = 0x1115, 302 /** Control command: Set context scheduling properties */ 303 VPU_JSM_MSG_SET_CONTEXT_SCHED_PROPERTIES = 0x1116, 304 /* 305 * Register a doorbell to notify VPU of new work. The doorbell may later be 306 * deallocated or reassigned to another context. 307 */ 308 VPU_JSM_MSG_HWS_REGISTER_DB = 0x1117, 309 /** Control command: Log buffer setting */ 310 VPU_JSM_MSG_HWS_SET_SCHEDULING_LOG = 0x1118, 311 /* Control command: Suspend command queue. */ 312 VPU_JSM_MSG_HWS_SUSPEND_CMDQ = 0x1119, 313 /* Control command: Resume command queue */ 314 VPU_JSM_MSG_HWS_RESUME_CMDQ = 0x111a, 315 /* Control command: Resume engine after reset */ 316 VPU_JSM_MSG_HWS_ENGINE_RESUME = 0x111b, 317 /* Control command: Enable survivability/DCT mode */ 318 VPU_JSM_MSG_DCT_ENABLE = 0x111c, 319 /* Control command: Disable survivability/DCT mode */ 320 VPU_JSM_MSG_DCT_DISABLE = 0x111d, 321 /** 322 * Dump VPU state. To be used for debug purposes only. 323 * NOTE: Please introduce new ASYNC commands before this one. * 324 */ 325 VPU_JSM_MSG_STATE_DUMP = 0x11FF, 326 /* IPC Host -> Device, General commands */ 327 VPU_JSM_MSG_GENERAL_CMD = 0x1200, 328 VPU_JSM_MSG_BLOB_DEINIT = VPU_JSM_MSG_GENERAL_CMD, 329 /** 330 * Control dyndbg behavior by executing a dyndbg command; equivalent to 331 * Linux command: `echo '<dyndbg_cmd>' > <debugfs>/dynamic_debug/control`. 332 */ 333 VPU_JSM_MSG_DYNDBG_CONTROL = 0x1201, 334 /** 335 * Perform the save procedure for the D0i3 entry 336 */ 337 VPU_JSM_MSG_PWR_D0I3_ENTER = 0x1202, 338 /* IPC Device -> Host, Job completion */ 339 VPU_JSM_MSG_JOB_DONE = 0x2100, 340 /* IPC Device -> Host, Async command completion */ 341 VPU_JSM_MSG_ASYNC_CMD_DONE = 0x2200, 342 VPU_JSM_MSG_ENGINE_RESET_DONE = VPU_JSM_MSG_ASYNC_CMD_DONE, 343 VPU_JSM_MSG_ENGINE_PREEMPT_DONE = 0x2201, 344 VPU_JSM_MSG_REGISTER_DB_DONE = 0x2202, 345 VPU_JSM_MSG_UNREGISTER_DB_DONE = 0x2203, 346 VPU_JSM_MSG_QUERY_ENGINE_HB_DONE = 0x2204, 347 VPU_JSM_MSG_GET_POWER_LEVEL_COUNT_DONE = 0x2205, 348 VPU_JSM_MSG_GET_POWER_LEVEL_DONE = 0x2206, 349 VPU_JSM_MSG_SET_POWER_LEVEL_DONE = 0x2207, 350 /* @deprecated */ 351 VPU_JSM_MSG_METRIC_STREAMER_OPEN_DONE = 0x2208, 352 /* @deprecated */ 353 VPU_JSM_MSG_METRIC_STREAMER_CLOSE_DONE = 0x2209, 354 /** Response to VPU_JSM_MSG_TRACE_SET_CONFIG. */ 355 VPU_JSM_MSG_TRACE_SET_CONFIG_RSP = 0x220a, 356 /** Response to VPU_JSM_MSG_TRACE_GET_CONFIG. */ 357 VPU_JSM_MSG_TRACE_GET_CONFIG_RSP = 0x220b, 358 /** Response to VPU_JSM_MSG_TRACE_GET_CAPABILITY. */ 359 VPU_JSM_MSG_TRACE_GET_CAPABILITY_RSP = 0x220c, 360 /** Response to VPU_JSM_MSG_TRACE_GET_NAME. */ 361 VPU_JSM_MSG_TRACE_GET_NAME_RSP = 0x220d, 362 /** Response to VPU_JSM_MSG_SSID_RELEASE. */ 363 VPU_JSM_MSG_SSID_RELEASE_DONE = 0x220e, 364 /** 365 * Response to VPU_JSM_MSG_METRIC_STREAMER_START. 366 * VPU will return an error result if metric collection cannot be started, 367 * e.g. when the specified metric mask is invalid. 368 * @see vpu_jsm_metric_streamer_done 369 */ 370 VPU_JSM_MSG_METRIC_STREAMER_START_DONE = 0x220f, 371 /** 372 * Response to VPU_JSM_MSG_METRIC_STREAMER_STOP. 373 * Returns information about collected metric data. 374 * @see vpu_jsm_metric_streamer_done 375 */ 376 VPU_JSM_MSG_METRIC_STREAMER_STOP_DONE = 0x2210, 377 /** 378 * Response to VPU_JSM_MSG_METRIC_STREAMER_UPDATE. 379 * Returns information about collected metric data. 380 * @see vpu_jsm_metric_streamer_done 381 */ 382 VPU_JSM_MSG_METRIC_STREAMER_UPDATE_DONE = 0x2211, 383 /** 384 * Response to VPU_JSM_MSG_METRIC_STREAMER_INFO. 385 * Returns a description of the metric groups and metric counters. 386 * @see vpu_jsm_metric_streamer_done 387 */ 388 VPU_JSM_MSG_METRIC_STREAMER_INFO_DONE = 0x2212, 389 /** 390 * Asynchronous event sent from the VPU to the host either when the current 391 * metric buffer is full or when the VPU has collected a multiple of 392 * @notify_sample_count samples as indicated through the start command 393 * (VPU_JSM_MSG_METRIC_STREAMER_START). Returns information about collected 394 * metric data. 395 * @see vpu_jsm_metric_streamer_done 396 */ 397 VPU_JSM_MSG_METRIC_STREAMER_NOTIFICATION = 0x2213, 398 /** Response to control command: Priority band setup */ 399 VPU_JSM_MSG_SET_PRIORITY_BAND_SETUP_RSP = 0x2214, 400 /** Response to control command: Create command queue */ 401 VPU_JSM_MSG_CREATE_CMD_QUEUE_RSP = 0x2215, 402 /** Response to control command: Destroy command queue */ 403 VPU_JSM_MSG_DESTROY_CMD_QUEUE_RSP = 0x2216, 404 /** Response to control command: Set context scheduling properties */ 405 VPU_JSM_MSG_SET_CONTEXT_SCHED_PROPERTIES_RSP = 0x2217, 406 /** Response to control command: Log buffer setting */ 407 VPU_JSM_MSG_HWS_SET_SCHEDULING_LOG_RSP = 0x2218, 408 /* IPC Device -> Host, HWS notify index entry of log buffer written */ 409 VPU_JSM_MSG_HWS_SCHEDULING_LOG_NOTIFICATION = 0x2219, 410 /* IPC Device -> Host, HWS completion of a context suspend request */ 411 VPU_JSM_MSG_HWS_SUSPEND_CMDQ_DONE = 0x221a, 412 /* Response to control command: Resume command queue */ 413 VPU_JSM_MSG_HWS_RESUME_CMDQ_RSP = 0x221b, 414 /* Response to control command: Resume engine command response */ 415 VPU_JSM_MSG_HWS_RESUME_ENGINE_DONE = 0x221c, 416 /* Response to control command: Enable survivability/DCT mode */ 417 VPU_JSM_MSG_DCT_ENABLE_DONE = 0x221d, 418 /* Response to control command: Disable survivability/DCT mode */ 419 VPU_JSM_MSG_DCT_DISABLE_DONE = 0x221e, 420 /** 421 * Response to state dump control command. 422 * NOTE: Please introduce new ASYNC responses before this one. * 423 */ 424 VPU_JSM_MSG_STATE_DUMP_RSP = 0x22FF, 425 /* IPC Device -> Host, General command completion */ 426 VPU_JSM_MSG_GENERAL_CMD_DONE = 0x2300, 427 VPU_JSM_MSG_BLOB_DEINIT_DONE = VPU_JSM_MSG_GENERAL_CMD_DONE, 428 /** Response to VPU_JSM_MSG_DYNDBG_CONTROL. */ 429 VPU_JSM_MSG_DYNDBG_CONTROL_RSP = 0x2301, 430 /** 431 * Acknowledgment of completion of the save procedure initiated by 432 * VPU_JSM_MSG_PWR_D0I3_ENTER 433 */ 434 VPU_JSM_MSG_PWR_D0I3_ENTER_DONE = 0x2302, 435 }; 436 437 enum vpu_ipc_msg_status { VPU_JSM_MSG_FREE, VPU_JSM_MSG_ALLOCATED }; 438 439 /* 440 * Host <-> LRT IPC message payload definitions 441 */ 442 struct vpu_ipc_msg_payload_engine_reset { 443 /* Engine to be reset. */ 444 u32 engine_idx; 445 /* Reserved */ 446 u32 reserved_0; 447 }; 448 449 struct vpu_ipc_msg_payload_engine_preempt { 450 /* Engine to be preempted. */ 451 u32 engine_idx; 452 /* ID of the preemption request. */ 453 u32 preempt_id; 454 }; 455 456 /* 457 * @brief Register doorbell command structure. 458 * This structure supports doorbell registration for only OS scheduling. 459 * @see VPU_JSM_MSG_REGISTER_DB 460 */ 461 struct vpu_ipc_msg_payload_register_db { 462 /* Index of the doorbell to register. */ 463 u32 db_idx; 464 /* Reserved */ 465 u32 reserved_0; 466 /* Virtual address in Global GTT pointing to the start of job queue. */ 467 u64 jobq_base; 468 /* Size of the job queue in bytes. */ 469 u32 jobq_size; 470 /* Host sub-stream ID for the context assigned to the doorbell. */ 471 u32 host_ssid; 472 }; 473 474 /** 475 * @brief Unregister doorbell command structure. 476 * Request structure to unregister a doorbell for both HW and OS scheduling. 477 * @see VPU_JSM_MSG_UNREGISTER_DB 478 */ 479 struct vpu_ipc_msg_payload_unregister_db { 480 /* Index of the doorbell to unregister. */ 481 u32 db_idx; 482 /* Reserved */ 483 u32 reserved_0; 484 }; 485 486 struct vpu_ipc_msg_payload_query_engine_hb { 487 /* Engine to return heartbeat value. */ 488 u32 engine_idx; 489 /* Reserved */ 490 u32 reserved_0; 491 }; 492 493 struct vpu_ipc_msg_payload_power_level { 494 /** 495 * Requested power level. The power level value is in the 496 * range [0, power_level_count-1] where power_level_count 497 * is the number of available power levels as returned by 498 * the get power level count command. A power level of 0 499 * corresponds to the maximum possible power level, while 500 * power_level_count-1 corresponds to the minimum possible 501 * power level. Values outside of this range are not 502 * considered to be valid. 503 */ 504 u32 power_level; 505 /* Reserved */ 506 u32 reserved_0; 507 }; 508 509 struct vpu_ipc_msg_payload_ssid_release { 510 /* Host sub-stream ID for the context to be released. */ 511 u32 host_ssid; 512 /* Reserved */ 513 u32 reserved_0; 514 }; 515 516 /** 517 * @brief Metric streamer start command structure. 518 * This structure is also used with VPU_JSM_MSG_METRIC_STREAMER_INFO to request metric 519 * groups and metric counters description from the firmware. 520 * @see VPU_JSM_MSG_METRIC_STREAMER_START 521 * @see VPU_JSM_MSG_METRIC_STREAMER_INFO 522 */ 523 struct vpu_jsm_metric_streamer_start { 524 /** 525 * Bitmask to select the desired metric groups. 526 * A metric group can belong only to one metric streamer instance at a time. 527 * Since each metric streamer instance has a unique set of metric groups, it 528 * can also identify a metric streamer instance if more than one instance was 529 * started. If the VPU device does not support multiple metric streamer instances, 530 * then VPU_JSM_MSG_METRIC_STREAMER_START will return an error even if the second 531 * instance has different groups to the first. 532 */ 533 u64 metric_group_mask; 534 /** Sampling rate in nanoseconds. */ 535 u64 sampling_rate; 536 /** 537 * If > 0 the VPU will send a VPU_JSM_MSG_METRIC_STREAMER_NOTIFICATION message 538 * after every @notify_sample_count samples is collected or dropped by the VPU. 539 * If set to UINT_MAX the VPU will only generate a notification when the metric 540 * buffer is full. If set to 0 the VPU will never generate a notification. 541 */ 542 u32 notify_sample_count; 543 u32 reserved_0; 544 /** 545 * Address and size of the buffer where the VPU will write metric data. The 546 * VPU writes all counters from enabled metric groups one after another. If 547 * there is no space left to write data at the next sample period the VPU 548 * will switch to the next buffer (@see next_buffer_addr) and will optionally 549 * send a notification to the host driver if @notify_sample_count is non-zero. 550 * If @next_buffer_addr is NULL the VPU will stop collecting metric data. 551 */ 552 u64 buffer_addr; 553 u64 buffer_size; 554 /** 555 * Address and size of the next buffer to write metric data to after the initial 556 * buffer is full. If the address is NULL the VPU will stop collecting metric 557 * data. 558 */ 559 u64 next_buffer_addr; 560 u64 next_buffer_size; 561 }; 562 563 /** 564 * @brief Metric streamer stop command structure. 565 * @see VPU_JSM_MSG_METRIC_STREAMER_STOP 566 */ 567 struct vpu_jsm_metric_streamer_stop { 568 /** Bitmask to select the desired metric groups. */ 569 u64 metric_group_mask; 570 }; 571 572 /** 573 * Provide VPU FW with buffers to write metric data. 574 * @see VPU_JSM_MSG_METRIC_STREAMER_UPDATE 575 */ 576 struct vpu_jsm_metric_streamer_update { 577 /** Metric group mask that identifies metric streamer instance. */ 578 u64 metric_group_mask; 579 /** 580 * Address and size of the buffer where the VPU will write metric data. If 581 * the buffer address is 0 or same as the currently used buffer the VPU will 582 * continue writing metric data to the current buffer. In this case the 583 * buffer size is ignored and the size of the current buffer is unchanged. 584 * If the address is non-zero and differs from the current buffer address the 585 * VPU will immediately switch data collection to the new buffer. 586 */ 587 u64 buffer_addr; 588 u64 buffer_size; 589 /** 590 * Address and size of the next buffer to write metric data after the initial 591 * buffer is full. If the address is NULL the VPU will stop collecting metric 592 * data but will continue to record dropped samples. 593 * 594 * Note that there is a hazard possible if both buffer_addr and the next_buffer_addr 595 * are non-zero in same update request. It is the host's responsibility to ensure 596 * that both addresses make sense even if the VPU just switched to writing samples 597 * from the current to the next buffer. 598 */ 599 u64 next_buffer_addr; 600 u64 next_buffer_size; 601 }; 602 603 struct vpu_ipc_msg_payload_blob_deinit { 604 /* 64-bit unique ID for the blob to be de-initialized. */ 605 u64 blob_id; 606 }; 607 608 struct vpu_ipc_msg_payload_job_done { 609 /* Engine to which the job was submitted. */ 610 u32 engine_idx; 611 /* Index of the doorbell to which the job was submitted */ 612 u32 db_idx; 613 /* ID of the completed job */ 614 u32 job_id; 615 /* Status of the completed job */ 616 u32 job_status; 617 /* Host SSID */ 618 u32 host_ssid; 619 /* Zero Padding */ 620 u32 reserved_0; 621 /* Command queue id */ 622 u64 cmdq_id; 623 }; 624 625 struct vpu_jsm_engine_reset_context { 626 /* Host SSID */ 627 u32 host_ssid; 628 /* Zero Padding */ 629 u32 reserved_0; 630 /* Command queue id */ 631 u64 cmdq_id; 632 /* See VPU_ENGINE_RESET_CONTEXT_* defines */ 633 u64 flags; 634 }; 635 636 struct vpu_ipc_msg_payload_engine_reset_done { 637 /* Engine ordinal */ 638 u32 engine_idx; 639 /* Number of impacted contexts */ 640 u32 num_impacted_contexts; 641 /* Array of impacted command queue ids and their flags */ 642 struct vpu_jsm_engine_reset_context 643 impacted_contexts[VPU_MAX_ENGINE_RESET_IMPACTED_CONTEXTS]; 644 }; 645 646 struct vpu_ipc_msg_payload_engine_preempt_done { 647 /* Engine preempted. */ 648 u32 engine_idx; 649 /* ID of the preemption request. */ 650 u32 preempt_id; 651 }; 652 653 /** 654 * Response structure for register doorbell command for both OS 655 * and HW scheduling. 656 * @see VPU_JSM_MSG_REGISTER_DB 657 * @see VPU_JSM_MSG_HWS_REGISTER_DB 658 */ 659 struct vpu_ipc_msg_payload_register_db_done { 660 /* Index of the registered doorbell. */ 661 u32 db_idx; 662 /* Reserved */ 663 u32 reserved_0; 664 }; 665 666 /** 667 * Response structure for unregister doorbell command for both OS 668 * and HW scheduling. 669 * @see VPU_JSM_MSG_UNREGISTER_DB 670 */ 671 struct vpu_ipc_msg_payload_unregister_db_done { 672 /* Index of the unregistered doorbell. */ 673 u32 db_idx; 674 /* Reserved */ 675 u32 reserved_0; 676 }; 677 678 struct vpu_ipc_msg_payload_query_engine_hb_done { 679 /* Engine returning heartbeat value. */ 680 u32 engine_idx; 681 /* Reserved */ 682 u32 reserved_0; 683 /* Heartbeat value. */ 684 u64 heartbeat; 685 }; 686 687 struct vpu_ipc_msg_payload_get_power_level_count_done { 688 /** 689 * Number of supported power levels. The maximum possible 690 * value of power_level_count is 16 but this may vary across 691 * implementations. 692 */ 693 u32 power_level_count; 694 /* Reserved */ 695 u32 reserved_0; 696 /** 697 * Power consumption limit for each supported power level in 698 * [0-100%] range relative to power level 0. 699 */ 700 u8 power_limit[16]; 701 }; 702 703 struct vpu_ipc_msg_payload_blob_deinit_done { 704 /* 64-bit unique ID for the blob de-initialized. */ 705 u64 blob_id; 706 }; 707 708 /* HWS priority band setup request / response */ 709 struct vpu_ipc_msg_payload_hws_priority_band_setup { 710 /* 711 * Grace period in 100ns units when preempting another priority band for 712 * this priority band 713 */ 714 u32 grace_period[VPU_HWS_NUM_PRIORITY_BANDS]; 715 /* 716 * Default quantum in 100ns units for scheduling across processes 717 * within a priority band 718 */ 719 u32 process_quantum[VPU_HWS_NUM_PRIORITY_BANDS]; 720 /* 721 * Default grace period in 100ns units for processes that preempt each 722 * other within a priority band 723 */ 724 u32 process_grace_period[VPU_HWS_NUM_PRIORITY_BANDS]; 725 /* 726 * For normal priority band, specifies the target VPU percentage 727 * in situations when it's starved by the focus band. 728 */ 729 u32 normal_band_percentage; 730 /* Reserved */ 731 u32 reserved_0; 732 }; 733 734 /* 735 * @brief HWS create command queue request. 736 * Host will create a command queue via this command. 737 * Note: Cmdq group is a handle of an object which 738 * may contain one or more command queues. 739 * @see VPU_JSM_MSG_CREATE_CMD_QUEUE 740 * @see VPU_JSM_MSG_CREATE_CMD_QUEUE_RSP 741 */ 742 struct vpu_ipc_msg_payload_hws_create_cmdq { 743 /* Process id */ 744 u64 process_id; 745 /* Host SSID */ 746 u32 host_ssid; 747 /* Engine for which queue is being created */ 748 u32 engine_idx; 749 /* Cmdq group: only used for HWS logging of state changes */ 750 u64 cmdq_group; 751 /* Command queue id */ 752 u64 cmdq_id; 753 /* Command queue base */ 754 u64 cmdq_base; 755 /* Command queue size */ 756 u32 cmdq_size; 757 /* Zero padding */ 758 u32 reserved_0; 759 }; 760 761 /* 762 * @brief HWS create command queue response. 763 * @see VPU_JSM_MSG_CREATE_CMD_QUEUE 764 * @see VPU_JSM_MSG_CREATE_CMD_QUEUE_RSP 765 */ 766 struct vpu_ipc_msg_payload_hws_create_cmdq_rsp { 767 /* Process id */ 768 u64 process_id; 769 /* Host SSID */ 770 u32 host_ssid; 771 /* Engine for which queue is being created */ 772 u32 engine_idx; 773 /* Command queue group */ 774 u64 cmdq_group; 775 /* Command queue id */ 776 u64 cmdq_id; 777 }; 778 779 /* HWS destroy command queue request / response */ 780 struct vpu_ipc_msg_payload_hws_destroy_cmdq { 781 /* Host SSID */ 782 u32 host_ssid; 783 /* Zero Padding */ 784 u32 reserved; 785 /* Command queue id */ 786 u64 cmdq_id; 787 }; 788 789 /* HWS set context scheduling properties request / response */ 790 struct vpu_ipc_msg_payload_hws_set_context_sched_properties { 791 /* Host SSID */ 792 u32 host_ssid; 793 /* Zero Padding */ 794 u32 reserved_0; 795 /* Command queue id */ 796 u64 cmdq_id; 797 /* Priority band to assign to work of this context */ 798 u32 priority_band; 799 /* Inside realtime band assigns a further priority */ 800 u32 realtime_priority_level; 801 /* Priority relative to other contexts in the same process */ 802 s32 in_process_priority; 803 /* Zero padding / Reserved */ 804 u32 reserved_1; 805 /* Context quantum relative to other contexts of same priority in the same process */ 806 u64 context_quantum; 807 /* Grace period when preempting context of the same priority within the same process */ 808 u64 grace_period_same_priority; 809 /* Grace period when preempting context of a lower priority within the same process */ 810 u64 grace_period_lower_priority; 811 }; 812 813 /* 814 * @brief Register doorbell command structure. 815 * This structure supports doorbell registration for both HW and OS scheduling. 816 * Note: Queue base and size are added here so that the same structure can be used for 817 * OS scheduling and HW scheduling. For OS scheduling, cmdq_id will be ignored 818 * and cmdq_base and cmdq_size will be used. For HW scheduling, cmdq_base and cmdq_size will be 819 * ignored and cmdq_id is used. 820 * @see VPU_JSM_MSG_HWS_REGISTER_DB 821 */ 822 struct vpu_jsm_hws_register_db { 823 /* Index of the doorbell to register. */ 824 u32 db_id; 825 /* Host sub-stream ID for the context assigned to the doorbell. */ 826 u32 host_ssid; 827 /* ID of the command queue associated with the doorbell. */ 828 u64 cmdq_id; 829 /* Virtual address pointing to the start of command queue. */ 830 u64 cmdq_base; 831 /* Size of the command queue in bytes. */ 832 u64 cmdq_size; 833 }; 834 835 /* 836 * @brief Structure to set another buffer to be used for scheduling-related logging. 837 * The size of the logging buffer and the number of entries is defined as part of the 838 * buffer itself as described next. 839 * The log buffer received from the host is made up of; 840 * - header: 32 bytes in size, as shown in 'struct vpu_hws_log_buffer_header'. 841 * The header contains the number of log entries in the buffer. 842 * - log entry: 0 to n-1, each log entry is 32 bytes in size, as shown in 843 * 'struct vpu_hws_log_buffer_entry'. 844 * The entry contains the VPU timestamp, operation type and data. 845 * The host should provide the notify index value of log buffer to VPU. This is a 846 * value defined within the log buffer and when written to will generate the 847 * scheduling log notification. 848 * The host should set engine_idx and vpu_log_buffer_va to 0 to disable logging 849 * for a particular engine. 850 * VPU will handle one log buffer for each of supported engines. 851 * VPU should allow the logging to consume one host_ssid. 852 * @see VPU_JSM_MSG_HWS_SET_SCHEDULING_LOG 853 * @see VPU_JSM_MSG_HWS_SET_SCHEDULING_LOG_RSP 854 * @see VPU_JSM_MSG_HWS_SCHEDULING_LOG_NOTIFICATION 855 */ 856 struct vpu_ipc_msg_payload_hws_set_scheduling_log { 857 /* Engine ordinal */ 858 u32 engine_idx; 859 /* Host SSID */ 860 u32 host_ssid; 861 /* 862 * VPU log buffer virtual address. 863 * Set to 0 to disable logging for this engine. 864 */ 865 u64 vpu_log_buffer_va; 866 /* 867 * Notify index of log buffer. VPU_JSM_MSG_HWS_SCHEDULING_LOG_NOTIFICATION 868 * is generated when an event log is written to this index. 869 */ 870 u64 notify_index; 871 }; 872 873 /* 874 * @brief The scheduling log notification is generated by VPU when it writes 875 * an event into the log buffer at the notify_index. VPU notifies host with 876 * VPU_JSM_MSG_HWS_SCHEDULING_LOG_NOTIFICATION. This is an asynchronous 877 * message from VPU to host. 878 * @see VPU_JSM_MSG_HWS_SCHEDULING_LOG_NOTIFICATION 879 * @see VPU_JSM_MSG_HWS_SET_SCHEDULING_LOG 880 */ 881 struct vpu_ipc_msg_payload_hws_scheduling_log_notification { 882 /* Engine ordinal */ 883 u32 engine_idx; 884 /* Zero Padding */ 885 u32 reserved_0; 886 }; 887 888 /* 889 * @brief HWS suspend command queue request and done structure. 890 * Host will request the suspend of contexts and VPU will; 891 * - Suspend all work on this context 892 * - Preempt any running work 893 * - Asynchronously perform the above and return success immediately once 894 * all items above are started successfully 895 * - Notify the host of completion of these operations via 896 * VPU_JSM_MSG_HWS_SUSPEND_CMDQ_DONE 897 * - Reject any other context operations on a context with an in-flight 898 * suspend request running 899 * Same structure used when VPU notifies host of completion of a context suspend 900 * request. The ids and suspend fence value reported in this command will match 901 * the one in the request from the host to suspend the context. Once suspend is 902 * complete, VPU will not access any data relating to this command queue until 903 * it is resumed. 904 * @see VPU_JSM_MSG_HWS_SUSPEND_CMDQ 905 * @see VPU_JSM_MSG_HWS_SUSPEND_CMDQ_DONE 906 */ 907 struct vpu_ipc_msg_payload_hws_suspend_cmdq { 908 /* Host SSID */ 909 u32 host_ssid; 910 /* Zero Padding */ 911 u32 reserved_0; 912 /* Command queue id */ 913 u64 cmdq_id; 914 /* 915 * Suspend fence value - reported by the VPU suspend context 916 * completed once suspend is complete. 917 */ 918 u64 suspend_fence_value; 919 }; 920 921 /* 922 * @brief HWS Resume command queue request / response structure. 923 * Host will request the resume of a context; 924 * - VPU will resume all work on this context 925 * - Scheduler will allow this context to be scheduled 926 * @see VPU_JSM_MSG_HWS_RESUME_CMDQ 927 * @see VPU_JSM_MSG_HWS_RESUME_CMDQ_RSP 928 */ 929 struct vpu_ipc_msg_payload_hws_resume_cmdq { 930 /* Host SSID */ 931 u32 host_ssid; 932 /* Zero Padding */ 933 u32 reserved_0; 934 /* Command queue id */ 935 u64 cmdq_id; 936 }; 937 938 /* 939 * @brief HWS Resume engine request / response structure. 940 * After a HWS engine reset, all scheduling is stopped on VPU until a engine resume. 941 * Host shall send this command to resume scheduling of any valid queue. 942 * @see VPU_JSM_MSG_HWS_RESUME_ENGINE 943 * @see VPU_JSM_MSG_HWS_RESUME_ENGINE_DONE 944 */ 945 struct vpu_ipc_msg_payload_hws_resume_engine { 946 /* Engine to be resumed */ 947 u32 engine_idx; 948 /* Reserved */ 949 u32 reserved_0; 950 }; 951 952 /** 953 * Payload for VPU_JSM_MSG_TRACE_SET_CONFIG[_RSP] and 954 * VPU_JSM_MSG_TRACE_GET_CONFIG_RSP messages. 955 * 956 * The payload is interpreted differently depending on the type of message: 957 * 958 * - For VPU_JSM_MSG_TRACE_SET_CONFIG, the payload specifies the desired 959 * logging configuration to be set. 960 * 961 * - For VPU_JSM_MSG_TRACE_SET_CONFIG_RSP, the payload reports the logging 962 * configuration that was set after a VPU_JSM_MSG_TRACE_SET_CONFIG request. 963 * The host can compare this payload with the one it sent in the 964 * VPU_JSM_MSG_TRACE_SET_CONFIG request to check whether or not the 965 * configuration was set as desired. 966 * 967 * - VPU_JSM_MSG_TRACE_GET_CONFIG_RSP, the payload reports the current logging 968 * configuration. 969 */ 970 struct vpu_ipc_msg_payload_trace_config { 971 /** 972 * Logging level (currently set or to be set); see 'mvLog_t' enum for 973 * acceptable values. The specified logging level applies to all 974 * destinations and HW components 975 */ 976 u32 trace_level; 977 /** 978 * Bitmask of logging destinations (currently enabled or to be enabled); 979 * bitwise OR of values defined in logging_destination enum. 980 */ 981 u32 trace_destination_mask; 982 /** 983 * Bitmask of loggable HW components (currently enabled or to be enabled); 984 * bitwise OR of values defined in loggable_hw_component enum. 985 */ 986 u64 trace_hw_component_mask; 987 u64 reserved_0; /**< Reserved for future extensions. */ 988 }; 989 990 /** 991 * Payload for VPU_JSM_MSG_TRACE_GET_CAPABILITY_RSP messages. 992 */ 993 struct vpu_ipc_msg_payload_trace_capability_rsp { 994 u32 trace_destination_mask; /**< Bitmask of supported logging destinations. */ 995 u32 reserved_0; 996 u64 trace_hw_component_mask; /**< Bitmask of supported loggable HW components. */ 997 u64 reserved_1; /**< Reserved for future extensions. */ 998 }; 999 1000 /** 1001 * Payload for VPU_JSM_MSG_TRACE_GET_NAME requests. 1002 */ 1003 struct vpu_ipc_msg_payload_trace_get_name { 1004 /** 1005 * The type of the entity to query name for; see logging_entity_type for 1006 * possible values. 1007 */ 1008 u32 entity_type; 1009 u32 reserved_0; 1010 /** 1011 * The ID of the entity to query name for; possible values depends on the 1012 * entity type. 1013 */ 1014 u64 entity_id; 1015 }; 1016 1017 /** 1018 * Payload for VPU_JSM_MSG_TRACE_GET_NAME_RSP responses. 1019 */ 1020 struct vpu_ipc_msg_payload_trace_get_name_rsp { 1021 /** 1022 * The type of the entity whose name was queried; see logging_entity_type 1023 * for possible values. 1024 */ 1025 u32 entity_type; 1026 u32 reserved_0; 1027 /** 1028 * The ID of the entity whose name was queried; possible values depends on 1029 * the entity type. 1030 */ 1031 u64 entity_id; 1032 /** Reserved for future extensions. */ 1033 u64 reserved_1; 1034 /** The name of the entity. */ 1035 char entity_name[VPU_TRACE_ENTITY_NAME_MAX_LEN]; 1036 }; 1037 1038 /** 1039 * Data sent from the VPU to the host in all metric streamer response messages 1040 * and in asynchronous notification. 1041 * @see VPU_JSM_MSG_METRIC_STREAMER_START_DONE 1042 * @see VPU_JSM_MSG_METRIC_STREAMER_STOP_DONE 1043 * @see VPU_JSM_MSG_METRIC_STREAMER_UPDATE_DONE 1044 * @see VPU_JSM_MSG_METRIC_STREAMER_INFO_DONE 1045 * @see VPU_JSM_MSG_METRIC_STREAMER_NOTIFICATION 1046 */ 1047 struct vpu_jsm_metric_streamer_done { 1048 /** Metric group mask that identifies metric streamer instance. */ 1049 u64 metric_group_mask; 1050 /** 1051 * Size in bytes of single sample - total size of all enabled counters. 1052 * Some VPU implementations may align sample_size to more than 8 bytes. 1053 */ 1054 u32 sample_size; 1055 u32 reserved_0; 1056 /** 1057 * Number of samples collected since the metric streamer was started. 1058 * This will be 0 if the metric streamer was not started. 1059 */ 1060 u32 samples_collected; 1061 /** 1062 * Number of samples dropped since the metric streamer was started. This 1063 * is incremented every time the metric streamer is not able to write 1064 * collected samples because the current buffer is full and there is no 1065 * next buffer to switch to. 1066 */ 1067 u32 samples_dropped; 1068 /** Address of the buffer that contains the latest metric data. */ 1069 u64 buffer_addr; 1070 /** 1071 * Number of bytes written into the metric data buffer. In response to the 1072 * VPU_JSM_MSG_METRIC_STREAMER_INFO request this field contains the size of 1073 * all group and counter descriptors. The size is updated even if the buffer 1074 * in the request was NULL or too small to hold descriptors of all counters 1075 */ 1076 u64 bytes_written; 1077 }; 1078 1079 /** 1080 * Metric group description placed in the metric buffer after successful completion 1081 * of the VPU_JSM_MSG_METRIC_STREAMER_INFO command. This is followed by one or more 1082 * @vpu_jsm_metric_counter_descriptor records. 1083 * @see VPU_JSM_MSG_METRIC_STREAMER_INFO 1084 */ 1085 struct vpu_jsm_metric_group_descriptor { 1086 /** 1087 * Offset to the next metric group (8-byte aligned). If this offset is 0 this 1088 * is the last descriptor. The value of metric_info_size must be greater than 1089 * or equal to sizeof(struct vpu_jsm_metric_group_descriptor) + name_string_size 1090 * + description_string_size and must be 8-byte aligned. 1091 */ 1092 u32 next_metric_group_info_offset; 1093 /** 1094 * Offset to the first metric counter description record (8-byte aligned). 1095 * @see vpu_jsm_metric_counter_descriptor 1096 */ 1097 u32 next_metric_counter_info_offset; 1098 /** Index of the group. This corresponds to bit index in metric_group_mask. */ 1099 u32 group_id; 1100 /** Number of counters in the metric group. */ 1101 u32 num_counters; 1102 /** Data size for all counters, must be a multiple of 8 bytes.*/ 1103 u32 metric_group_data_size; 1104 /** 1105 * Metric group domain number. Cannot use multiple, simultaneous metric groups 1106 * from the same domain. 1107 */ 1108 u32 domain; 1109 /** 1110 * Counter name string size. The string must include a null termination character. 1111 * The FW may use a fixed size name or send a different name for each counter. 1112 * If the VPU uses fixed size strings, all characters from the end of the name 1113 * to the of the fixed size character array must be zeroed. 1114 */ 1115 u32 name_string_size; 1116 /** Counter description string size, @see name_string_size */ 1117 u32 description_string_size; 1118 u64 reserved_0; 1119 /** 1120 * Right after this structure, the VPU writes name and description of 1121 * the metric group. 1122 */ 1123 }; 1124 1125 /** 1126 * Metric counter description, placed in the buffer after vpu_jsm_metric_group_descriptor. 1127 * @see VPU_JSM_MSG_METRIC_STREAMER_INFO 1128 */ 1129 struct vpu_jsm_metric_counter_descriptor { 1130 /** 1131 * Offset to the next counter in a group (8-byte aligned). If this offset is 1132 * 0 this is the last counter in the group. 1133 */ 1134 u32 next_metric_counter_info_offset; 1135 /** 1136 * Offset to the counter data from the start of samples in this metric group. 1137 * Note that metric_data_offset % metric_data_size must be 0. 1138 */ 1139 u32 metric_data_offset; 1140 /** Size of the metric counter data in bytes. */ 1141 u32 metric_data_size; 1142 /** Metric type, see Level Zero API for definitions. */ 1143 u32 tier; 1144 /** Metric type, see set_metric_type_t for definitions. */ 1145 u32 metric_type; 1146 /** Metric type, see set_value_type_t for definitions. */ 1147 u32 metric_value_type; 1148 /** 1149 * Counter name string size. The string must include a null termination character. 1150 * The FW may use a fixed size name or send a different name for each counter. 1151 * If the VPU uses fixed size strings, all characters from the end of the name 1152 * to the of the fixed size character array must be zeroed. 1153 */ 1154 u32 name_string_size; 1155 /** Counter description string size, @see name_string_size */ 1156 u32 description_string_size; 1157 /** Counter component name string size, @see name_string_size */ 1158 u32 component_string_size; 1159 /** Counter string size, @see name_string_size */ 1160 u32 units_string_size; 1161 u64 reserved_0; 1162 /** 1163 * Right after this structure, the VPU writes name, description 1164 * component and unit strings. 1165 */ 1166 }; 1167 1168 /** 1169 * Payload for VPU_JSM_MSG_DYNDBG_CONTROL requests. 1170 * 1171 * VPU_JSM_MSG_DYNDBG_CONTROL are used to control the VPU FW Dynamic Debug 1172 * feature, which allows developers to selectively enable / disable MVLOG_DEBUG 1173 * messages. This is equivalent to the Dynamic Debug functionality provided by 1174 * Linux 1175 * (https://www.kernel.org/doc/html/latest/admin-guide/dynamic-debug-howto.html) 1176 * The host can control Dynamic Debug behavior by sending dyndbg commands, which 1177 * have the same syntax as Linux 1178 * dyndbg commands. 1179 * 1180 * NOTE: in order for MVLOG_DEBUG messages to be actually printed, the host 1181 * still has to set the logging level to MVLOG_DEBUG, using the 1182 * VPU_JSM_MSG_TRACE_SET_CONFIG command. 1183 * 1184 * The host can see the current dynamic debug configuration by executing a 1185 * special 'show' command. The dyndbg configuration will be printed to the 1186 * configured logging destination using MVLOG_INFO logging level. 1187 */ 1188 struct vpu_ipc_msg_payload_dyndbg_control { 1189 /** 1190 * Dyndbg command (same format as Linux dyndbg); must be a NULL-terminated 1191 * string. 1192 */ 1193 char dyndbg_cmd[VPU_DYNDBG_CMD_MAX_LEN]; 1194 }; 1195 1196 /** 1197 * Payload for VPU_JSM_MSG_PWR_D0I3_ENTER 1198 * 1199 * This is a bi-directional payload. 1200 */ 1201 struct vpu_ipc_msg_payload_pwr_d0i3_enter { 1202 /** 1203 * 0: VPU_JSM_MSG_PWR_D0I3_ENTER_DONE is not sent to the host driver 1204 * The driver will poll for D0i2 Idle state transitions. 1205 * 1: VPU_JSM_MSG_PWR_D0I3_ENTER_DONE is sent after VPU state save is complete 1206 */ 1207 u32 send_response; 1208 u32 reserved_0; 1209 }; 1210 1211 /** 1212 * Payload for VPU_JSM_MSG_DCT_ENABLE message. 1213 * 1214 * Default values for DCT active/inactive times are 5.3ms and 30ms respectively, 1215 * corresponding to a 85% duty cycle. This payload allows the host to tune these 1216 * values according to application requirements. 1217 */ 1218 struct vpu_ipc_msg_payload_pwr_dct_control { 1219 /** Duty cycle active time in microseconds */ 1220 u32 dct_active_us; 1221 /** Duty cycle inactive time in microseconds */ 1222 u32 dct_inactive_us; 1223 }; 1224 1225 /* 1226 * Payloads union, used to define complete message format. 1227 */ 1228 union vpu_ipc_msg_payload { 1229 struct vpu_ipc_msg_payload_engine_reset engine_reset; 1230 struct vpu_ipc_msg_payload_engine_preempt engine_preempt; 1231 struct vpu_ipc_msg_payload_register_db register_db; 1232 struct vpu_ipc_msg_payload_unregister_db unregister_db; 1233 struct vpu_ipc_msg_payload_query_engine_hb query_engine_hb; 1234 struct vpu_ipc_msg_payload_power_level power_level; 1235 struct vpu_jsm_metric_streamer_start metric_streamer_start; 1236 struct vpu_jsm_metric_streamer_stop metric_streamer_stop; 1237 struct vpu_jsm_metric_streamer_update metric_streamer_update; 1238 struct vpu_ipc_msg_payload_blob_deinit blob_deinit; 1239 struct vpu_ipc_msg_payload_ssid_release ssid_release; 1240 struct vpu_jsm_hws_register_db hws_register_db; 1241 struct vpu_ipc_msg_payload_job_done job_done; 1242 struct vpu_ipc_msg_payload_engine_reset_done engine_reset_done; 1243 struct vpu_ipc_msg_payload_engine_preempt_done engine_preempt_done; 1244 struct vpu_ipc_msg_payload_register_db_done register_db_done; 1245 struct vpu_ipc_msg_payload_unregister_db_done unregister_db_done; 1246 struct vpu_ipc_msg_payload_query_engine_hb_done query_engine_hb_done; 1247 struct vpu_ipc_msg_payload_get_power_level_count_done get_power_level_count_done; 1248 struct vpu_jsm_metric_streamer_done metric_streamer_done; 1249 struct vpu_ipc_msg_payload_blob_deinit_done blob_deinit_done; 1250 struct vpu_ipc_msg_payload_trace_config trace_config; 1251 struct vpu_ipc_msg_payload_trace_capability_rsp trace_capability; 1252 struct vpu_ipc_msg_payload_trace_get_name trace_get_name; 1253 struct vpu_ipc_msg_payload_trace_get_name_rsp trace_get_name_rsp; 1254 struct vpu_ipc_msg_payload_dyndbg_control dyndbg_control; 1255 struct vpu_ipc_msg_payload_hws_priority_band_setup hws_priority_band_setup; 1256 struct vpu_ipc_msg_payload_hws_create_cmdq hws_create_cmdq; 1257 struct vpu_ipc_msg_payload_hws_create_cmdq_rsp hws_create_cmdq_rsp; 1258 struct vpu_ipc_msg_payload_hws_destroy_cmdq hws_destroy_cmdq; 1259 struct vpu_ipc_msg_payload_hws_set_context_sched_properties 1260 hws_set_context_sched_properties; 1261 struct vpu_ipc_msg_payload_hws_set_scheduling_log hws_set_scheduling_log; 1262 struct vpu_ipc_msg_payload_hws_scheduling_log_notification hws_scheduling_log_notification; 1263 struct vpu_ipc_msg_payload_hws_suspend_cmdq hws_suspend_cmdq; 1264 struct vpu_ipc_msg_payload_hws_resume_cmdq hws_resume_cmdq; 1265 struct vpu_ipc_msg_payload_hws_resume_engine hws_resume_engine; 1266 struct vpu_ipc_msg_payload_pwr_d0i3_enter pwr_d0i3_enter; 1267 struct vpu_ipc_msg_payload_pwr_dct_control pwr_dct_control; 1268 }; 1269 1270 /* 1271 * Host <-> LRT IPC message base structure. 1272 * 1273 * NOTE: All instances of this object must be aligned on a 64B boundary 1274 * to allow proper handling of VPU cache operations. 1275 */ 1276 struct vpu_jsm_msg { 1277 /* Reserved */ 1278 u64 reserved_0; 1279 /* Message type, see vpu_ipc_msg_type enum. */ 1280 u32 type; 1281 /* Buffer status, see vpu_ipc_msg_status enum. */ 1282 u32 status; 1283 /* 1284 * Request ID, provided by the host in a request message and passed 1285 * back by VPU in the response message. 1286 */ 1287 u32 request_id; 1288 /* Request return code set by the VPU, see VPU_JSM_STATUS_* defines. */ 1289 u32 result; 1290 u64 reserved_1; 1291 /* Message payload depending on message type, see vpu_ipc_msg_payload union. */ 1292 union vpu_ipc_msg_payload payload; 1293 }; 1294 1295 #pragma pack(pop) 1296 1297 #endif 1298 1299 ///@} 1300