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
30 bool CodecHalMmcState::m_mmcEnabled = false;
31
CodecHalMmcState(CodechalHwInterface * hwInterface)32 CodecHalMmcState::CodecHalMmcState(CodechalHwInterface *hwInterface)
33 {
34 CODECHAL_HW_FUNCTION_ENTER;
35
36 CODECHAL_HW_ASSERT(hwInterface);
37 m_hwInterface = hwInterface;
38 CODECHAL_HW_ASSERT(hwInterface->GetOsInterface());
39 m_osInterface = hwInterface->GetOsInterface();
40 CODECHAL_HW_ASSERT(hwInterface->GetSkuTable());
41 #ifdef _MMC_SUPPORTED
42 m_hcpMmcEnabled = MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrHcpDecMemoryCompression);
43 m_10bitMmcEnabled = MEDIA_IS_SKU(hwInterface->GetSkuTable(), Ftr10bitDecMemoryCompression);
44 m_gpuMmuPageFaultEnabled = MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrGpuMmuPageFault);
45
46 if (MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrMemoryCompression))
47 {
48 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
49 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
50
51 // read reg key of Codec MMC enabling. MMC default on.
52 userFeatureData.i32Data = true;
53 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
54
55 MOS_USER_FEATURE_VALUE_ID valueId = __MEDIA_USER_FEATURE_VALUE_CODEC_MMC_ENABLE_ID;
56 MOS_UserFeature_ReadValue_ID(
57 nullptr,
58 valueId,
59 &userFeatureData);
60 m_mmcEnabled = (userFeatureData.i32Data) ? true : false;
61
62 // report in-use
63 MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
64 MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData));
65 userFeatureWriteData.Value.i32Data = m_mmcEnabled;
66 userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_CODEC_MMC_IN_USE_ID;
67 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1);
68 }
69 #endif
70 }
IsMmcEnabled()71 bool CodecHalMmcState::IsMmcEnabled()
72 {
73 CODECHAL_HW_FUNCTION_ENTER;
74
75 return m_mmcEnabled;
76 }
77
SetMmcDisabled()78 void CodecHalMmcState::SetMmcDisabled()
79 {
80 CODECHAL_HW_FUNCTION_ENTER;
81
82 m_mmcEnabled = false;
83 }
GetSurfaceMmcState(PMOS_SURFACE surface)84 MOS_STATUS CodecHalMmcState::GetSurfaceMmcState(PMOS_SURFACE surface)
85 {
86 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
87
88 CODECHAL_HW_FUNCTION_ENTER;
89
90 if (m_mmcEnabled)
91 {
92 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetMemoryCompressionMode(
93 m_osInterface,
94 &surface->OsResource,
95 (PMOS_MEMCOMP_STATE)&surface->CompressionMode));
96 }
97
98 return eStatus;
99 }
100
101 MOS_STATUS CodecHalMmcState::
DisableSurfaceMmcState(PMOS_SURFACE surface)102 DisableSurfaceMmcState(PMOS_SURFACE surface)
103 {
104 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
105
106 CODECHAL_HW_FUNCTION_ENTER;
107
108 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
109 m_osInterface,
110 &surface->OsResource,
111 MOS_MEMCOMP_DISABLED));
112
113 return eStatus;
114 }
115
SetSurfaceMmcMode(PMOS_SURFACE dstSurface,PMOS_SURFACE srcSurface)116 MOS_STATUS CodecHalMmcState::SetSurfaceMmcMode(
117 PMOS_SURFACE dstSurface,
118 PMOS_SURFACE srcSurface)
119 {
120 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
121
122 CODECHAL_HW_FUNCTION_ENTER;
123
124 if (m_mmcEnabled)
125 {
126 if (srcSurface->CompressionMode == MOS_MMC_DISABLED)
127 {
128 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
129 m_osInterface,
130 &dstSurface->OsResource,
131 MOS_MEMCOMP_DISABLED));
132 dstSurface->CompressionMode = MOS_MMC_DISABLED;
133 }
134 else
135 {
136 if (dstSurface->bCompressible)
137 {
138 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
139 m_osInterface,
140 &dstSurface->OsResource,
141 (MOS_MEMCOMP_STATE)srcSurface->CompressionMode));
142 dstSurface->CompressionMode = srcSurface->CompressionMode;
143 }
144 else
145 {
146 m_osInterface->pfnDecompResource(m_osInterface, &srcSurface->OsResource);
147 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
148 m_osInterface,
149 &dstSurface->OsResource,
150 MOS_MEMCOMP_DISABLED));
151 dstSurface->CompressionMode = MOS_MMC_DISABLED;
152 }
153 }
154 }
155
156 return eStatus;
157 }
158
SetSurfaceParams(PCODECHAL_SURFACE_CODEC_PARAMS surfaceParams)159 MOS_STATUS CodecHalMmcState::SetSurfaceParams(
160 PCODECHAL_SURFACE_CODEC_PARAMS surfaceParams)
161 {
162 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
163
164 CODECHAL_HW_FUNCTION_ENTER;
165
166 if (m_mmcEnabled)
167 {
168 CODECHAL_HW_CHK_NULL_RETURN(surfaceParams->psSurface);
169 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetMemoryCompressionMode(
170 m_osInterface,
171 &surfaceParams->psSurface->OsResource,
172 (PMOS_MEMCOMP_STATE) &surfaceParams->psSurface->CompressionMode));
173
174 // R8_UNORM is required by MMCD. For 4x downscaling, the input surface could be MMCD-compressed.
175 if (surfaceParams->psSurface->CompressionMode != MOS_MMC_DISABLED)
176 {
177 surfaceParams->bUse32UnormSurfaceFormat = false;
178 surfaceParams->bUse16UnormSurfaceFormat = false;
179 }
180 }
181
182 return eStatus;
183 }
184
185 #if (_DEBUG || _RELEASE_INTERNAL)
UpdateUserFeatureKey(PMOS_SURFACE surface)186 MOS_STATUS CodecHalMmcState::UpdateUserFeatureKey(PMOS_SURFACE surface)
187 {
188 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
189
190 CODECHAL_HW_FUNCTION_ENTER;
191
192 CODECHAL_HW_CHK_NULL_RETURN(surface);
193 #ifdef _MMC_SUPPORTED
194 if (!m_userFeatureUpdated)
195 {
196 MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
197 userFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
198 userFeatureWriteData.Value.i32Data = surface->bCompressible;
199 userFeatureWriteData.ValueID = (MOS_USER_FEATURE_VALUE_ID)m_compressibleId;
200 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1);
201
202 userFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
203 userFeatureWriteData.Value.i32Data = surface->MmcState;
204 userFeatureWriteData.ValueID = (MOS_USER_FEATURE_VALUE_ID)m_compressModeId;
205 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1);
206
207 m_userFeatureUpdated = true;
208 }
209 #endif
210 return eStatus;
211 }
212 #endif
213