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