1 /* 2 * Copyright (c) 2014-2017, Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included 12 * in all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 */ 22 //! 23 //! \file mhw_render_generic.h 24 //! \brief MHW interface templates for render engine commands 25 //! \details Impelements shared HW command construction functions across all platforms as templates 26 //! 27 28 #ifndef __MHW_RENDER_GENERIC_H__ 29 #define __MHW_RENDER_GENERIC_H__ 30 31 #include "mhw_render.h" 32 33 template <class TRenderCmds> 34 class MhwRenderInterfaceGeneric : public MhwRenderInterface 35 { 36 protected: MhwRenderInterfaceGeneric(MhwMiInterface * miInterface,PMOS_INTERFACE osInterface,MEDIA_SYSTEM_INFO * gtSystemInfo,uint8_t newStateHeapManagerRequested)37 MhwRenderInterfaceGeneric( 38 MhwMiInterface *miInterface, 39 PMOS_INTERFACE osInterface, 40 MEDIA_SYSTEM_INFO *gtSystemInfo, 41 uint8_t newStateHeapManagerRequested) : 42 MhwRenderInterface(miInterface, osInterface, gtSystemInfo, newStateHeapManagerRequested){} 43 44 public: ~MhwRenderInterfaceGeneric()45 virtual ~MhwRenderInterfaceGeneric() { MHW_FUNCTION_ENTER; } 46 AddPipelineSelectCmd(PMOS_COMMAND_BUFFER cmdBuffer,bool gpGpuPipe)47 MOS_STATUS AddPipelineSelectCmd( 48 PMOS_COMMAND_BUFFER cmdBuffer, 49 bool gpGpuPipe) 50 { 51 MHW_FUNCTION_ENTER; 52 53 MHW_MI_CHK_NULL(cmdBuffer); 54 55 typename TRenderCmds::PIPELINE_SELECT_CMD cmd; 56 cmd.DW0.PipelineSelection = (gpGpuPipe) ? cmd.PIPELINE_SELECTION_GPGPU : cmd.PIPELINE_SELECTION_MEDIA; 57 58 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize)); 59 60 return MOS_STATUS_SUCCESS; 61 } 62 AddStateBaseAddrCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_STATE_BASE_ADDR_PARAMS params)63 MOS_STATUS AddStateBaseAddrCmd( 64 PMOS_COMMAND_BUFFER cmdBuffer, 65 PMHW_STATE_BASE_ADDR_PARAMS params) 66 { 67 MHW_FUNCTION_ENTER; 68 69 MHW_MI_CHK_NULL(cmdBuffer); 70 MHW_MI_CHK_NULL(params); 71 72 MHW_RESOURCE_PARAMS resourceParams; 73 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 74 resourceParams.dwLsbNum = MHW_RENDER_ENGINE_STATE_BASE_ADDRESS_SHIFT; 75 resourceParams.HwCommandType = MOS_STATE_BASE_ADDR; 76 77 typename TRenderCmds::STATE_BASE_ADDRESS_CMD cmd; 78 79 if (params->presGeneralState) 80 { 81 cmd.DW1_2.GeneralStateBaseAddressModifyEnable = true; 82 cmd.DW12.GeneralStateBufferSizeModifyEnable = true; 83 resourceParams.presResource = params->presGeneralState; 84 resourceParams.dwOffset = 0; 85 resourceParams.pdwCmd = cmd.DW1_2.Value; 86 resourceParams.dwLocationInCmd = 1; 87 88 // upper bound of the allocated resource will not be set 89 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; 90 91 InitMocsParams(resourceParams, &cmd.DW1_2.Value[0], 5, 10); 92 93 MHW_MI_CHK_STATUS(AddResourceToCmd( 94 m_osInterface, 95 cmdBuffer, 96 &resourceParams)); 97 98 if (params->mocs4GeneralState != 0) 99 { 100 cmd.DW1_2.GeneralStateMemoryObjectControlState = params->mocs4GeneralState; 101 } 102 103 cmd.DW12.GeneralStateBufferSize = (params->dwGeneralStateSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE; 104 } 105 106 if (m_osInterface->bNoParsingAssistanceInKmd) 107 { 108 uint32_t indirectStateOffset, indirectStateSize; 109 MHW_MI_CHK_STATUS(m_osInterface->pfnGetIndirectState(m_osInterface, &indirectStateOffset, &indirectStateSize)); 110 111 // When KMD parsing assistance is not used, 112 // UMD is required to set up the SSH 113 // in the STATE_BASE_ADDRESS command. 114 // All addresses used in the STATE_BASE_ADDRESS 115 // command need to have the modify 116 // bit associated with it set to 1. 117 cmd.DW4_5.SurfaceStateBaseAddressModifyEnable = true; 118 resourceParams.presResource = &cmdBuffer->OsResource; 119 resourceParams.dwOffset = indirectStateOffset; 120 resourceParams.pdwCmd = cmd.DW4_5.Value; 121 resourceParams.dwLocationInCmd = 4; 122 123 // upper bound of the allocated resource will not be set 124 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; 125 126 InitMocsParams(resourceParams, &cmd.DW4_5.Value[0], 5, 10); 127 128 MHW_MI_CHK_STATUS(AddResourceToCmd( 129 m_osInterface, 130 cmdBuffer, 131 &resourceParams)); 132 133 if (params->mocs4SurfaceState != 0) 134 { 135 cmd.DW4_5.SurfaceStateMemoryObjectControlState = params->mocs4SurfaceState; 136 } 137 } 138 139 if (params->presDynamicState) 140 { 141 cmd.DW6_7.DynamicStateBaseAddressModifyEnable = true; 142 cmd.DW13.DynamicStateBufferSizeModifyEnable = true; 143 resourceParams.presResource = params->presDynamicState; 144 resourceParams.dwOffset = 0; 145 resourceParams.pdwCmd = cmd.DW6_7.Value; 146 resourceParams.dwLocationInCmd = 6; 147 resourceParams.bIsWritable = params->bDynamicStateRenderTarget; 148 149 // upper bound of the allocated resource will not be set 150 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; 151 152 InitMocsParams(resourceParams, &cmd.DW6_7.Value[0], 5, 10); 153 154 MHW_MI_CHK_STATUS(AddResourceToCmd( 155 m_osInterface, 156 cmdBuffer, 157 &resourceParams)); 158 159 if (params->mocs4DynamicState != 0) 160 { 161 cmd.DW6_7.DynamicStateMemoryObjectControlState = params->mocs4DynamicState; 162 } 163 164 cmd.DW13.DynamicStateBufferSize = (params->dwDynamicStateSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE; 165 166 //Reset bRenderTarget as it should be enabled only for Dynamic State 167 resourceParams.bIsWritable = false; 168 } 169 170 if (params->presIndirectObjectBuffer) 171 { 172 cmd.DW8_9.IndirectObjectBaseAddressModifyEnable = true; 173 cmd.DW14.IndirectObjectBufferSizeModifyEnable = true; 174 resourceParams.presResource = params->presIndirectObjectBuffer; 175 resourceParams.dwOffset = 0; 176 resourceParams.pdwCmd = cmd.DW8_9.Value; 177 resourceParams.dwLocationInCmd = 8; 178 179 // upper bound of the allocated resource will not be set 180 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; 181 182 InitMocsParams(resourceParams, &cmd.DW8_9.Value[0], 5, 10); 183 184 MHW_MI_CHK_STATUS(AddResourceToCmd( 185 m_osInterface, 186 cmdBuffer, 187 &resourceParams)); 188 189 if (params->mocs4IndirectObjectBuffer != 0) 190 { 191 cmd.DW8_9.IndirectObjectMemoryObjectControlState = params->mocs4IndirectObjectBuffer; 192 } 193 194 cmd.DW14.IndirectObjectBufferSize = (params->dwIndirectObjectBufferSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE; 195 } 196 197 if (params->presInstructionBuffer) 198 { 199 cmd.DW10_11.InstructionBaseAddressModifyEnable = true; 200 cmd.DW15.InstructionBufferSizeModifyEnable = true; 201 resourceParams.presResource = params->presInstructionBuffer; 202 resourceParams.dwOffset = 0; 203 resourceParams.pdwCmd = cmd.DW10_11.Value; 204 resourceParams.dwLocationInCmd = 10; 205 206 // upper bound of the allocated resource will not be set 207 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; 208 209 InitMocsParams(resourceParams, &cmd.DW10_11.Value[0], 5, 10); 210 211 MHW_MI_CHK_STATUS(AddResourceToCmd( 212 m_osInterface, 213 cmdBuffer, 214 &resourceParams)); 215 216 if (params->mocs4InstructionCache != 0) 217 { 218 cmd.DW10_11.InstructionMemoryObjectControlState = params->mocs4InstructionCache; 219 } 220 221 cmd.DW15.InstructionBufferSize = (params->dwInstructionBufferSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE; 222 } 223 224 // stateless dataport access 225 cmd.DW3.StatelessDataPortAccessMemoryObjectControlState = params->mocs4StatelessDataport; 226 227 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize)); 228 229 return MOS_STATUS_SUCCESS; 230 } 231 AddMediaVfeCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VFE_PARAMS params)232 MOS_STATUS AddMediaVfeCmd( 233 PMOS_COMMAND_BUFFER cmdBuffer, 234 PMHW_VFE_PARAMS params) 235 { 236 MHW_FUNCTION_ENTER; 237 238 MHW_MI_CHK_NULL(cmdBuffer); 239 MHW_MI_CHK_NULL(params); 240 241 typename TRenderCmds::MEDIA_VFE_STATE_CMD cmd; 242 243 if (params->pKernelState) 244 { 245 MHW_MI_CHK_NULL(params->pKernelState); 246 247 cmd.DW3.MaximumNumberOfThreads = (params->dwMaximumNumberofThreads) ? 248 params->dwMaximumNumberofThreads - 1 : params->pKernelState->KernelParams.iThreadCount - 1; 249 cmd.DW5.CurbeAllocationSize = 250 MOS_ROUNDUP_SHIFT(params->pKernelState->KernelParams.iCurbeLength, 5); 251 cmd.DW5.UrbEntryAllocationSize = MOS_MAX(1, 252 MOS_ROUNDUP_SHIFT(params->pKernelState->KernelParams.iInlineDataLength, 5)); 253 254 uint32_t numberofURBEntries = 255 (m_hwCaps.dwMaxURBSize - 256 cmd.DW5.CurbeAllocationSize - 257 params->pKernelState->KernelParams.iIdCount) / 258 cmd.DW5.UrbEntryAllocationSize; 259 numberofURBEntries = MOS_CLAMP_MIN_MAX(numberofURBEntries, 1, 64); 260 cmd.DW3.NumberOfUrbEntries = numberofURBEntries; 261 } 262 else 263 { 264 if (params->dwNumberofURBEntries == 0) 265 { 266 MHW_ASSERTMESSAGE("Parameter dwNumberofURBEntries is 0 will cause divided by zero."); 267 return MOS_STATUS_INVALID_PARAMETER; 268 } 269 270 if (params->dwPerThreadScratchSpace) 271 { 272 cmd.DW1.PerThreadScratchSpace = params->dwPerThreadScratchSpace; 273 cmd.DW1.ScratchSpaceBasePointer = params->dwScratchSpaceBasePointer >> 10; 274 cmd.DW2.ScratchSpaceBasePointerHigh = 0; 275 } 276 cmd.DW3.MaximumNumberOfThreads = (params->dwMaximumNumberofThreads) ? 277 params->dwMaximumNumberofThreads - 1 : m_hwCaps.dwMaxThreads - 1; 278 cmd.DW3.NumberOfUrbEntries = params->dwNumberofURBEntries; 279 cmd.DW5.CurbeAllocationSize = params->dwCURBEAllocationSize >> 5; 280 cmd.DW5.UrbEntryAllocationSize = (params->dwURBEntryAllocationSize) ? 281 params->dwURBEntryAllocationSize : 282 (m_hwCaps.dwMaxURBSize - 283 cmd.DW5.CurbeAllocationSize - 284 m_hwCaps.dwMaxInterfaceDescriptorEntries) / 285 params->dwNumberofURBEntries; 286 } 287 288 if ((cmd.DW3.NumberOfUrbEntries > m_hwCaps.dwMaxURBEntries) || 289 (cmd.DW5.CurbeAllocationSize > m_hwCaps.dwMaxCURBEAllocationSize) || 290 (cmd.DW5.UrbEntryAllocationSize > m_hwCaps.dwMaxURBEntryAllocationSize) || 291 (cmd.DW3.NumberOfUrbEntries * cmd.DW5.UrbEntryAllocationSize + 292 cmd.DW5.CurbeAllocationSize + 293 m_hwCaps.dwMaxInterfaceDescriptorEntries > m_hwCaps.dwMaxURBSize)) 294 { 295 MHW_ASSERTMESSAGE("Parameters requested exceed maximum supported by HW."); 296 return MOS_STATUS_INVALID_PARAMETER; 297 } 298 299 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize)); 300 301 return MOS_STATUS_SUCCESS; 302 } 303 AddMediaCurbeLoadCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_CURBE_LOAD_PARAMS params)304 MOS_STATUS AddMediaCurbeLoadCmd( 305 PMOS_COMMAND_BUFFER cmdBuffer, 306 PMHW_CURBE_LOAD_PARAMS params) 307 { 308 MHW_FUNCTION_ENTER; 309 310 MHW_MI_CHK_NULL(cmdBuffer); 311 MHW_MI_CHK_NULL(params); 312 313 typename TRenderCmds::MEDIA_CURBE_LOAD_CMD cmd; 314 315 if (params->pKernelState) 316 { 317 MHW_MI_CHK_NULL(m_stateHeapInterface->pStateHeapInterface); 318 319 auto kernelState = params->pKernelState; 320 321 cmd.DW2.CurbeTotalDataLength = (uint32_t)MOS_ALIGN_CEIL( 322 kernelState->KernelParams.iCurbeLength, 323 m_stateHeapInterface->pStateHeapInterface->GetCurbeAlignment()); 324 cmd.DW3.CurbeDataStartAddress = MOS_ALIGN_CEIL( 325 (kernelState->m_dshRegion.GetOffset() + 326 kernelState->dwCurbeOffset), 327 m_stateHeapInterface->pStateHeapInterface->GetCurbeAlignment()); 328 } 329 else 330 { 331 cmd.DW2.CurbeTotalDataLength = params->dwCURBETotalDataLength; 332 cmd.DW3.CurbeDataStartAddress = params->dwCURBEDataStartAddress; 333 } 334 335 // Send the command only if there is data to load 336 if (cmd.DW2.CurbeTotalDataLength) 337 { 338 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize)); 339 } 340 else 341 { 342 MHW_NORMALMESSAGE("MEDIA_CURBE_LOAD must load data. Command skipped."); 343 } 344 345 return MOS_STATUS_SUCCESS; 346 } 347 AddMediaIDLoadCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_ID_LOAD_PARAMS params)348 MOS_STATUS AddMediaIDLoadCmd( 349 PMOS_COMMAND_BUFFER cmdBuffer, 350 PMHW_ID_LOAD_PARAMS params) 351 { 352 MHW_FUNCTION_ENTER; 353 354 MHW_MI_CHK_NULL(cmdBuffer); 355 MHW_MI_CHK_NULL(params); 356 MHW_MI_CHK_NULL(m_stateHeapInterface->pStateHeapInterface); 357 358 typename TRenderCmds::MEDIA_INTERFACE_DESCRIPTOR_LOAD_CMD cmd; 359 360 if (params->pKernelState) 361 { 362 auto kernelState = params->pKernelState; 363 364 cmd.DW2.InterfaceDescriptorTotalLength = 365 m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData() * params->dwNumKernelsLoaded; 366 cmd.DW3.InterfaceDescriptorDataStartAddress = MOS_ALIGN_CEIL( 367 kernelState->m_dshRegion.GetOffset() + 368 kernelState->dwIdOffset + 369 (params->dwIdIdx * m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData()), 370 m_stateHeapInterface->pStateHeapInterface->GetIdAlignment()); 371 } 372 // Client managed MediaIDs 373 else if (params->dwInterfaceDescriptorLength) 374 { 375 cmd.DW2.InterfaceDescriptorTotalLength = params->dwInterfaceDescriptorLength; 376 cmd.DW3.InterfaceDescriptorDataStartAddress = params->dwInterfaceDescriptorStartOffset; 377 } 378 379 if (cmd.DW2.InterfaceDescriptorTotalLength > 0) 380 { 381 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize)); 382 } 383 else 384 { 385 MHW_NORMALMESSAGE("MEDIA_INTERFACE_DESCRIPTOR_LOAD must load data. Command skipped."); 386 } 387 388 return MOS_STATUS_SUCCESS; 389 } 390 AddMediaObject(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_BATCH_BUFFER batchBuffer,PMHW_MEDIA_OBJECT_PARAMS params)391 MOS_STATUS AddMediaObject( 392 PMOS_COMMAND_BUFFER cmdBuffer, 393 PMHW_BATCH_BUFFER batchBuffer, 394 PMHW_MEDIA_OBJECT_PARAMS params) 395 { 396 MHW_FUNCTION_ENTER; 397 398 MHW_MI_CHK_NULL(params); 399 400 if (cmdBuffer == nullptr && batchBuffer == nullptr) 401 { 402 MHW_ASSERTMESSAGE("No valid buffer to add the command to!"); 403 return MOS_STATUS_INVALID_PARAMETER; 404 } 405 406 typename TRenderCmds::MEDIA_OBJECT_CMD cmd; 407 408 if (params->dwInlineDataSize > 0) 409 { 410 cmd.DW0.DwordLength = 411 TRenderCmds::GetOpLength(((params->dwInlineDataSize / sizeof(uint32_t)) + cmd.dwSize)); 412 } 413 414 cmd.DW1.InterfaceDescriptorOffset = params->dwInterfaceDescriptorOffset; 415 cmd.DW2.IndirectDataLength = params->dwIndirectLoadLength; 416 cmd.DW2.SubsliceDestinationSelect = params->dwHalfSliceDestinationSelect; 417 cmd.DW2.SliceDestinationSelect = params->dwSliceDestinationSelect; 418 cmd.DW2.ForceDestination = params->bForceDestination; 419 cmd.DW3.IndirectDataStartAddress = params->dwIndirectDataStartAddress; 420 421 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB( 422 cmdBuffer, 423 batchBuffer, 424 &cmd, 425 cmd.byteSize)); 426 427 if (params->pInlineData && params->dwInlineDataSize > 0) 428 { 429 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB( 430 cmdBuffer, 431 batchBuffer, 432 params->pInlineData, 433 params->dwInlineDataSize)); 434 } 435 436 return MOS_STATUS_SUCCESS; 437 } 438 AddMediaObjectWalkerCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_WALKER_PARAMS params)439 MOS_STATUS AddMediaObjectWalkerCmd( 440 PMOS_COMMAND_BUFFER cmdBuffer, 441 PMHW_WALKER_PARAMS params) 442 { 443 MHW_FUNCTION_ENTER; 444 445 MHW_MI_CHK_NULL(cmdBuffer); 446 MHW_MI_CHK_NULL(params); 447 448 typename TRenderCmds::MEDIA_OBJECT_WALKER_CMD cmd; 449 450 if (params->pInlineData) 451 { 452 cmd.DW0.DwordLength = 453 TRenderCmds::GetOpLength(cmd.dwSize + params->InlineDataLength / sizeof(uint32_t)); 454 } 455 456 cmd.DW1.InterfaceDescriptorOffset = params->InterfaceDescriptorOffset; 457 cmd.DW5.GroupIdLoopSelect = params->GroupIdLoopSelect; 458 cmd.DW6.ColorCountMinusOne = params->ColorCountMinusOne; 459 cmd.DW6.MiddleLoopExtraSteps = params->MiddleLoopExtraSteps; 460 cmd.DW6.MidLoopUnitX = params->MidLoopUnitX; 461 cmd.DW6.LocalMidLoopUnitY = params->MidLoopUnitY; 462 cmd.DW7.LocalLoopExecCount = params->dwLocalLoopExecCount; 463 cmd.DW7.GlobalLoopExecCount = params->dwGlobalLoopExecCount; 464 cmd.DW8.BlockResolutionX = params->BlockResolution.x; 465 cmd.DW8.BlockResolutionY = params->BlockResolution.y; 466 cmd.DW9.LocalStartX = params->LocalStart.x; 467 cmd.DW9.LocalStartY = params->LocalStart.y; 468 cmd.DW11.LocalOuterLoopStrideX = params->LocalOutLoopStride.x; 469 cmd.DW11.LocalOuterLoopStrideY = params->LocalOutLoopStride.y; 470 cmd.DW12.LocalInnerLoopUnitX = params->LocalInnerLoopUnit.x; 471 cmd.DW12.LocalInnerLoopUnitY = params->LocalInnerLoopUnit.y; 472 cmd.DW13.GlobalResolutionX = params->GlobalResolution.x; 473 cmd.DW13.GlobalResolutionY = params->GlobalResolution.y; 474 cmd.DW14.GlobalStartX = params->GlobalStart.x; 475 cmd.DW14.GlobalStartY = params->GlobalStart.y; 476 cmd.DW15.GlobalOuterLoopStrideX = params->GlobalOutlerLoopStride.x; 477 cmd.DW15.GlobalOuterLoopStrideY = params->GlobalOutlerLoopStride.y; 478 cmd.DW16.GlobalInnerLoopUnitX = params->GlobalInnerLoopUnit.x; 479 cmd.DW16.GlobalInnerLoopUnitY = params->GlobalInnerLoopUnit.y; 480 481 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize)); 482 483 if (params->pInlineData) 484 { 485 if (params->InlineDataLength > 0) 486 { 487 MHW_MI_CHK_STATUS(Mos_AddCommand( 488 cmdBuffer, 489 params->pInlineData, 490 params->InlineDataLength)); 491 } 492 else 493 { 494 MHW_NORMALMESSAGE("Inline data indicated, however cannot insert without valid length."); 495 } 496 } 497 498 return MOS_STATUS_SUCCESS; 499 } 500 AddGpGpuWalkerStateCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_GPGPU_WALKER_PARAMS params)501 MOS_STATUS AddGpGpuWalkerStateCmd( 502 PMOS_COMMAND_BUFFER cmdBuffer, 503 PMHW_GPGPU_WALKER_PARAMS params) 504 { 505 MHW_FUNCTION_ENTER; 506 507 MHW_MI_CHK_NULL(cmdBuffer); 508 MHW_MI_CHK_NULL(params); 509 510 if (params->ThreadDepth == 0) 511 { 512 params->ThreadDepth = 1; 513 } 514 if (params->GroupDepth == 0) 515 { 516 params->GroupDepth = 1; 517 } 518 519 typename TRenderCmds::GPGPU_WALKER_CMD cmd; 520 cmd.DW1.InterfaceDescriptorOffset = params->InterfaceDescriptorOffset; 521 cmd.DW4.SimdSize = 2; // SIMD32 522 cmd.DW4.ThreadWidthCounterMaximum = params->ThreadWidth - 1; 523 cmd.DW4.ThreadHeightCounterMaximum = params->ThreadHeight - 1; 524 cmd.DW4.ThreadDepthCounterMaximum = params->ThreadDepth - 1; 525 cmd.DW5.ThreadGroupIdStartingX = 0; 526 cmd.DW7.ThreadGroupIdXDimension = params->GroupWidth; 527 cmd.DW8.ThreadGroupIdStartingY = 0; 528 cmd.DW10.ThreadGroupIdYDimension = params->GroupHeight; 529 cmd.DW11.ThreadGroupIdStartingResumeZ = 0; 530 cmd.DW12.ThreadGroupIdZDimension = params->GroupDepth; 531 cmd.DW13.RightExecutionMask = 0xffffffff; 532 cmd.DW14.BottomExecutionMask = 0xffffffff; 533 534 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize)); 535 536 return MOS_STATUS_SUCCESS; 537 } AddChromaKeyCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_CHROMAKEY_PARAMS params)538 MOS_STATUS AddChromaKeyCmd( 539 PMOS_COMMAND_BUFFER cmdBuffer, 540 PMHW_CHROMAKEY_PARAMS params) 541 { 542 MHW_FUNCTION_ENTER; 543 544 MHW_MI_CHK_NULL(cmdBuffer); 545 MHW_MI_CHK_NULL(params); 546 547 typename TRenderCmds::_3DSTATE_CHROMA_KEY_CMD cmd; 548 cmd.DW1.ChromakeyTableIndex = params->dwIndex; 549 cmd.DW2.ChromakeyLowValue = params->dwLow; 550 cmd.DW3.ChromakeyHighValue = params->dwHigh; 551 552 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize)); 553 554 return MOS_STATUS_SUCCESS; 555 } 556 AddSipStateCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_SIP_STATE_PARAMS params)557 MOS_STATUS AddSipStateCmd( 558 PMOS_COMMAND_BUFFER cmdBuffer, 559 PMHW_SIP_STATE_PARAMS params) 560 { 561 MHW_FUNCTION_ENTER; 562 563 MHW_MI_CHK_NULL(cmdBuffer); 564 MHW_MI_CHK_NULL(params); 565 566 typename TRenderCmds::STATE_SIP_CMD cmd; 567 cmd.DW1_2.SystemInstructionPointer = (uint64_t)(params->dwSipBase >> 4); 568 569 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize)) 570 571 return MOS_STATUS_SUCCESS; 572 } 573 GetMediaObjectCmdSize()574 inline uint32_t GetMediaObjectCmdSize() 575 { 576 return TRenderCmds::MEDIA_OBJECT_CMD::byteSize; 577 } 578 }; 579 580 #endif // __MHW_RENDER_GENERIC_H__ 581