1 /*
2 * Copyright (c) 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 codechal_mmc.cpp
24 //! \brief Impelements the public interface for CodecHal Media Memory Compression
25 //!
26
27 #include "codechal_hw.h"
28 #include "codechal_mmc.h"
29
CodecHalMmcState(CodechalHwInterface * hwInterface)30 CodecHalMmcState::CodecHalMmcState(CodechalHwInterface *hwInterface)
31 {
32 CODECHAL_HW_FUNCTION_ENTER;
33
34 CODECHAL_HW_ASSERT(hwInterface);
35 m_hwInterface = hwInterface;
36 CODECHAL_HW_ASSERT(hwInterface->GetOsInterface());
37 m_osInterface = hwInterface->GetOsInterface();
38 CODECHAL_HW_ASSERT(hwInterface->GetSkuTable());
39 #ifdef _MMC_SUPPORTED
40 m_hcpMmcEnabled = MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrHcpDecMemoryCompression);
41 m_10bitMmcEnabled = MEDIA_IS_SKU(hwInterface->GetSkuTable(), Ftr10bitDecMemoryCompression);
42 m_gpuMmuPageFaultEnabled = MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrGpuMmuPageFault);
43
44 if (MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrMemoryCompression))
45 {
46 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
47 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
48
49 // read reg key of Codec MMC enabling. MMC default on.
50 userFeatureData.i32Data = true;
51 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
52
53 MOS_USER_FEATURE_VALUE_ID valueId = __MEDIA_USER_FEATURE_VALUE_CODEC_MMC_ENABLE_ID;
54 MOS_UserFeature_ReadValue_ID(
55 nullptr,
56 valueId,
57 &userFeatureData,
58 m_osInterface->pOsContext);
59 m_mmcEnabled = (userFeatureData.i32Data) ? true : false;
60
61 // report in-use
62 MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
63 MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData));
64 userFeatureWriteData.Value.i32Data = m_mmcEnabled;
65 userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_CODEC_MMC_IN_USE_ID;
66 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
67 }
68 #endif
69 }
IsMmcEnabled()70 bool CodecHalMmcState::IsMmcEnabled()
71 {
72 CODECHAL_HW_FUNCTION_ENTER;
73
74 return m_mmcEnabled;
75 }
76
SetMmcDisabled()77 void CodecHalMmcState::SetMmcDisabled()
78 {
79 CODECHAL_HW_FUNCTION_ENTER;
80
81 m_mmcEnabled = false;
82 }
GetSurfaceMmcState(PMOS_SURFACE surface)83 MOS_STATUS CodecHalMmcState::GetSurfaceMmcState(PMOS_SURFACE surface)
84 {
85 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
86
87 CODECHAL_HW_FUNCTION_ENTER;
88
89 if (m_mmcEnabled)
90 {
91 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetMemoryCompressionMode(
92 m_osInterface,
93 &surface->OsResource,
94 (PMOS_MEMCOMP_STATE)&surface->CompressionMode));
95 }
96
97 return eStatus;
98 }
99
GetSurfaceMmcState(PMOS_SURFACE surface,MOS_MEMCOMP_STATE * mmcState)100 MOS_STATUS CodecHalMmcState::GetSurfaceMmcState(PMOS_SURFACE surface,MOS_MEMCOMP_STATE *mmcState)
101 {
102 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
103
104 CODECHAL_HW_FUNCTION_ENTER;
105
106 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, surface);
107 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, mmcState);
108 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, m_osInterface);
109
110 if (m_mmcEnabled)
111 {
112 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetMemoryCompressionMode(
113 m_osInterface,
114 &surface->OsResource,
115 (PMOS_MEMCOMP_STATE)&surface->CompressionMode));
116 *mmcState = (MOS_MEMCOMP_STATE)surface->CompressionMode;
117 }
118 else
119 {
120 *mmcState = MOS_MEMCOMP_DISABLED;
121 }
122
123 return eStatus;
124 }
125
GetSurfaceMmcFormat(PMOS_SURFACE surface,uint32_t * mmcFormat)126 MOS_STATUS CodecHalMmcState::GetSurfaceMmcFormat(
127 PMOS_SURFACE surface,
128 uint32_t *mmcFormat)
129 {
130 MOS_STATUS status = MOS_STATUS_SUCCESS;
131
132 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, surface);
133 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, mmcFormat);
134 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, m_osInterface);
135
136 if (m_mmcEnabled)
137 {
138 status = m_osInterface->pfnGetMemoryCompressionFormat(m_osInterface, &surface->OsResource, mmcFormat);
139 }
140 else
141 {
142 *mmcFormat = 0;
143 }
144
145 return status;
146 }
147
148
149 MOS_STATUS CodecHalMmcState::
DisableSurfaceMmcState(PMOS_SURFACE surface)150 DisableSurfaceMmcState(PMOS_SURFACE surface)
151 {
152 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
153
154 CODECHAL_HW_FUNCTION_ENTER;
155
156 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
157 m_osInterface,
158 &surface->OsResource,
159 MOS_MEMCOMP_DISABLED));
160
161 return eStatus;
162 }
163
SetSurfaceMmcMode(PMOS_SURFACE dstSurface,PMOS_SURFACE srcSurface)164 MOS_STATUS CodecHalMmcState::SetSurfaceMmcMode(
165 PMOS_SURFACE dstSurface,
166 PMOS_SURFACE srcSurface)
167 {
168 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
169
170 CODECHAL_HW_FUNCTION_ENTER;
171
172 if (m_mmcEnabled)
173 {
174 if (srcSurface->CompressionMode == MOS_MMC_DISABLED)
175 {
176 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
177 m_osInterface,
178 &dstSurface->OsResource,
179 MOS_MEMCOMP_DISABLED));
180 dstSurface->CompressionMode = MOS_MMC_DISABLED;
181 }
182 else
183 {
184 if (dstSurface->bCompressible)
185 {
186 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
187 m_osInterface,
188 &dstSurface->OsResource,
189 (MOS_MEMCOMP_STATE)srcSurface->CompressionMode));
190 dstSurface->CompressionMode = srcSurface->CompressionMode;
191 }
192 else
193 {
194 m_osInterface->pfnDecompResource(m_osInterface, &srcSurface->OsResource);
195 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
196 m_osInterface,
197 &dstSurface->OsResource,
198 MOS_MEMCOMP_DISABLED));
199 dstSurface->CompressionMode = MOS_MMC_DISABLED;
200 }
201 }
202 }
203
204 return eStatus;
205 }
206
SetSurfaceParams(PCODECHAL_SURFACE_CODEC_PARAMS surfaceParams)207 MOS_STATUS CodecHalMmcState::SetSurfaceParams(
208 PCODECHAL_SURFACE_CODEC_PARAMS surfaceParams)
209 {
210 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
211
212 CODECHAL_HW_FUNCTION_ENTER;
213
214 if (m_mmcEnabled)
215 {
216 CODECHAL_HW_CHK_NULL_RETURN(surfaceParams->psSurface);
217 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetMemoryCompressionMode(
218 m_osInterface,
219 &surfaceParams->psSurface->OsResource,
220 (PMOS_MEMCOMP_STATE) &surfaceParams->psSurface->CompressionMode));
221
222 // R8_UNORM is required by MMCD. For 4x downscaling, the input surface could be MMCD-compressed.
223 if (surfaceParams->psSurface->CompressionMode != MOS_MMC_DISABLED)
224 {
225 surfaceParams->bUse32UnormSurfaceFormat = false;
226 surfaceParams->bUse16UnormSurfaceFormat = false;
227 }
228 }
229
230 return eStatus;
231 }
232
233 #if (_DEBUG || _RELEASE_INTERNAL)
UpdateUserFeatureKey(PMOS_SURFACE surface)234 MOS_STATUS CodecHalMmcState::UpdateUserFeatureKey(PMOS_SURFACE surface)
235 {
236 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
237
238 CODECHAL_HW_FUNCTION_ENTER;
239
240 CODECHAL_HW_CHK_NULL_RETURN(surface);
241 #ifdef _MMC_SUPPORTED
242 if (!m_userFeatureUpdated)
243 {
244 MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
245 userFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
246 userFeatureWriteData.Value.i32Data = surface->bCompressible;
247 userFeatureWriteData.ValueID = (MOS_USER_FEATURE_VALUE_ID)m_compressibleId;
248 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
249
250 userFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
251 userFeatureWriteData.Value.i32Data = surface->MmcState;
252 userFeatureWriteData.ValueID = (MOS_USER_FEATURE_VALUE_ID)m_compressModeId;
253 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
254
255 m_userFeatureUpdated = true;
256 }
257 #endif
258 return eStatus;
259 }
260 #endif
261