diff --git a/runtime/dll/linux/drm_neo_create.cpp b/runtime/dll/linux/drm_neo_create.cpp
index ec0807f59f..99cda5175e 100644
--- a/runtime/dll/linux/drm_neo_create.cpp
+++ b/runtime/dll/linux/drm_neo_create.cpp
@@ -155,8 +155,7 @@ Drm *Drm::create(int32_t deviceOrdinal) {
     }
     if (device) {
         platformDevices[0] = device->pHwInfo;
-        device->setupHardwareInfo(const_cast<GT_SYSTEM_INFO *>(platformDevices[0]->pSysInfo),
-                                  const_cast<FeatureTable *>(platformDevices[0]->pSkuTable), true);
+        device->setupHardwareInfo(const_cast<HardwareInfo *>(platformDevices[0]), true);
         drmObject->setGtType(eGtType);
     } else {
         printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr,
diff --git a/runtime/gen10/hw_cmds.h b/runtime/gen10/hw_cmds.h
index 386c9cf772..b31994b1d1 100644
--- a/runtime/gen10/hw_cmds.h
+++ b/runtime/gen10/hw_cmds.h
@@ -68,16 +68,19 @@ struct CNLFamily : public GEN10 {
 struct CNL : public CNLFamily {
     static const PLATFORM platform;
     static const HardwareInfo hwInfo;
+    static FeatureTable featureTable;
+    static WorkaroundTable workaroundTable;
     static const uint32_t threadsPerEu = 7;
     static const uint32_t maxEuPerSubslice = 8;
     static const uint32_t maxSlicesSupported = 4;
     static const uint32_t maxSubslicesSupported = 9;
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
+    static void (*setupHardwareInfo)(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig);
+    static void setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo);
 };
 class CNL_2x5x8 : public CNL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -85,7 +88,7 @@ class CNL_2x5x8 : public CNL {
 };
 class CNL_2x4x8 : public CNL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -93,7 +96,7 @@ class CNL_2x4x8 : public CNL {
 };
 class CNL_1x3x8 : public CNL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -101,7 +104,7 @@ class CNL_1x3x8 : public CNL {
 };
 class CNL_1x2x8 : public CNL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -109,7 +112,7 @@ class CNL_1x2x8 : public CNL {
 };
 class CNL_4x9x8 : public CNL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
diff --git a/runtime/gen10/hw_info_cnl.inl b/runtime/gen10/hw_info_cnl.inl
index b3f5a41961..571f452fe1 100644
--- a/runtime/gen10/hw_info_cnl.inl
+++ b/runtime/gen10/hw_info_cnl.inl
@@ -71,15 +71,56 @@ const RuntimeCapabilityTable CNL::capabilityTable{
     false                                          // supportCacheFlushAfterWalker
 };
 
+WorkaroundTable CNL::workaroundTable = {};
+FeatureTable CNL::featureTable = {};
+
+void CNL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+
+    pSkuTable->ftrGpGpuMidThreadLevelPreempt = true;
+    pSkuTable->ftr3dMidBatchPreempt = true;
+    pSkuTable->ftr3dObjectLevelPreempt = true;
+    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
+    pSkuTable->ftrPPGTT = true;
+    pSkuTable->ftrSVM = true;
+    pSkuTable->ftrIA32eGfxPTEs = true;
+    pSkuTable->ftrStandardMipTailFormat = true;
+    pSkuTable->ftrDisplayYTiling = true;
+    pSkuTable->ftrTranslationTable = true;
+    pSkuTable->ftrUserModeTranslationTable = true;
+    pSkuTable->ftrTileMappedResource = true;
+    pSkuTable->ftrEnableGuC = true;
+    pSkuTable->ftrFbc = true;
+    pSkuTable->ftrFbc2AddressTranslation = true;
+    pSkuTable->ftrFbcBlitterTracking = true;
+    pSkuTable->ftrFbcCpuTracking = true;
+    pSkuTable->ftrAstcHdr2D = true;
+    pSkuTable->ftrAstcLdr2D = true;
+    pSkuTable->ftrTileY = true;
+
+    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
+    pWaTable->waSendMIFLUSHBeforeVFE = true;
+    pWaTable->waReportPerfCountUseGlobalContextID = true;
+    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
+
+    if ((1 << hwInfo->pPlatform->usRevId) & 0x3) {
+        pWaTable->waFbcLinearSurfaceStride = true;
+    }
+    if ((1 << hwInfo->pPlatform->usRevId) & 0x1) {
+        pWaTable->waEncryptedEdramOnlyPartials = true;
+    }
+}
 const HardwareInfo CNL_2x5x8::hwInfo = {
     &CNL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &CNL::featureTable,
+    &CNL::workaroundTable,
     &CNL_2x5x8::gtSystemInfo,
     CNL::capabilityTable,
 };
 GT_SYSTEM_INFO CNL_2x5x8::gtSystemInfo = {0};
-void CNL_2x5x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void CNL_2x5x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 39;
     gtSysInfo->ThreadCount = 39 * CNL::threadsPerEu;
     gtSysInfo->SliceCount = 2;
@@ -98,16 +139,20 @@ void CNL_2x5x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = CNL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 const HardwareInfo CNL_2x4x8::hwInfo = {
     &CNL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &CNL::featureTable,
+    &CNL::workaroundTable,
     &CNL_2x4x8::gtSystemInfo,
     CNL::capabilityTable,
 };
 GT_SYSTEM_INFO CNL_2x4x8::gtSystemInfo = {0};
-void CNL_2x4x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void CNL_2x4x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 31;
     gtSysInfo->ThreadCount = 31 * CNL::threadsPerEu;
     gtSysInfo->SliceCount = 2;
@@ -126,16 +171,20 @@ void CNL_2x4x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = CNL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 const HardwareInfo CNL_1x3x8::hwInfo = {
     &CNL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &CNL::featureTable,
+    &CNL::workaroundTable,
     &CNL_1x3x8::gtSystemInfo,
     CNL::capabilityTable,
 };
 GT_SYSTEM_INFO CNL_1x3x8::gtSystemInfo = {0};
-void CNL_1x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void CNL_1x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 23;
     gtSysInfo->ThreadCount = 23 * CNL::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -154,16 +203,20 @@ void CNL_1x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = CNL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 const HardwareInfo CNL_1x2x8::hwInfo = {
     &CNL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &CNL::featureTable,
+    &CNL::workaroundTable,
     &CNL_1x2x8::gtSystemInfo,
     CNL::capabilityTable,
 };
 GT_SYSTEM_INFO CNL_1x2x8::gtSystemInfo = {0};
-void CNL_1x2x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void CNL_1x2x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 15;
     gtSysInfo->ThreadCount = 15 * CNL::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -182,16 +235,20 @@ void CNL_1x2x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = CNL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 const HardwareInfo CNL_4x9x8::hwInfo = {
     &CNL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &CNL::featureTable,
+    &CNL::workaroundTable,
     &CNL_4x9x8::gtSystemInfo,
     CNL::capabilityTable,
 };
 GT_SYSTEM_INFO CNL_4x9x8::gtSystemInfo = {0};
-void CNL_4x9x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void CNL_4x9x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 71;
     gtSysInfo->ThreadCount = 71 * CNL::threadsPerEu;
     gtSysInfo->SliceCount = 4;
@@ -210,27 +267,31 @@ void CNL_4x9x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = CNL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
-};
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
+}
+
 const HardwareInfo CNL::hwInfo = CNL_2x5x8::hwInfo;
 
-void setupCNLHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+void setupCNLHardwareInfoImpl(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig) {
     if (hwInfoConfig == "1x2x8") {
-        CNL_1x2x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CNL_1x2x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x3x8") {
-        CNL_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CNL_1x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "2x5x8") {
-        CNL_2x5x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CNL_2x5x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "2x4x8") {
-        CNL_2x4x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CNL_2x4x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "4x9x8") {
-        CNL_4x9x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CNL_4x9x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "default") {
         // Default config
-        CNL_2x5x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CNL_2x5x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else {
         UNRECOVERABLE_IF(true);
     }
 }
 
-void (*CNL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupCNLHardwareInfoImpl;
+void (*CNL::setupHardwareInfo)(HardwareInfo *, bool, const std::string &) = setupCNLHardwareInfoImpl;
 } // namespace NEO
diff --git a/runtime/gen10/linux/hw_info_config_cnl.inl b/runtime/gen10/linux/hw_info_config_cnl.inl
index 13e99a45b7..88030ba518 100644
--- a/runtime/gen10/linux/hw_info_config_cnl.inl
+++ b/runtime/gen10/linux/hw_info_config_cnl.inl
@@ -15,10 +15,12 @@ int HwInfoConfigHw<IGFX_CANNONLAKE>::configureHardwareCustom(HardwareInfo *hwInf
     if (nullptr == osIface) {
         return 0;
     }
-
-    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
     GT_SYSTEM_INFO *pSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
-    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+
+    pSkuTable->ftrGpGpuMidBatchPreempt = true;
+    pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
+    pSkuTable->ftrL3IACoherency = true;
 
     if (pSysInfo->SubSliceCount == 9) {
         pSysInfo->SliceCount = 4;
@@ -34,48 +36,6 @@ int HwInfoConfigHw<IGFX_CANNONLAKE>::configureHardwareCustom(HardwareInfo *hwInf
         pSysInfo->L3BankCount--;
         pSysInfo->L3CacheSizeInKb -= 256;
     }
-
-    pSkuTable->ftrGpGpuMidBatchPreempt = true;
-    pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
-    pSkuTable->ftrGpGpuMidThreadLevelPreempt = false;
-    pSkuTable->ftr3dMidBatchPreempt = true;
-    pSkuTable->ftr3dObjectLevelPreempt = true;
-    pSkuTable->ftr3dMidBatchPreempt = true;
-    pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
-    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
-
-    pSkuTable->ftrPPGTT = true;
-    pSkuTable->ftrSVM = true;
-    pSkuTable->ftrL3IACoherency = true;
-    pSkuTable->ftrIA32eGfxPTEs = true;
-    pSkuTable->ftrStandardMipTailFormat = true;
-
-    pSkuTable->ftrDisplayYTiling = true;
-    pSkuTable->ftrTranslationTable = true;
-    pSkuTable->ftrUserModeTranslationTable = true;
-    pSkuTable->ftrTileMappedResource = true;
-    pSkuTable->ftrEnableGuC = true;
-
-    pSkuTable->ftrFbc = true;
-    pSkuTable->ftrFbc2AddressTranslation = true;
-    pSkuTable->ftrFbcBlitterTracking = true;
-    pSkuTable->ftrFbcCpuTracking = true;
-
-    pSkuTable->ftrAstcHdr2D = true;
-    pSkuTable->ftrAstcLdr2D = true;
-    pSkuTable->ftrTileY = true;
-
-    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
-    pWaTable->waSendMIFLUSHBeforeVFE = true;
-    pWaTable->waReportPerfCountUseGlobalContextID = true;
-    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
-
-    if ((1 << hwInfo->pPlatform->usRevId) & 0x3) {
-        pWaTable->waFbcLinearSurfaceStride = true;
-    }
-    if ((1 << hwInfo->pPlatform->usRevId) & 0x1) {
-        pWaTable->waEncryptedEdramOnlyPartials = true;
-    }
     return 0;
 }
 
diff --git a/runtime/gen11/hw_cmds_icllp.h b/runtime/gen11/hw_cmds_icllp.h
index a5e64926e2..b415492c48 100644
--- a/runtime/gen11/hw_cmds_icllp.h
+++ b/runtime/gen11/hw_cmds_icllp.h
@@ -13,17 +13,20 @@ namespace NEO {
 struct ICLLP : public ICLFamily {
     static const PLATFORM platform;
     static const HardwareInfo hwInfo;
+    static FeatureTable featureTable;
+    static WorkaroundTable workaroundTable;
     static const uint32_t threadsPerEu = 7;
     static const uint32_t maxEuPerSubslice = 8;
     static const uint32_t maxSlicesSupported = 1;
     static const uint32_t maxSubslicesSupported = 8;
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
+    static void (*setupHardwareInfo)(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig);
+    static void setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo);
 };
 
 class ICLLP_1x8x8 : public ICLLP {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -32,7 +35,7 @@ class ICLLP_1x8x8 : public ICLLP {
 
 class ICLLP_1x4x8 : public ICLLP {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -40,7 +43,7 @@ class ICLLP_1x4x8 : public ICLLP {
 };
 class ICLLP_1x6x8 : public ICLLP {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -49,7 +52,7 @@ class ICLLP_1x6x8 : public ICLLP {
 
 class ICLLP_1x1x8 : public ICLLP {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
diff --git a/runtime/gen11/hw_cmds_lkf.h b/runtime/gen11/hw_cmds_lkf.h
index 036ee2da03..b17ea3935a 100644
--- a/runtime/gen11/hw_cmds_lkf.h
+++ b/runtime/gen11/hw_cmds_lkf.h
@@ -13,16 +13,19 @@ namespace NEO {
 struct LKF : public ICLFamily {
     static const PLATFORM platform;
     static const HardwareInfo hwInfo;
+    static FeatureTable featureTable;
+    static WorkaroundTable workaroundTable;
     static const uint32_t threadsPerEu = 7;
     static const uint32_t maxEuPerSubslice = 8;
     static const uint32_t maxSlicesSupported = 1;
     static const uint32_t maxSubslicesSupported = 8;
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
+    static void (*setupHardwareInfo)(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig);
+    static void setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo);
 };
 class LKF_1x8x8 : public LKF {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
diff --git a/runtime/gen11/hw_info_icllp.inl b/runtime/gen11/hw_info_icllp.inl
index cedd66a3d9..b672fb31f5 100644
--- a/runtime/gen11/hw_info_icllp.inl
+++ b/runtime/gen11/hw_info_icllp.inl
@@ -68,16 +68,48 @@ const RuntimeCapabilityTable ICLLP::capabilityTable{
     false                                            // supportCacheFlushAfterWalker
 };
 
+WorkaroundTable ICLLP::workaroundTable = {};
+FeatureTable ICLLP::featureTable = {};
+
+void ICLLP::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+
+    pSkuTable->ftrPPGTT = true;
+    pSkuTable->ftrSVM = true;
+    pSkuTable->ftrIA32eGfxPTEs = true;
+    pSkuTable->ftrStandardMipTailFormat = true;
+
+    pSkuTable->ftrDisplayYTiling = true;
+    pSkuTable->ftrTranslationTable = true;
+    pSkuTable->ftrUserModeTranslationTable = true;
+    pSkuTable->ftrTileMappedResource = true;
+    pSkuTable->ftrEnableGuC = true;
+
+    pSkuTable->ftrFbc = true;
+    pSkuTable->ftrFbc2AddressTranslation = true;
+    pSkuTable->ftrFbcBlitterTracking = true;
+    pSkuTable->ftrFbcCpuTracking = true;
+    pSkuTable->ftrTileY = true;
+
+    pSkuTable->ftrAstcHdr2D = true;
+    pSkuTable->ftrAstcLdr2D = true;
+
+    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
+    pWaTable->waReportPerfCountUseGlobalContextID = true;
+};
+
 const HardwareInfo ICLLP_1x8x8::hwInfo = {
     &ICLLP::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &ICLLP::featureTable,
+    &ICLLP::workaroundTable,
     &ICLLP_1x8x8::gtSystemInfo,
     ICLLP::capabilityTable,
 };
 
 GT_SYSTEM_INFO ICLLP_1x8x8::gtSystemInfo = {0};
-void ICLLP_1x8x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void ICLLP_1x8x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 63;
     gtSysInfo->ThreadCount = 63 * ICLLP::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -96,18 +128,22 @@ void ICLLP_1x8x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *fea
     gtSysInfo->MaxSubSlicesSupported = ICLLP::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo ICLLP_1x4x8::hwInfo = {
     &ICLLP::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &ICLLP::featureTable,
+    &ICLLP::workaroundTable,
     &ICLLP_1x4x8::gtSystemInfo,
     ICLLP::capabilityTable,
 };
 
 GT_SYSTEM_INFO ICLLP_1x4x8::gtSystemInfo = {0};
-void ICLLP_1x4x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void ICLLP_1x4x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 31;
     gtSysInfo->ThreadCount = 31 * ICLLP::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -126,17 +162,21 @@ void ICLLP_1x4x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *fea
     gtSysInfo->MaxSubSlicesSupported = 4;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 const HardwareInfo ICLLP_1x6x8::hwInfo = {
     &ICLLP::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &ICLLP::featureTable,
+    &ICLLP::workaroundTable,
     &ICLLP_1x6x8::gtSystemInfo,
     ICLLP::capabilityTable,
 };
 
 GT_SYSTEM_INFO ICLLP_1x6x8::gtSystemInfo = {0};
-void ICLLP_1x6x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void ICLLP_1x6x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 47;
     gtSysInfo->ThreadCount = 47 * ICLLP::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -155,17 +195,21 @@ void ICLLP_1x6x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *fea
     gtSysInfo->MaxSubSlicesSupported = 4;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo ICLLP_1x1x8::hwInfo = {
     &ICLLP::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &ICLLP::featureTable,
+    &ICLLP::workaroundTable,
     &ICLLP_1x1x8::gtSystemInfo,
     ICLLP::capabilityTable,
 };
 GT_SYSTEM_INFO ICLLP_1x1x8::gtSystemInfo = {0};
-void ICLLP_1x1x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void ICLLP_1x1x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 8;
     gtSysInfo->ThreadCount = 8 * ICLLP::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -184,26 +228,29 @@ void ICLLP_1x1x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *fea
     gtSysInfo->MaxSubSlicesSupported = 4;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo ICLLP::hwInfo = ICLLP_1x8x8::hwInfo;
 
-void setupICLLPHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+void setupICLLPHardwareInfoImpl(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig) {
     if (hwInfoConfig == "1x8x8") {
-        ICLLP_1x8x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        ICLLP_1x8x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x4x8") {
-        ICLLP_1x4x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        ICLLP_1x4x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x6x8") {
-        ICLLP_1x6x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        ICLLP_1x6x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x1x8") {
-        ICLLP_1x1x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        ICLLP_1x1x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "default") {
         // Default config
-        ICLLP_1x8x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        ICLLP_1x8x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else {
         UNRECOVERABLE_IF(true);
     }
-} // namespace NEO
+}
 
-void (*ICLLP::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupICLLPHardwareInfoImpl;
+void (*ICLLP::setupHardwareInfo)(HardwareInfo *, bool, const std::string &) = setupICLLPHardwareInfoImpl;
 } // namespace NEO
diff --git a/runtime/gen11/hw_info_lkf.inl b/runtime/gen11/hw_info_lkf.inl
index 56df4b197a..e627dd1fd5 100644
--- a/runtime/gen11/hw_info_lkf.inl
+++ b/runtime/gen11/hw_info_lkf.inl
@@ -67,15 +67,47 @@ const RuntimeCapabilityTable LKF::capabilityTable{
     false                                          // supportCacheFlushAfterWalker
 };
 
+WorkaroundTable LKF::workaroundTable = {};
+FeatureTable LKF::featureTable = {};
+
+void LKF::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+
+    pSkuTable->ftrPPGTT = true;
+    pSkuTable->ftrSVM = true;
+    pSkuTable->ftrIA32eGfxPTEs = true;
+    pSkuTable->ftrStandardMipTailFormat = true;
+
+    pSkuTable->ftrDisplayYTiling = true;
+    pSkuTable->ftrTranslationTable = true;
+    pSkuTable->ftrUserModeTranslationTable = true;
+    pSkuTable->ftrTileMappedResource = true;
+    pSkuTable->ftrEnableGuC = true;
+
+    pSkuTable->ftrFbc = true;
+    pSkuTable->ftrFbc2AddressTranslation = true;
+    pSkuTable->ftrFbcBlitterTracking = true;
+    pSkuTable->ftrFbcCpuTracking = true;
+    pSkuTable->ftrTileY = true;
+
+    pSkuTable->ftrAstcHdr2D = true;
+    pSkuTable->ftrAstcLdr2D = true;
+
+    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
+    pWaTable->waReportPerfCountUseGlobalContextID = true;
+};
+
 const HardwareInfo LKF_1x8x8::hwInfo = {
     &LKF::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &LKF::featureTable,
+    &LKF::workaroundTable,
     &LKF_1x8x8::gtSystemInfo,
     LKF::capabilityTable,
 };
 GT_SYSTEM_INFO LKF_1x8x8::gtSystemInfo = {0};
-void LKF_1x8x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void LKF_1x8x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 64;
     gtSysInfo->ThreadCount = 64 * LKF::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -94,20 +126,23 @@ void LKF_1x8x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = LKF::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo LKF::hwInfo = LKF_1x8x8::hwInfo;
 
-void setupLKFHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+void setupLKFHardwareInfoImpl(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig) {
     if (hwInfoConfig == "1x8x8") {
-        LKF_1x8x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        LKF_1x8x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "default") {
         // Default config
-        LKF_1x8x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        LKF_1x8x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else {
         UNRECOVERABLE_IF(true);
     }
-} // namespace NEO
+}
 
-void (*LKF::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupLKFHardwareInfoImpl;
+void (*LKF::setupHardwareInfo)(HardwareInfo *, bool, const std::string &) = setupLKFHardwareInfoImpl;
 } // namespace NEO
diff --git a/runtime/gen11/linux/hw_info_config_icllp.inl b/runtime/gen11/linux/hw_info_config_icllp.inl
index 599e1c45b9..215e3590aa 100644
--- a/runtime/gen11/linux/hw_info_config_icllp.inl
+++ b/runtime/gen11/linux/hw_info_config_icllp.inl
@@ -18,33 +18,9 @@ int HwInfoConfigHw<IGFX_ICELAKE_LP>::configureHardwareCustom(HardwareInfo *hwInf
 
     FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
     GT_SYSTEM_INFO *pSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
-    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
 
     pSysInfo->SliceCount = 1;
-
-    pSkuTable->ftrPPGTT = true;
-    pSkuTable->ftrSVM = true;
     pSkuTable->ftrL3IACoherency = true;
-    pSkuTable->ftrIA32eGfxPTEs = true;
-    pSkuTable->ftrStandardMipTailFormat = true;
-
-    pSkuTable->ftrDisplayYTiling = true;
-    pSkuTable->ftrTranslationTable = true;
-    pSkuTable->ftrUserModeTranslationTable = true;
-    pSkuTable->ftrTileMappedResource = true;
-    pSkuTable->ftrEnableGuC = true;
-
-    pSkuTable->ftrFbc = true;
-    pSkuTable->ftrFbc2AddressTranslation = true;
-    pSkuTable->ftrFbcBlitterTracking = true;
-    pSkuTable->ftrFbcCpuTracking = true;
-    pSkuTable->ftrTileY = true;
-
-    pSkuTable->ftrAstcHdr2D = true;
-    pSkuTable->ftrAstcLdr2D = true;
-
-    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
-    pWaTable->waReportPerfCountUseGlobalContextID = true;
 
     return 0;
 }
diff --git a/runtime/gen11/linux/hw_info_config_lkf.inl b/runtime/gen11/linux/hw_info_config_lkf.inl
index c1a0508f4e..4f75be8d57 100644
--- a/runtime/gen11/linux/hw_info_config_lkf.inl
+++ b/runtime/gen11/linux/hw_info_config_lkf.inl
@@ -18,33 +18,9 @@ int HwInfoConfigHw<IGFX_LAKEFIELD>::configureHardwareCustom(HardwareInfo *hwInfo
 
     FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
     GT_SYSTEM_INFO *pSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
-    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
 
     pSysInfo->SliceCount = 1;
-
-    pSkuTable->ftrPPGTT = true;
-    pSkuTable->ftrSVM = true;
     pSkuTable->ftrL3IACoherency = true;
-    pSkuTable->ftrIA32eGfxPTEs = true;
-    pSkuTable->ftrStandardMipTailFormat = true;
-
-    pSkuTable->ftrDisplayYTiling = true;
-    pSkuTable->ftrTranslationTable = true;
-    pSkuTable->ftrUserModeTranslationTable = true;
-    pSkuTable->ftrTileMappedResource = true;
-    pSkuTable->ftrEnableGuC = true;
-
-    pSkuTable->ftrFbc = true;
-    pSkuTable->ftrFbc2AddressTranslation = true;
-    pSkuTable->ftrFbcBlitterTracking = true;
-    pSkuTable->ftrFbcCpuTracking = true;
-    pSkuTable->ftrTileY = true;
-
-    pSkuTable->ftrAstcHdr2D = true;
-    pSkuTable->ftrAstcLdr2D = true;
-
-    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
-    pWaTable->waReportPerfCountUseGlobalContextID = true;
 
     return 0;
 }
diff --git a/runtime/gen8/hw_cmds_bdw.h b/runtime/gen8/hw_cmds_bdw.h
index ea499dc287..6c57c5baa4 100644
--- a/runtime/gen8/hw_cmds_bdw.h
+++ b/runtime/gen8/hw_cmds_bdw.h
@@ -15,16 +15,19 @@ namespace NEO {
 struct BDW : public BDWFamily {
     static const PLATFORM platform;
     static const HardwareInfo hwInfo;
+    static FeatureTable featureTable;
+    static WorkaroundTable workaroundTable;
     static const uint32_t threadsPerEu = 7;
     static const uint32_t maxEuPerSubslice = 8;
     static const uint32_t maxSlicesSupported = 2;
     static const uint32_t maxSubslicesSupported = 6;
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
+    static void (*setupHardwareInfo)(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig);
+    static void setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo);
 };
 class BDW_1x2x6 : public BDW {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -32,7 +35,7 @@ class BDW_1x2x6 : public BDW {
 };
 class BDW_1x3x6 : public BDW {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -40,7 +43,7 @@ class BDW_1x3x6 : public BDW {
 };
 class BDW_1x3x8 : public BDW {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -48,7 +51,7 @@ class BDW_1x3x8 : public BDW {
 };
 class BDW_2x3x8 : public BDW {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
diff --git a/runtime/gen8/hw_info_bdw.inl b/runtime/gen8/hw_info_bdw.inl
index f298451296..9e04062a12 100644
--- a/runtime/gen8/hw_info_bdw.inl
+++ b/runtime/gen8/hw_info_bdw.inl
@@ -72,15 +72,40 @@ const RuntimeCapabilityTable BDW::capabilityTable{
     false                                          // supportCacheFlushAfterWalker
 };
 
+WorkaroundTable BDW::workaroundTable = {};
+FeatureTable BDW::featureTable = {};
+
+void BDW::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+
+    pSkuTable->ftrPPGTT = true;
+    pSkuTable->ftrSVM = true;
+    pSkuTable->ftrIA32eGfxPTEs = true;
+    pSkuTable->ftrFbc = true;
+    pSkuTable->ftrFbc2AddressTranslation = true;
+    pSkuTable->ftrFbcBlitterTracking = true;
+    pSkuTable->ftrFbcCpuTracking = true;
+    pSkuTable->ftrTileY = true;
+
+    pWaTable->waDisableLSQCROPERFforOCL = true;
+    pWaTable->waReportPerfCountUseGlobalContextID = true;
+    pWaTable->waUseVAlign16OnTileXYBpp816 = true;
+    pWaTable->waModifyVFEStateAfterGPGPUPreemption = true;
+    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
+}
+
 const HardwareInfo BDW_1x2x6::hwInfo = {
     &BDW::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &BDW::featureTable,
+    &BDW::workaroundTable,
     &BDW_1x2x6::gtSystemInfo,
     BDW::capabilityTable,
 };
+
 GT_SYSTEM_INFO BDW_1x2x6::gtSystemInfo = {0};
-void BDW_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void BDW_1x2x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 12;
     gtSysInfo->ThreadCount = 12 * BDW::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -99,17 +124,21 @@ void BDW_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = BDW::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo BDW_1x3x6::hwInfo = {
     &BDW::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &BDW::featureTable,
+    &BDW::workaroundTable,
     &BDW_1x3x6::gtSystemInfo,
     BDW::capabilityTable,
 };
 GT_SYSTEM_INFO BDW_1x3x6::gtSystemInfo = {0};
-void BDW_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void BDW_1x3x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 18;
     gtSysInfo->ThreadCount = 18 * BDW::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -128,17 +157,21 @@ void BDW_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = BDW::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo BDW_1x3x8::hwInfo = {
     &BDW::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &BDW::featureTable,
+    &BDW::workaroundTable,
     &BDW_1x3x8::gtSystemInfo,
     BDW::capabilityTable,
 };
 GT_SYSTEM_INFO BDW_1x3x8::gtSystemInfo = {0};
-void BDW_1x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void BDW_1x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 23;
     gtSysInfo->ThreadCount = 23 * BDW::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -157,17 +190,21 @@ void BDW_1x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = BDW::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo BDW_2x3x8::hwInfo = {
     &BDW::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &BDW::featureTable,
+    &BDW::workaroundTable,
     &BDW_2x3x8::gtSystemInfo,
     BDW::capabilityTable,
 };
 GT_SYSTEM_INFO BDW_2x3x8::gtSystemInfo = {0};
-void BDW_2x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void BDW_2x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 47;
     gtSysInfo->ThreadCount = 47 * BDW::threadsPerEu;
     gtSysInfo->SliceCount = 2;
@@ -186,26 +223,29 @@ void BDW_2x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = BDW::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo BDW::hwInfo = BDW_1x3x8::hwInfo;
 
-void setupBDWHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+void setupBDWHardwareInfoImpl(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig) {
     if (hwInfoConfig == "2x3x8") {
-        BDW_2x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        BDW_2x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x3x8") {
-        BDW_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        BDW_1x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x3x6") {
-        BDW_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        BDW_1x3x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x2x6") {
-        BDW_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        BDW_1x2x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "default") {
         // Default config
-        BDW_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        BDW_1x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else {
         UNRECOVERABLE_IF(true);
     }
 }
 
-void (*BDW::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupBDWHardwareInfoImpl;
+void (*BDW::setupHardwareInfo)(HardwareInfo *, bool, const std::string &) = setupBDWHardwareInfoImpl;
 } // namespace NEO
diff --git a/runtime/gen8/linux/hw_info_config_bdw.inl b/runtime/gen8/linux/hw_info_config_bdw.inl
index 25b081d3b1..786618a443 100644
--- a/runtime/gen8/linux/hw_info_config_bdw.inl
+++ b/runtime/gen8/linux/hw_info_config_bdw.inl
@@ -15,10 +15,10 @@ int HwInfoConfigHw<IGFX_BROADWELL>::configureHardwareCustom(HardwareInfo *hwInfo
     if (nullptr == osIface) {
         return 0;
     }
-
-    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
     GT_SYSTEM_INFO *pSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
-    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+
+    pSkuTable->ftrL3IACoherency = true;
 
     // There is no interface to read total slice count from drm/i915, so we
     // derive this from the number of EUs and subslices.
@@ -29,23 +29,6 @@ int HwInfoConfigHw<IGFX_BROADWELL>::configureHardwareCustom(HardwareInfo *hwInfo
         pSysInfo->SliceCount = 1;
     }
 
-    pSkuTable->ftrPPGTT = true;
-    pSkuTable->ftrSVM = true;
-    pSkuTable->ftrL3IACoherency = true;
-    pSkuTable->ftrIA32eGfxPTEs = true;
-
-    pSkuTable->ftrFbc = true;
-    pSkuTable->ftrFbc2AddressTranslation = true;
-    pSkuTable->ftrFbcBlitterTracking = true;
-    pSkuTable->ftrFbcCpuTracking = true;
-    pSkuTable->ftrTileY = true;
-
-    pWaTable->waDisableLSQCROPERFforOCL = true;
-    pWaTable->waReportPerfCountUseGlobalContextID = true;
-    pWaTable->waUseVAlign16OnTileXYBpp816 = true;
-    pWaTable->waModifyVFEStateAfterGPGPUPreemption = true;
-    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
-
     if (hwInfo->pPlatform->usDeviceID == IBDW_GT3_HALO_MOBL_DEVICE_F0_ID ||
         hwInfo->pPlatform->usDeviceID == IBDW_GT3_SERV_DEVICE_F0_ID) {
         pSysInfo->EdramSizeInKb = 128 * 1024;
diff --git a/runtime/gen9/hw_cmds_bxt.h b/runtime/gen9/hw_cmds_bxt.h
index 58ada06daa..fa53682fcf 100644
--- a/runtime/gen9/hw_cmds_bxt.h
+++ b/runtime/gen9/hw_cmds_bxt.h
@@ -13,19 +13,21 @@ namespace NEO {
 struct BXT : public SKLFamily {
     static const PLATFORM platform;
     static const HardwareInfo hwInfo;
-
+    static FeatureTable featureTable;
+    static WorkaroundTable workaroundTable;
     static const uint32_t threadsPerEu = 6;
     static const uint32_t maxEuPerSubslice = 6;
     static const uint32_t maxSlicesSupported = 1;
     static const uint32_t maxSubslicesSupported = 3;
 
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
+    static void (*setupHardwareInfo)(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig);
+    static void setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo);
 };
 
 class BXT_1x2x6 : public BXT {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -34,7 +36,7 @@ class BXT_1x2x6 : public BXT {
 
 class BXT_1x3x6 : public BXT {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
diff --git a/runtime/gen9/hw_cmds_cfl.h b/runtime/gen9/hw_cmds_cfl.h
index 2a2a8d3ddf..4a29548ee1 100644
--- a/runtime/gen9/hw_cmds_cfl.h
+++ b/runtime/gen9/hw_cmds_cfl.h
@@ -13,19 +13,21 @@ namespace NEO {
 struct CFL : public SKLFamily {
     static const PLATFORM platform;
     static const HardwareInfo hwInfo;
-
+    static FeatureTable featureTable;
+    static WorkaroundTable workaroundTable;
     static const uint32_t threadsPerEu = 7;
     static const uint32_t maxEuPerSubslice = 8;
     static const uint32_t maxSlicesSupported = 3;
     static const uint32_t maxSubslicesSupported = 9;
 
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
+    static void (*setupHardwareInfo)(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig);
+    static void setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo);
 };
 
 class CFL_1x2x6 : public CFL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -34,7 +36,7 @@ class CFL_1x2x6 : public CFL {
 
 class CFL_1x3x6 : public CFL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -43,7 +45,7 @@ class CFL_1x3x6 : public CFL {
 
 class CFL_1x3x8 : public CFL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -52,7 +54,7 @@ class CFL_1x3x8 : public CFL {
 
 class CFL_2x3x8 : public CFL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -61,7 +63,7 @@ class CFL_2x3x8 : public CFL {
 
 class CFL_3x3x8 : public CFL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
diff --git a/runtime/gen9/hw_cmds_glk.h b/runtime/gen9/hw_cmds_glk.h
index 6a33c0f1e3..c95f053c3a 100644
--- a/runtime/gen9/hw_cmds_glk.h
+++ b/runtime/gen9/hw_cmds_glk.h
@@ -13,19 +13,21 @@ namespace NEO {
 struct GLK : public SKLFamily {
     static const PLATFORM platform;
     static const HardwareInfo hwInfo;
-
+    static FeatureTable featureTable;
+    static WorkaroundTable workaroundTable;
     static const uint32_t threadsPerEu = 6;
     static const uint32_t maxEuPerSubslice = 6;
     static const uint32_t maxSlicesSupported = 1;
     static const uint32_t maxSubslicesSupported = 3;
 
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
+    static void (*setupHardwareInfo)(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig);
+    static void setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo);
 };
 
 class GLK_1x3x6 : public GLK {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -34,7 +36,7 @@ class GLK_1x3x6 : public GLK {
 
 class GLK_1x2x6 : public GLK {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
diff --git a/runtime/gen9/hw_cmds_kbl.h b/runtime/gen9/hw_cmds_kbl.h
index 007bff1e07..a897a4a3b5 100644
--- a/runtime/gen9/hw_cmds_kbl.h
+++ b/runtime/gen9/hw_cmds_kbl.h
@@ -13,19 +13,21 @@ namespace NEO {
 struct KBL : public SKLFamily {
     static const PLATFORM platform;
     static const HardwareInfo hwInfo;
-
+    static FeatureTable featureTable;
+    static WorkaroundTable workaroundTable;
     static const uint32_t threadsPerEu = 7;
     static const uint32_t maxEuPerSubslice = 8;
     static const uint32_t maxSlicesSupported = 3;
     static const uint32_t maxSubslicesSupported = 9;
 
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
+    static void (*setupHardwareInfo)(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig);
+    static void setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo);
 };
 
 class KBL_1x2x6 : public KBL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -34,7 +36,7 @@ class KBL_1x2x6 : public KBL {
 
 class KBL_1x3x6 : public KBL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -43,7 +45,7 @@ class KBL_1x3x6 : public KBL {
 
 class KBL_1x3x8 : public KBL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -52,7 +54,7 @@ class KBL_1x3x8 : public KBL {
 
 class KBL_2x3x8 : public KBL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -61,7 +63,7 @@ class KBL_2x3x8 : public KBL {
 
 class KBL_3x3x8 : public KBL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
diff --git a/runtime/gen9/hw_cmds_skl.h b/runtime/gen9/hw_cmds_skl.h
index 5bec22ed59..ca5f2c6785 100644
--- a/runtime/gen9/hw_cmds_skl.h
+++ b/runtime/gen9/hw_cmds_skl.h
@@ -13,19 +13,21 @@ namespace NEO {
 struct SKL : public SKLFamily {
     static const PLATFORM platform;
     static const HardwareInfo hwInfo;
-
+    static FeatureTable featureTable;
+    static WorkaroundTable workaroundTable;
     static const uint32_t threadsPerEu = 7;
     static const uint32_t maxEuPerSubslice = 8;
     static const uint32_t maxSlicesSupported = 3;
     static const uint32_t maxSubslicesSupported = 9;
 
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
+    static void (*setupHardwareInfo)(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig);
+    static void setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo);
 };
 
 class SKL_1x2x6 : public SKL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -34,7 +36,7 @@ class SKL_1x2x6 : public SKL {
 
 class SKL_1x3x6 : public SKL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -43,7 +45,7 @@ class SKL_1x3x6 : public SKL {
 
 class SKL_1x3x8 : public SKL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -52,7 +54,7 @@ class SKL_1x3x8 : public SKL {
 
 class SKL_2x3x8 : public SKL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
@@ -61,7 +63,7 @@ class SKL_2x3x8 : public SKL {
 
 class SKL_3x3x8 : public SKL {
   public:
-    static void setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable);
     static const HardwareInfo hwInfo;
 
   private:
diff --git a/runtime/gen9/hw_info_bxt.inl b/runtime/gen9/hw_info_bxt.inl
index cf406d654a..2bdab4db43 100644
--- a/runtime/gen9/hw_info_bxt.inl
+++ b/runtime/gen9/hw_info_bxt.inl
@@ -69,15 +69,58 @@ const RuntimeCapabilityTable BXT::capabilityTable{
     false                                          // supportCacheFlushAfterWalker
 };
 
+WorkaroundTable BXT::workaroundTable = {};
+FeatureTable BXT::featureTable = {};
+
+void BXT::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
+    PLATFORM *pPlatform = const_cast<PLATFORM *>(hwInfo->pPlatform);
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+
+    pSkuTable->ftrVEBOX = true;
+    pSkuTable->ftrULT = true;
+    pSkuTable->ftrGpGpuMidThreadLevelPreempt = true;
+    pSkuTable->ftr3dMidBatchPreempt = true;
+    pSkuTable->ftr3dObjectLevelPreempt = true;
+    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
+    pSkuTable->ftrLCIA = true;
+    pSkuTable->ftrPPGTT = true;
+    pSkuTable->ftrIA32eGfxPTEs = true;
+    pSkuTable->ftrDisplayYTiling = true;
+    pSkuTable->ftrTranslationTable = true;
+    pSkuTable->ftrUserModeTranslationTable = true;
+    pSkuTable->ftrEnableGuC = true;
+    pSkuTable->ftrFbc = true;
+    pSkuTable->ftrFbc2AddressTranslation = true;
+    pSkuTable->ftrFbcBlitterTracking = true;
+    pSkuTable->ftrFbcCpuTracking = true;
+    pSkuTable->ftrTileY = true;
+
+    if (pPlatform->usRevId >= 3) {
+        pSkuTable->ftrGttCacheInvalidation = true;
+    }
+
+    pWaTable->waLLCCachingUnsupported = true;
+    pWaTable->waMsaa8xTileYDepthPitchAlignment = true;
+    pWaTable->waFbcLinearSurfaceStride = true;
+    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
+    pWaTable->waEnablePreemptionGranularityControlByUMD = true;
+    pWaTable->waSendMIFLUSHBeforeVFE = true;
+    pWaTable->waForcePcBbFullCfgRestore = true;
+    pWaTable->waReportPerfCountUseGlobalContextID = true;
+    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
+}
+
 const HardwareInfo BXT_1x2x6::hwInfo = {
     &BXT::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &BXT::featureTable,
+    &BXT::workaroundTable,
     &BXT_1x2x6::gtSystemInfo,
     BXT::capabilityTable,
 };
 GT_SYSTEM_INFO BXT_1x2x6::gtSystemInfo = {0};
-void BXT_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void BXT_1x2x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 12;
     gtSysInfo->ThreadCount = 12 * BXT::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -96,17 +139,21 @@ void BXT_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = BXT::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo BXT_1x3x6::hwInfo = {
     &BXT::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &BXT::featureTable,
+    &BXT::workaroundTable,
     &BXT_1x3x6::gtSystemInfo,
     BXT::capabilityTable,
 };
 GT_SYSTEM_INFO BXT_1x3x6::gtSystemInfo = {0};
-void BXT_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void BXT_1x3x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 18;
     gtSysInfo->ThreadCount = 18 * BXT::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -125,22 +172,25 @@ void BXT_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = BXT::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo BXT::hwInfo = BXT_1x3x6::hwInfo;
 
-void setupBXTHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+void setupBXTHardwareInfoImpl(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig) {
     if (hwInfoConfig == "1x2x6") {
-        BXT_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        BXT_1x2x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x3x6") {
-        BXT_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        BXT_1x3x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "default") {
         // Default config
-        BXT_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        BXT_1x3x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else {
         UNRECOVERABLE_IF(true);
     }
 }
 
-void (*BXT::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupBXTHardwareInfoImpl;
+void (*BXT::setupHardwareInfo)(HardwareInfo *, bool, const std::string &) = setupBXTHardwareInfoImpl;
 } // namespace NEO
diff --git a/runtime/gen9/hw_info_cfl.inl b/runtime/gen9/hw_info_cfl.inl
index 27732cb39c..66bf54e934 100644
--- a/runtime/gen9/hw_info_cfl.inl
+++ b/runtime/gen9/hw_info_cfl.inl
@@ -64,15 +64,51 @@ const RuntimeCapabilityTable CFL::capabilityTable{
     false                                          // supportCacheFlushAfterWalker
 };
 
+WorkaroundTable CFL::workaroundTable = {};
+FeatureTable CFL::featureTable = {};
+
+void CFL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+
+    pSkuTable->ftrVEBOX = true;
+    pSkuTable->ftrGpGpuMidThreadLevelPreempt = false;
+    pSkuTable->ftr3dMidBatchPreempt = true;
+    pSkuTable->ftr3dObjectLevelPreempt = true;
+    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
+    pSkuTable->ftrPPGTT = true;
+    pSkuTable->ftrSVM = true;
+    pSkuTable->ftrIA32eGfxPTEs = true;
+    pSkuTable->ftrDisplayYTiling = true;
+    pSkuTable->ftrTranslationTable = true;
+    pSkuTable->ftrUserModeTranslationTable = true;
+    pSkuTable->ftrEnableGuC = true;
+    pSkuTable->ftrFbc = true;
+    pSkuTable->ftrFbc2AddressTranslation = true;
+    pSkuTable->ftrFbcBlitterTracking = true;
+    pSkuTable->ftrFbcCpuTracking = true;
+    pSkuTable->ftrTileY = true;
+
+    pWaTable->waEnablePreemptionGranularityControlByUMD = true;
+    pWaTable->waSendMIFLUSHBeforeVFE = true;
+    pWaTable->waReportPerfCountUseGlobalContextID = true;
+    pWaTable->waMsaa8xTileYDepthPitchAlignment = true;
+    pWaTable->waLosslessCompressionSurfaceStride = true;
+    pWaTable->waFbcLinearSurfaceStride = true;
+    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
+    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
+}
+
 const HardwareInfo CFL_1x2x6::hwInfo = {
     &CFL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &CFL::featureTable,
+    &CFL::workaroundTable,
     &CFL_1x2x6::gtSystemInfo,
     CFL::capabilityTable,
 };
 GT_SYSTEM_INFO CFL_1x2x6::gtSystemInfo = {0};
-void CFL_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void CFL_1x2x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 11;
     gtSysInfo->ThreadCount = 11 * CFL::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -91,17 +127,21 @@ void CFL_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = CFL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo CFL_1x3x6::hwInfo = {
     &CFL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &CFL::featureTable,
+    &CFL::workaroundTable,
     &CFL_1x3x6::gtSystemInfo,
     CFL::capabilityTable,
 };
 GT_SYSTEM_INFO CFL_1x3x6::gtSystemInfo = {0};
-void CFL_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void CFL_1x3x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 17;
     gtSysInfo->ThreadCount = 17 * CFL::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -120,17 +160,21 @@ void CFL_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = CFL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo CFL_1x3x8::hwInfo = {
     &CFL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &CFL::featureTable,
+    &CFL::workaroundTable,
     &CFL_1x3x8::gtSystemInfo,
     CFL::capabilityTable,
 };
 GT_SYSTEM_INFO CFL_1x3x8::gtSystemInfo = {0};
-void CFL_1x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void CFL_1x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 23;
     gtSysInfo->ThreadCount = 23 * CFL::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -149,17 +193,21 @@ void CFL_1x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = CFL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo CFL_2x3x8::hwInfo = {
     &CFL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &CFL::featureTable,
+    &CFL::workaroundTable,
     &CFL_2x3x8::gtSystemInfo,
     CFL::capabilityTable,
 };
 GT_SYSTEM_INFO CFL_2x3x8::gtSystemInfo = {0};
-void CFL_2x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void CFL_2x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 47;
     gtSysInfo->ThreadCount = 47 * CFL::threadsPerEu;
     gtSysInfo->SliceCount = 2;
@@ -178,17 +226,21 @@ void CFL_2x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = CFL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo CFL_3x3x8::hwInfo = {
     &CFL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &CFL::featureTable,
+    &CFL::workaroundTable,
     &CFL_3x3x8::gtSystemInfo,
     CFL::capabilityTable,
 };
 GT_SYSTEM_INFO CFL_3x3x8::gtSystemInfo = {0};
-void CFL_3x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void CFL_3x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 71;
     gtSysInfo->ThreadCount = 71 * CFL::threadsPerEu;
     gtSysInfo->SliceCount = 3;
@@ -207,28 +259,31 @@ void CFL_3x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = CFL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo CFL::hwInfo = CFL_1x3x6::hwInfo;
 
-void setupCFLHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+void setupCFLHardwareInfoImpl(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig) {
     if (hwInfoConfig == "1x3x8") {
-        CFL_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CFL_1x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "2x3x8") {
-        CFL_2x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CFL_2x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "3x3x8") {
-        CFL_3x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CFL_3x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x2x6") {
-        CFL_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CFL_1x2x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x3x6") {
-        CFL_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CFL_1x3x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "default") {
         // Default config
-        CFL_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        CFL_1x3x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else {
         UNRECOVERABLE_IF(true);
     }
 }
 
-void (*CFL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupCFLHardwareInfoImpl;
+void (*CFL::setupHardwareInfo)(HardwareInfo *, bool, const std::string &) = setupCFLHardwareInfoImpl;
 } // namespace NEO
diff --git a/runtime/gen9/hw_info_glk.inl b/runtime/gen9/hw_info_glk.inl
index 0821f9a157..4c0ea4a185 100644
--- a/runtime/gen9/hw_info_glk.inl
+++ b/runtime/gen9/hw_info_glk.inl
@@ -64,15 +64,51 @@ const RuntimeCapabilityTable GLK::capabilityTable{
     false                                          // supportCacheFlushAfterWalker
 };
 
+WorkaroundTable GLK::workaroundTable = {};
+FeatureTable GLK::featureTable = {};
+
+void GLK::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+
+    pSkuTable->ftrGpGpuMidThreadLevelPreempt = false;
+    pSkuTable->ftr3dMidBatchPreempt = true;
+    pSkuTable->ftr3dObjectLevelPreempt = true;
+    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
+    pSkuTable->ftrLCIA = true;
+    pSkuTable->ftrPPGTT = true;
+    pSkuTable->ftrIA32eGfxPTEs = true;
+    pSkuTable->ftrTranslationTable = true;
+    pSkuTable->ftrUserModeTranslationTable = true;
+    pSkuTable->ftrEnableGuC = true;
+    pSkuTable->ftrTileMappedResource = true;
+    pSkuTable->ftrULT = true;
+    pSkuTable->ftrAstcHdr2D = true;
+    pSkuTable->ftrAstcLdr2D = true;
+    pSkuTable->ftrTileY = true;
+
+    pWaTable->waLLCCachingUnsupported = true;
+    pWaTable->waMsaa8xTileYDepthPitchAlignment = true;
+    pWaTable->waFbcLinearSurfaceStride = true;
+    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
+    pWaTable->waEnablePreemptionGranularityControlByUMD = true;
+    pWaTable->waSendMIFLUSHBeforeVFE = true;
+    pWaTable->waForcePcBbFullCfgRestore = true;
+    pWaTable->waReportPerfCountUseGlobalContextID = true;
+    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
+}
+
 const HardwareInfo GLK_1x3x6::hwInfo = {
     &GLK::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &GLK::featureTable,
+    &GLK::workaroundTable,
     &GLK_1x3x6::gtSystemInfo,
     GLK::capabilityTable,
 };
+
 GT_SYSTEM_INFO GLK_1x3x6::gtSystemInfo = {0};
-void GLK_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void GLK_1x3x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 18;
     gtSysInfo->ThreadCount = 18 * GLK::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -91,17 +127,21 @@ void GLK_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = GLK::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo GLK_1x2x6::hwInfo = {
     &GLK::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &GLK::featureTable,
+    &GLK::workaroundTable,
     &GLK_1x2x6::gtSystemInfo,
     GLK::capabilityTable,
 };
 GT_SYSTEM_INFO GLK_1x2x6::gtSystemInfo = {0};
-void GLK_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void GLK_1x2x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 12;
     gtSysInfo->ThreadCount = 12 * GLK::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -120,22 +160,25 @@ void GLK_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = GLK::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo GLK::hwInfo = GLK_1x3x6::hwInfo;
 
-void setupGLKHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+void setupGLKHardwareInfoImpl(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig) {
     if (hwInfoConfig == "1x2x6") {
-        GLK_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        GLK_1x2x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x3x6") {
-        GLK_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        GLK_1x3x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "default") {
         // Default config
-        GLK_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        GLK_1x3x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else {
         UNRECOVERABLE_IF(true);
     }
 }
 
-void (*GLK::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupGLKHardwareInfoImpl;
+void (*GLK::setupHardwareInfo)(HardwareInfo *, bool, const std::string &) = setupGLKHardwareInfoImpl;
 } // namespace NEO
diff --git a/runtime/gen9/hw_info_kbl.inl b/runtime/gen9/hw_info_kbl.inl
index 5049c6fc37..59559a8f15 100644
--- a/runtime/gen9/hw_info_kbl.inl
+++ b/runtime/gen9/hw_info_kbl.inl
@@ -64,15 +64,60 @@ const RuntimeCapabilityTable KBL::capabilityTable{
     false                                          // supportCacheFlushAfterWalker
 };
 
+WorkaroundTable KBL::workaroundTable = {};
+FeatureTable KBL::featureTable = {};
+
+void KBL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
+    PLATFORM *pPlatform = const_cast<PLATFORM *>(hwInfo->pPlatform);
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+
+    pSkuTable->ftrVEBOX = true;
+    pSkuTable->ftrGpGpuMidThreadLevelPreempt = true;
+    pSkuTable->ftr3dMidBatchPreempt = true;
+    pSkuTable->ftr3dObjectLevelPreempt = true;
+    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
+    pSkuTable->ftrPPGTT = true;
+    pSkuTable->ftrSVM = true;
+    pSkuTable->ftrIA32eGfxPTEs = true;
+    pSkuTable->ftrDisplayYTiling = true;
+    pSkuTable->ftrTranslationTable = true;
+    pSkuTable->ftrUserModeTranslationTable = true;
+    pSkuTable->ftrEnableGuC = true;
+    pSkuTable->ftrFbc = true;
+    pSkuTable->ftrFbc2AddressTranslation = true;
+    pSkuTable->ftrFbcBlitterTracking = true;
+    pSkuTable->ftrFbcCpuTracking = true;
+    pSkuTable->ftrTileY = true;
+
+    pWaTable->waEnablePreemptionGranularityControlByUMD = true;
+    pWaTable->waSendMIFLUSHBeforeVFE = true;
+    pWaTable->waReportPerfCountUseGlobalContextID = true;
+    pWaTable->waMsaa8xTileYDepthPitchAlignment = true;
+    pWaTable->waLosslessCompressionSurfaceStride = true;
+    pWaTable->waFbcLinearSurfaceStride = true;
+    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
+    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
+
+    if (pPlatform->usRevId <= 0x6) {
+        pWaTable->waDisableLSQCROPERFforOCL = true;
+        pWaTable->waEncryptedEdramOnlyPartials = true;
+    }
+    if (pPlatform->usRevId <= 0x8) {
+        pWaTable->waForcePcBbFullCfgRestore = true;
+    }
+}
+
 const HardwareInfo KBL_1x2x6::hwInfo = {
     &KBL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &KBL::featureTable,
+    &KBL::workaroundTable,
     &KBL_1x2x6::gtSystemInfo,
     KBL::capabilityTable,
 };
 GT_SYSTEM_INFO KBL_1x2x6::gtSystemInfo = {0};
-void KBL_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void KBL_1x2x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 11;
     gtSysInfo->ThreadCount = 11 * KBL::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -91,17 +136,22 @@ void KBL_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = KBL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo KBL_1x3x6::hwInfo = {
     &KBL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &KBL::featureTable,
+    &KBL::workaroundTable,
     &KBL_1x3x6::gtSystemInfo,
     KBL::capabilityTable,
 };
+
 GT_SYSTEM_INFO KBL_1x3x6::gtSystemInfo = {0};
-void KBL_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void KBL_1x3x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 17;
     gtSysInfo->ThreadCount = 17 * KBL::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -120,17 +170,21 @@ void KBL_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = KBL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo KBL_1x3x8::hwInfo = {
     &KBL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &KBL::featureTable,
+    &KBL::workaroundTable,
     &KBL_1x3x8::gtSystemInfo,
     KBL::capabilityTable,
 };
 GT_SYSTEM_INFO KBL_1x3x8::gtSystemInfo = {0};
-void KBL_1x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void KBL_1x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 23;
     gtSysInfo->ThreadCount = 23 * KBL::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -149,17 +203,21 @@ void KBL_1x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = KBL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo KBL_2x3x8::hwInfo = {
     &KBL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &KBL::featureTable,
+    &KBL::workaroundTable,
     &KBL_2x3x8::gtSystemInfo,
     KBL::capabilityTable,
 };
 GT_SYSTEM_INFO KBL_2x3x8::gtSystemInfo = {0};
-void KBL_2x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void KBL_2x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 47;
     gtSysInfo->ThreadCount = 47 * KBL::threadsPerEu;
     gtSysInfo->SliceCount = 2;
@@ -178,17 +236,21 @@ void KBL_2x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = KBL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo KBL_3x3x8::hwInfo = {
     &KBL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &KBL::featureTable,
+    &KBL::workaroundTable,
     &KBL_3x3x8::gtSystemInfo,
     KBL::capabilityTable,
 };
 GT_SYSTEM_INFO KBL_3x3x8::gtSystemInfo = {0};
-void KBL_3x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void KBL_3x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 71;
     gtSysInfo->ThreadCount = 71 * KBL::threadsPerEu;
     gtSysInfo->SliceCount = 3;
@@ -207,28 +269,31 @@ void KBL_3x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = KBL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo KBL::hwInfo = KBL_1x3x6::hwInfo;
 
-void setupKBLHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+void setupKBLHardwareInfoImpl(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig) {
     if (hwInfoConfig == "1x3x8") {
-        KBL_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        KBL_1x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "2x3x8") {
-        KBL_2x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        KBL_2x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "3x3x8") {
-        KBL_3x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        KBL_3x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x2x6") {
-        KBL_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        KBL_1x2x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x3x6") {
-        KBL_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        KBL_1x3x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "default") {
         // Default config
-        KBL_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        KBL_1x3x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else {
         UNRECOVERABLE_IF(true);
     }
 }
 
-void (*KBL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupKBLHardwareInfoImpl;
+void (*KBL::setupHardwareInfo)(HardwareInfo *, bool, const std::string &) = setupKBLHardwareInfoImpl;
 } // namespace NEO
diff --git a/runtime/gen9/hw_info_skl.inl b/runtime/gen9/hw_info_skl.inl
index 8e2368f022..b866fd8881 100644
--- a/runtime/gen9/hw_info_skl.inl
+++ b/runtime/gen9/hw_info_skl.inl
@@ -71,16 +71,66 @@ const RuntimeCapabilityTable SKL::capabilityTable{
     true,                                          // supportsVme
     false                                          // supportCacheFlushAfterWalker
 };
+WorkaroundTable SKL::workaroundTable = {};
+FeatureTable SKL::featureTable = {};
+void SKL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
 
+    pSkuTable->ftrGpGpuMidThreadLevelPreempt = true;
+    pSkuTable->ftr3dMidBatchPreempt = true;
+    pSkuTable->ftr3dObjectLevelPreempt = true;
+    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
+    pSkuTable->ftrPPGTT = true;
+    pSkuTable->ftrSVM = true;
+    pSkuTable->ftrIA32eGfxPTEs = true;
+    pSkuTable->ftrDisplayYTiling = true;
+    pSkuTable->ftrTranslationTable = true;
+    pSkuTable->ftrUserModeTranslationTable = true;
+    pSkuTable->ftrEnableGuC = true;
+    pSkuTable->ftrFbc = true;
+    pSkuTable->ftrFbc2AddressTranslation = true;
+    pSkuTable->ftrFbcBlitterTracking = true;
+    pSkuTable->ftrFbcCpuTracking = true;
+    pSkuTable->ftrVcs2 = pSkuTable->ftrGT3 || pSkuTable->ftrGT4;
+    pSkuTable->ftrVEBOX = true;
+    pSkuTable->ftrSingleVeboxSlice = pSkuTable->ftrGT1 || pSkuTable->ftrGT2;
+    pSkuTable->ftrTileY = true;
+
+    pWaTable->waEnablePreemptionGranularityControlByUMD = true;
+    pWaTable->waSendMIFLUSHBeforeVFE = true;
+    pWaTable->waReportPerfCountUseGlobalContextID = true;
+    pWaTable->waDisableLSQCROPERFforOCL = true;
+    pWaTable->waMsaa8xTileYDepthPitchAlignment = true;
+    pWaTable->waLosslessCompressionSurfaceStride = true;
+    pWaTable->waFbcLinearSurfaceStride = true;
+    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
+    pWaTable->waEncryptedEdramOnlyPartials = true;
+    pWaTable->waDisableEdramForDisplayRT = true;
+    pWaTable->waForcePcBbFullCfgRestore = true;
+    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
+
+    if ((1 << hwInfo->pPlatform->usRevId) & 0x0eu) {
+        pWaTable->waCompressedResourceRequiresConstVA21 = true;
+    }
+    if ((1 << hwInfo->pPlatform->usRevId) & 0x0fu) {
+        pWaTable->waDisablePerCtxtPreemptionGranularityControl = true;
+        pWaTable->waModifyVFEStateAfterGPGPUPreemption = true;
+    }
+    if ((1 << hwInfo->pPlatform->usRevId) & 0x3f) {
+        pWaTable->waCSRUncachable = true;
+    }
+}
 const HardwareInfo SKL_1x2x6::hwInfo = {
     &SKL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &SKL::featureTable,
+    &SKL::workaroundTable,
     &SKL_1x2x6::gtSystemInfo,
     SKL::capabilityTable,
 };
 GT_SYSTEM_INFO SKL_1x2x6::gtSystemInfo = {0};
-void SKL_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void SKL_1x2x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 11;
     gtSysInfo->ThreadCount = 11 * SKL::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -99,17 +149,21 @@ void SKL_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = SKL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo SKL_1x3x6::hwInfo = {
     &SKL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &SKL::featureTable,
+    &SKL::workaroundTable,
     &SKL_1x3x6::gtSystemInfo,
     SKL::capabilityTable,
 };
 GT_SYSTEM_INFO SKL_1x3x6::gtSystemInfo = {0};
-void SKL_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void SKL_1x3x6::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 17;
     gtSysInfo->ThreadCount = 17 * SKL::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -128,17 +182,21 @@ void SKL_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = SKL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo SKL_1x3x8::hwInfo = {
     &SKL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &SKL::featureTable,
+    &SKL::workaroundTable,
     &SKL_1x3x8::gtSystemInfo,
     SKL::capabilityTable,
 };
 GT_SYSTEM_INFO SKL_1x3x8::gtSystemInfo = {0};
-void SKL_1x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void SKL_1x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 23;
     gtSysInfo->ThreadCount = 23 * SKL::threadsPerEu;
     gtSysInfo->SliceCount = 1;
@@ -157,17 +215,21 @@ void SKL_1x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = SKL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo SKL_2x3x8::hwInfo = {
     &SKL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &SKL::featureTable,
+    &SKL::workaroundTable,
     &SKL_2x3x8::gtSystemInfo,
     SKL::capabilityTable,
 };
 GT_SYSTEM_INFO SKL_2x3x8::gtSystemInfo = {0};
-void SKL_2x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void SKL_2x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 47;
     gtSysInfo->ThreadCount = 47 * SKL::threadsPerEu;
     gtSysInfo->SliceCount = 2;
@@ -186,17 +248,21 @@ void SKL_2x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = SKL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo SKL_3x3x8::hwInfo = {
     &SKL::platform,
-    &emptySkuTable,
-    &emptyWaTable,
+    &SKL::featureTable,
+    &SKL::workaroundTable,
     &SKL_3x3x8::gtSystemInfo,
     SKL::capabilityTable,
 };
 GT_SYSTEM_INFO SKL_3x3x8::gtSystemInfo = {0};
-void SKL_3x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable) {
+void SKL_3x3x8::setupHardwareInfo(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {
+    GT_SYSTEM_INFO *gtSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
     gtSysInfo->EUCount = 71;
     gtSysInfo->ThreadCount = 71 * SKL::threadsPerEu;
     gtSysInfo->SliceCount = 3;
@@ -215,28 +281,31 @@ void SKL_3x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->MaxSubSlicesSupported = SKL::maxSubslicesSupported;
     gtSysInfo->IsL3HashModeEnabled = false;
     gtSysInfo->IsDynamicallyPopulated = false;
+    if (setupFeatureTableAndWorkaroundTable) {
+        setupFeatureAndWorkaroundTable(hwInfo);
+    }
 };
 
 const HardwareInfo SKL::hwInfo = SKL_1x3x8::hwInfo;
 
-void setupSKLHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+void setupSKLHardwareInfoImpl(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig) {
     if (hwInfoConfig == "1x3x8") {
-        SKL_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        SKL_1x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "2x3x8") {
-        SKL_2x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        SKL_2x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "3x3x8") {
-        SKL_3x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        SKL_3x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x2x6") {
-        SKL_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        SKL_1x2x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "1x3x6") {
-        SKL_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        SKL_1x3x6::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else if (hwInfoConfig == "default") {
         // Default config
-        SKL_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+        SKL_1x3x8::setupHardwareInfo(hwInfo, setupFeatureTableAndWorkaroundTable);
     } else {
         UNRECOVERABLE_IF(true);
     }
 }
 
-void (*SKL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupSKLHardwareInfoImpl;
+void (*SKL::setupHardwareInfo)(HardwareInfo *, bool, const std::string &) = setupSKLHardwareInfoImpl;
 } // namespace NEO
diff --git a/runtime/gen9/linux/hw_info_config_bxt.inl b/runtime/gen9/linux/hw_info_config_bxt.inl
index 73f27ed6c8..bcc77717ed 100644
--- a/runtime/gen9/linux/hw_info_config_bxt.inl
+++ b/runtime/gen9/linux/hw_info_config_bxt.inl
@@ -19,52 +19,17 @@ int HwInfoConfigHw<IGFX_BROXTON>::configureHardwareCustom(HardwareInfo *hwInfo,
     }
 
     Drm *drm = osIface->get()->getDrm();
-    PLATFORM *pPlatform = const_cast<PLATFORM *>(hwInfo->pPlatform);
     FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
     GT_SYSTEM_INFO *pSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
-    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+
+    pSkuTable->ftrGpGpuMidBatchPreempt = true;
+    pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
+    pSkuTable->ftrL3IACoherency = true;
 
     pSysInfo->SliceCount = 1;
 
     pSysInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled = 1;
     pSysInfo->VEBoxInfo.IsValid = true;
-    pSkuTable->ftrVEBOX = true;
-    pSkuTable->ftrULT = true;
-    pSkuTable->ftrGpGpuMidBatchPreempt = true;
-    pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
-    pSkuTable->ftrGpGpuMidThreadLevelPreempt = true;
-    pSkuTable->ftr3dMidBatchPreempt = true;
-    pSkuTable->ftr3dObjectLevelPreempt = true;
-    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
-    pSkuTable->ftrLCIA = true;
-    pSkuTable->ftrPPGTT = true;
-    pSkuTable->ftrL3IACoherency = true;
-    pSkuTable->ftrIA32eGfxPTEs = true;
-
-    pSkuTable->ftrDisplayYTiling = true;
-    pSkuTable->ftrTranslationTable = true;
-    pSkuTable->ftrUserModeTranslationTable = true;
-    pSkuTable->ftrEnableGuC = true;
-
-    pSkuTable->ftrFbc = true;
-    pSkuTable->ftrFbc2AddressTranslation = true;
-    pSkuTable->ftrFbcBlitterTracking = true;
-    pSkuTable->ftrFbcCpuTracking = true;
-    pSkuTable->ftrTileY = true;
-
-    if (pPlatform->usRevId >= 3) {
-        pSkuTable->ftrGttCacheInvalidation = true;
-    }
-
-    pWaTable->waLLCCachingUnsupported = true;
-    pWaTable->waMsaa8xTileYDepthPitchAlignment = true;
-    pWaTable->waFbcLinearSurfaceStride = true;
-    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
-    pWaTable->waEnablePreemptionGranularityControlByUMD = true;
-    pWaTable->waSendMIFLUSHBeforeVFE = true;
-    pWaTable->waForcePcBbFullCfgRestore = true;
-    pWaTable->waReportPerfCountUseGlobalContextID = true;
-    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
 
     int enabled = 0;
     int retVal = drm->getEnabledPooledEu(enabled);
diff --git a/runtime/gen9/linux/hw_info_config_cfl.inl b/runtime/gen9/linux/hw_info_config_cfl.inl
index e513da1dca..bd719b9fdd 100644
--- a/runtime/gen9/linux/hw_info_config_cfl.inl
+++ b/runtime/gen9/linux/hw_info_config_cfl.inl
@@ -15,10 +15,12 @@ int HwInfoConfigHw<IGFX_COFFEELAKE>::configureHardwareCustom(HardwareInfo *hwInf
     if (nullptr == osIface) {
         return 0;
     }
-
-    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
     GT_SYSTEM_INFO *pSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
-    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+
+    pSkuTable->ftrGpGpuMidBatchPreempt = true;
+    pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
+    pSkuTable->ftrL3IACoherency = true;
 
     if (pSysInfo->SubSliceCount > 3) {
         pSysInfo->SliceCount = 2;
@@ -28,39 +30,6 @@ int HwInfoConfigHw<IGFX_COFFEELAKE>::configureHardwareCustom(HardwareInfo *hwInf
 
     pSysInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled = true;
     pSysInfo->VEBoxInfo.IsValid = true;
-    pSkuTable->ftrVEBOX = true;
-
-    pSkuTable->ftrGpGpuMidBatchPreempt = true;
-    pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
-    pSkuTable->ftrGpGpuMidThreadLevelPreempt = false;
-    pSkuTable->ftr3dMidBatchPreempt = true;
-    pSkuTable->ftr3dObjectLevelPreempt = true;
-    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
-
-    pSkuTable->ftrPPGTT = true;
-    pSkuTable->ftrSVM = true;
-    pSkuTable->ftrL3IACoherency = true;
-    pSkuTable->ftrIA32eGfxPTEs = true;
-
-    pSkuTable->ftrDisplayYTiling = true;
-    pSkuTable->ftrTranslationTable = true;
-    pSkuTable->ftrUserModeTranslationTable = true;
-    pSkuTable->ftrEnableGuC = true;
-
-    pSkuTable->ftrFbc = true;
-    pSkuTable->ftrFbc2AddressTranslation = true;
-    pSkuTable->ftrFbcBlitterTracking = true;
-    pSkuTable->ftrFbcCpuTracking = true;
-    pSkuTable->ftrTileY = true;
-
-    pWaTable->waEnablePreemptionGranularityControlByUMD = true;
-    pWaTable->waSendMIFLUSHBeforeVFE = true;
-    pWaTable->waReportPerfCountUseGlobalContextID = true;
-    pWaTable->waMsaa8xTileYDepthPitchAlignment = true;
-    pWaTable->waLosslessCompressionSurfaceStride = true;
-    pWaTable->waFbcLinearSurfaceStride = true;
-    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
-    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
 
     if (hwInfo->pPlatform->usDeviceID == ICFL_GT3_ULT_28W_DEVICE_F0_ID ||
         hwInfo->pPlatform->usDeviceID == ICFL_GT3_ULT_15W_DEVICE_F0_ID) {
diff --git a/runtime/gen9/linux/hw_info_config_glk.inl b/runtime/gen9/linux/hw_info_config_glk.inl
index 8d5160a532..3f8daa0f02 100644
--- a/runtime/gen9/linux/hw_info_config_glk.inl
+++ b/runtime/gen9/linux/hw_info_config_glk.inl
@@ -21,41 +21,13 @@ int HwInfoConfigHw<IGFX_GEMINILAKE>::configureHardwareCustom(HardwareInfo *hwInf
     Drm *drm = osIface->get()->getDrm();
     FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
     GT_SYSTEM_INFO *pSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
-    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
-
-    pSysInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled = 1;
-    pSysInfo->VEBoxInfo.IsValid = true;
 
     pSkuTable->ftrGpGpuMidBatchPreempt = true;
     pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
-    pSkuTable->ftrGpGpuMidThreadLevelPreempt = false;
-    pSkuTable->ftr3dMidBatchPreempt = true;
-    pSkuTable->ftr3dObjectLevelPreempt = true;
-    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
-
-    pSkuTable->ftrLCIA = true;
-    pSkuTable->ftrPPGTT = true;
     pSkuTable->ftrL3IACoherency = true;
-    pSkuTable->ftrIA32eGfxPTEs = true;
 
-    pSkuTable->ftrTranslationTable = true;
-    pSkuTable->ftrUserModeTranslationTable = true;
-    pSkuTable->ftrEnableGuC = true;
-    pSkuTable->ftrTileMappedResource = true;
-    pSkuTable->ftrULT = true;
-    pSkuTable->ftrAstcHdr2D = true;
-    pSkuTable->ftrAstcLdr2D = true;
-    pSkuTable->ftrTileY = true;
-
-    pWaTable->waLLCCachingUnsupported = true;
-    pWaTable->waMsaa8xTileYDepthPitchAlignment = true;
-    pWaTable->waFbcLinearSurfaceStride = true;
-    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
-    pWaTable->waEnablePreemptionGranularityControlByUMD = true;
-    pWaTable->waSendMIFLUSHBeforeVFE = true;
-    pWaTable->waForcePcBbFullCfgRestore = true;
-    pWaTable->waReportPerfCountUseGlobalContextID = true;
-    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
+    pSysInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled = 1;
+    pSysInfo->VEBoxInfo.IsValid = true;
 
     int enabled = 0;
     int retVal = drm->getEnabledPooledEu(enabled);
diff --git a/runtime/gen9/linux/hw_info_config_kbl.inl b/runtime/gen9/linux/hw_info_config_kbl.inl
index 48a4d2d1b4..8979c2a3df 100644
--- a/runtime/gen9/linux/hw_info_config_kbl.inl
+++ b/runtime/gen9/linux/hw_info_config_kbl.inl
@@ -15,11 +15,12 @@ int HwInfoConfigHw<IGFX_KABYLAKE>::configureHardwareCustom(HardwareInfo *hwInfo,
     if (nullptr == osIface) {
         return 0;
     }
-
-    PLATFORM *pPlatform = const_cast<PLATFORM *>(hwInfo->pPlatform);
-    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
     GT_SYSTEM_INFO *pSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
-    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+
+    pSkuTable->ftrGpGpuMidBatchPreempt = true;
+    pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
+    pSkuTable->ftrL3IACoherency = true;
 
     if (pSysInfo->SubSliceCount > 3) {
         pSysInfo->SliceCount = 2;
@@ -29,45 +30,6 @@ int HwInfoConfigHw<IGFX_KABYLAKE>::configureHardwareCustom(HardwareInfo *hwInfo,
 
     pSysInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled = 1;
     pSysInfo->VEBoxInfo.IsValid = true;
-    pSkuTable->ftrVEBOX = true;
-    pSkuTable->ftrGpGpuMidBatchPreempt = true;
-    pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
-    pSkuTable->ftrGpGpuMidThreadLevelPreempt = true;
-    pSkuTable->ftr3dMidBatchPreempt = true;
-    pSkuTable->ftr3dObjectLevelPreempt = true;
-    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
-    pSkuTable->ftrPPGTT = true;
-    pSkuTable->ftrSVM = true;
-    pSkuTable->ftrL3IACoherency = true;
-    pSkuTable->ftrIA32eGfxPTEs = true;
-
-    pSkuTable->ftrDisplayYTiling = true;
-    pSkuTable->ftrTranslationTable = true;
-    pSkuTable->ftrUserModeTranslationTable = true;
-    pSkuTable->ftrEnableGuC = true;
-
-    pSkuTable->ftrFbc = true;
-    pSkuTable->ftrFbc2AddressTranslation = true;
-    pSkuTable->ftrFbcBlitterTracking = true;
-    pSkuTable->ftrFbcCpuTracking = true;
-    pSkuTable->ftrTileY = true;
-
-    pWaTable->waEnablePreemptionGranularityControlByUMD = true;
-    pWaTable->waSendMIFLUSHBeforeVFE = true;
-    pWaTable->waReportPerfCountUseGlobalContextID = true;
-    pWaTable->waMsaa8xTileYDepthPitchAlignment = true;
-    pWaTable->waLosslessCompressionSurfaceStride = true;
-    pWaTable->waFbcLinearSurfaceStride = true;
-    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
-    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
-
-    if (pPlatform->usRevId <= 0x6) {
-        pWaTable->waDisableLSQCROPERFforOCL = true;
-        pWaTable->waEncryptedEdramOnlyPartials = true;
-    }
-    if (pPlatform->usRevId <= 0x8) {
-        pWaTable->waForcePcBbFullCfgRestore = true;
-    }
 
     if (hwInfo->pPlatform->usDeviceID == IKBL_GT3_28W_ULT_DEVICE_F0_ID ||
         hwInfo->pPlatform->usDeviceID == IKBL_GT3_15W_ULT_DEVICE_F0_ID) {
diff --git a/runtime/gen9/linux/hw_info_config_skl.inl b/runtime/gen9/linux/hw_info_config_skl.inl
index ea0a408423..1a9dcf2db1 100644
--- a/runtime/gen9/linux/hw_info_config_skl.inl
+++ b/runtime/gen9/linux/hw_info_config_skl.inl
@@ -16,10 +16,12 @@ int HwInfoConfigHw<IGFX_SKYLAKE>::configureHardwareCustom(HardwareInfo *hwInfo,
     if (nullptr == osIface) {
         return 0;
     }
-
-    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
     GT_SYSTEM_INFO *pSysInfo = const_cast<GT_SYSTEM_INFO *>(hwInfo->pSysInfo);
-    WorkaroundTable *pWaTable = const_cast<WorkaroundTable *>(hwInfo->pWaTable);
+    FeatureTable *pSkuTable = const_cast<FeatureTable *>(hwInfo->pSkuTable);
+
+    pSkuTable->ftrGpGpuMidBatchPreempt = true;
+    pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
+    pSkuTable->ftrL3IACoherency = true;
 
     if (pSysInfo->SubSliceCount > 3) {
         pSysInfo->SliceCount = 2;
@@ -31,56 +33,6 @@ int HwInfoConfigHw<IGFX_SKYLAKE>::configureHardwareCustom(HardwareInfo *hwInfo,
     pSysInfo->VDBoxInfo.Instances.Bits.VDBox0Enabled = 1;
     pSysInfo->VEBoxInfo.IsValid = true;
     pSysInfo->VDBoxInfo.IsValid = true;
-    pSkuTable->ftrGpGpuMidBatchPreempt = true;
-    pSkuTable->ftrGpGpuThreadGroupLevelPreempt = true;
-    pSkuTable->ftrGpGpuMidThreadLevelPreempt = true;
-    pSkuTable->ftr3dMidBatchPreempt = true;
-    pSkuTable->ftr3dObjectLevelPreempt = true;
-    pSkuTable->ftrPerCtxtPreemptionGranularityControl = true;
-    pSkuTable->ftrPPGTT = true;
-    pSkuTable->ftrSVM = true;
-    pSkuTable->ftrL3IACoherency = true;
-    pSkuTable->ftrIA32eGfxPTEs = true;
-
-    pSkuTable->ftrDisplayYTiling = true;
-    pSkuTable->ftrTranslationTable = true;
-    pSkuTable->ftrUserModeTranslationTable = true;
-
-    pSkuTable->ftrEnableGuC = true;
-
-    pSkuTable->ftrFbc = true;
-    pSkuTable->ftrFbc2AddressTranslation = true;
-    pSkuTable->ftrFbcBlitterTracking = true;
-    pSkuTable->ftrFbcCpuTracking = true;
-
-    pSkuTable->ftrVcs2 = pSkuTable->ftrGT3 || pSkuTable->ftrGT4;
-    pSkuTable->ftrVEBOX = true;
-    pSkuTable->ftrSingleVeboxSlice = pSkuTable->ftrGT1 || pSkuTable->ftrGT2;
-    pSkuTable->ftrTileY = true;
-
-    pWaTable->waEnablePreemptionGranularityControlByUMD = true;
-    pWaTable->waSendMIFLUSHBeforeVFE = true;
-    pWaTable->waReportPerfCountUseGlobalContextID = true;
-    pWaTable->waDisableLSQCROPERFforOCL = true;
-    pWaTable->waMsaa8xTileYDepthPitchAlignment = true;
-    pWaTable->waLosslessCompressionSurfaceStride = true;
-    pWaTable->waFbcLinearSurfaceStride = true;
-    pWaTable->wa4kAlignUVOffsetNV12LinearSurface = true;
-    pWaTable->waEncryptedEdramOnlyPartials = true;
-    pWaTable->waDisableEdramForDisplayRT = true;
-    pWaTable->waForcePcBbFullCfgRestore = true;
-    pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
-
-    if ((1 << hwInfo->pPlatform->usRevId) & 0x0eu) {
-        pWaTable->waCompressedResourceRequiresConstVA21 = true;
-    }
-    if ((1 << hwInfo->pPlatform->usRevId) & 0x0fu) {
-        pWaTable->waDisablePerCtxtPreemptionGranularityControl = true;
-        pWaTable->waModifyVFEStateAfterGPGPUPreemption = true;
-    }
-    if ((1 << hwInfo->pPlatform->usRevId) & 0x3f) {
-        pWaTable->waCSRUncachable = true;
-    }
 
     if (hwInfo->pPlatform->usDeviceID == ISKL_GT3e_ULT_DEVICE_F0_ID_540 ||
         hwInfo->pPlatform->usDeviceID == ISKL_GT3e_ULT_DEVICE_F0_ID_550 ||
diff --git a/runtime/helpers/hw_info.cpp b/runtime/helpers/hw_info.cpp
index d47647b13f..24ce70013a 100644
--- a/runtime/helpers/hw_info.cpp
+++ b/runtime/helpers/hw_info.cpp
@@ -18,13 +18,10 @@ HardwareInfo::HardwareInfo(const PLATFORM *platform, const FeatureTable *skuTabl
 }
 
 const HardwareInfo *hardwareInfoTable[IGFX_MAX_PRODUCT] = {};
-void (*hardwareInfoSetup[IGFX_MAX_PRODUCT])(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = {
+void (*hardwareInfoSetup[IGFX_MAX_PRODUCT])(HardwareInfo *, bool, const std::string &) = {
     nullptr,
 };
 
-const FeatureTable emptySkuTable = {};
-const WorkaroundTable emptyWaTable = {};
-
 const char *getPlatformType(const HardwareInfo &hwInfo) {
     if (hwInfo.capabilityTable.isCore) {
         return "core";
diff --git a/runtime/helpers/hw_info.h b/runtime/helpers/hw_info.h
index 297501d9cd..01f03ce73d 100644
--- a/runtime/helpers/hw_info.h
+++ b/runtime/helpers/hw_info.h
@@ -76,9 +76,6 @@ struct HardwareInfo {
     RuntimeCapabilityTable capabilityTable = {};
 };
 
-extern const WorkaroundTable emptyWaTable;
-extern const FeatureTable emptySkuTable;
-
 template <PRODUCT_FAMILY product>
 struct HwMapper {};
 
@@ -90,7 +87,7 @@ extern bool familyEnabled[IGFX_MAX_CORE];
 extern const char *familyName[IGFX_MAX_CORE];
 extern const char *hardwarePrefix[];
 extern const HardwareInfo *hardwareInfoTable[IGFX_MAX_PRODUCT];
-extern void (*hardwareInfoSetup[IGFX_MAX_PRODUCT])(GT_SYSTEM_INFO *gtSystemInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
+extern void (*hardwareInfoSetup[IGFX_MAX_PRODUCT])(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const std::string &hwInfoConfig);
 
 template <GFXCORE_FAMILY gfxFamily>
 struct EnableGfxFamilyHw {
diff --git a/runtime/os_interface/device_factory.cpp b/runtime/os_interface/device_factory.cpp
index 93bcc9c28c..4ed021c63f 100644
--- a/runtime/os_interface/device_factory.cpp
+++ b/runtime/os_interface/device_factory.cpp
@@ -30,14 +30,13 @@ bool DeviceFactory::getDevicesForProductFamilyOverride(HardwareInfo **pHWInfos,
     hardwareInfo->pWaTable = new WorkaroundTable(*hwInfoConst->pWaTable);
     hardwareInfo->pSysInfo = new GT_SYSTEM_INFO(*hwInfoConst->pSysInfo);
     hardwareInfo->capabilityTable = hwInfoConst->capabilityTable;
-    hardwareInfoSetup[hwInfoConst->pPlatform->eProductFamily](const_cast<GT_SYSTEM_INFO *>(hardwareInfo->pSysInfo),
-                                                              const_cast<FeatureTable *>(hardwareInfo->pSkuTable),
-                                                              true, hwInfoConfig);
+    hardwareInfoSetup[hwInfoConst->pPlatform->eProductFamily](hardwareInfo.get(), true, hwInfoConfig);
 
     HwInfoConfig *hwConfig = HwInfoConfig::get(hardwareInfo->pPlatform->eProductFamily);
     hwConfig->configureHardwareCustom(hardwareInfo.get(), nullptr);
 
     *pHWInfos = hardwareInfo.release();
+
     executionEnvironment.setHwInfo(*pHWInfos);
     numDevices = totalDeviceCount;
     DeviceFactory::numDevices = numDevices;
diff --git a/runtime/os_interface/linux/drm_neo.h b/runtime/os_interface/linux/drm_neo.h
index 7d0fb9a673..1c6dcc1e83 100644
--- a/runtime/os_interface/linux/drm_neo.h
+++ b/runtime/os_interface/linux/drm_neo.h
@@ -30,7 +30,7 @@ struct FeatureTable;
 struct DeviceDescriptor {
     unsigned short deviceId;
     const HardwareInfo *pHwInfo;
-    void (*setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool);
+    void (*setupHardwareInfo)(HardwareInfo *, bool);
     GTTYPE eGtType;
 };
 
diff --git a/unit_tests/command_stream/get_devices_tests.cpp b/unit_tests/command_stream/get_devices_tests.cpp
index 0dc7abc9b0..9be741ad10 100644
--- a/unit_tests/command_stream/get_devices_tests.cpp
+++ b/unit_tests/command_stream/get_devices_tests.cpp
@@ -39,6 +39,7 @@ struct GetDevicesTest : ::testing::Test {
     size_t numDevices = 0;
     HardwareInfo *hwInfo = nullptr;
     FeatureTable featureTable = {};
+    WorkaroundTable workaroundTable = {};
     GT_SYSTEM_INFO sysInfo = {};
     DebugManagerStateRestore stateRestorer;
 };
@@ -91,17 +92,17 @@ HWTEST_F(GetDevicesTest, givenGetDevicesWhenCsrIsSetToVariousTypesThenTheFunctio
                 }
                 EXPECT_TRUE(i < IGFX_MAX_PRODUCT);
                 ASSERT_NE(nullptr, hardwarePrefix[i]);
+
                 HardwareInfo hwInfoFromTable = *hardwareInfoTable[i];
                 hwInfoFromTable.pSkuTable = &featureTable;
+                hwInfoFromTable.pWaTable = &workaroundTable;
                 hwInfoFromTable.pSysInfo = &sysInfo;
-                hardwareInfoSetup[hwInfoFromTable.pPlatform->eProductFamily](const_cast<GT_SYSTEM_INFO *>(hwInfoFromTable.pSysInfo),
-                                                                             const_cast<FeatureTable *>(hwInfoFromTable.pSkuTable),
-                                                                             true, "default");
+                hardwareInfoSetup[hwInfoFromTable.pPlatform->eProductFamily](&hwInfoFromTable, true, "default");
                 HwInfoConfig *hwConfig = HwInfoConfig::get(hwInfoFromTable.pPlatform->eProductFamily);
                 hwConfig->configureHardwareCustom(&hwInfoFromTable, nullptr);
                 EXPECT_EQ(0, memcmp(hwInfoFromTable.pPlatform, hwInfo->pPlatform, sizeof(PLATFORM)));
                 EXPECT_EQ(0, memcmp(&hwInfoFromTable.capabilityTable, &hwInfo->capabilityTable, sizeof(RuntimeCapabilityTable)));
-                EXPECT_EQ(0, memcmp(hwInfoFromTable.pWaTable, hwInfo->pWaTable, sizeof(WorkaroundTable)));
+
                 EXPECT_STREQ(hardwarePrefix[i], productFamily.c_str());
                 DeviceFactory::releaseDevices();
                 break;
@@ -151,16 +152,15 @@ HWTEST_F(GetDevicesTest, givenGetDevicesAndUnknownProductFamilyWhenCsrIsSetToVal
             ASSERT_NE(nullptr, hardwarePrefix[i]);
             HardwareInfo defaultHwInfo = **platformDevices;
             defaultHwInfo.pSkuTable = &featureTable;
+            defaultHwInfo.pWaTable = &workaroundTable;
             defaultHwInfo.pSysInfo = &sysInfo;
-            hardwareInfoSetup[defaultHwInfo.pPlatform->eProductFamily](const_cast<GT_SYSTEM_INFO *>(defaultHwInfo.pSysInfo),
-                                                                       const_cast<FeatureTable *>(defaultHwInfo.pSkuTable),
-                                                                       true, "default");
+            hardwareInfoSetup[defaultHwInfo.pPlatform->eProductFamily](&defaultHwInfo, true, "default");
             HwInfoConfig *hwConfig = HwInfoConfig::get(defaultHwInfo.pPlatform->eProductFamily);
             hwConfig->configureHardwareCustom(&defaultHwInfo, nullptr);
             EXPECT_EQ(0, memcmp(defaultHwInfo.pPlatform, hwInfo->pPlatform, sizeof(PLATFORM)));
             EXPECT_EQ(0, memcmp(&defaultHwInfo.capabilityTable, &hwInfo->capabilityTable, sizeof(RuntimeCapabilityTable)));
-            EXPECT_EQ(0, memcmp(defaultHwInfo.pWaTable, hwInfo->pWaTable, sizeof(WorkaroundTable)));
             DeviceFactory::releaseDevices();
+
             break;
         }
         default:
diff --git a/unit_tests/gen10/linux/hw_info_config_tests_gen10.cpp b/unit_tests/gen10/linux/hw_info_config_tests_gen10.cpp
index 199dbc0f41..96ac2324a7 100644
--- a/unit_tests/gen10/linux/hw_info_config_tests_gen10.cpp
+++ b/unit_tests/gen10/linux/hw_info_config_tests_gen10.cpp
@@ -45,29 +45,9 @@ CNLTEST_F(HwInfoConfigTestLinuxCnl, configureHwInfo) {
     //constant sysInfo/ftr flags
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuMidBatchPreempt);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuThreadGroupLevelPreempt);
-    EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGpGpuMidThreadLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dMidBatchPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dObjectLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dMidBatchPreempt);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuThreadGroupLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPerCtxtPreemptionGranularityControl);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPPGTT);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrSVM);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrL3IACoherency);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrIA32eGfxPTEs);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrStandardMipTailFormat);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrDisplayYTiling);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrUserModeTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTileMappedResource);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrEnableGuC);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbc);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbc2AddressTranslation);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbcBlitterTracking);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbcCpuTracking);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrAstcHdr2D);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrAstcLdr2D);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTileY);
 
     ReleaseOutHwInfoStructs();
 
@@ -153,18 +133,13 @@ CNLTEST_F(HwInfoConfigTestLinuxCnl, configureHwInfoWaFlags) {
     drm->StoredDeviceRevID = 0;
     int ret = hwInfoConfig->configureHwInfo(pInHwInfo, &outHwInfo, osInterface);
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waFbcLinearSurfaceStride);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waEncryptedEdramOnlyPartials);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 
     ReleaseOutHwInfoStructs();
 
     drm->StoredDeviceRevID = 1;
     ret = hwInfoConfig->configureHwInfo(pInHwInfo, &outHwInfo, osInterface);
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waFbcLinearSurfaceStride);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waEncryptedEdramOnlyPartials);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 
     ReleaseOutHwInfoStructs();
 
@@ -173,7 +148,6 @@ CNLTEST_F(HwInfoConfigTestLinuxCnl, configureHwInfoWaFlags) {
     EXPECT_EQ(0, ret);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waFbcLinearSurfaceStride);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waEncryptedEdramOnlyPartials);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 }
 
 CNLTEST_F(HwInfoConfigTestLinuxCnl, configureHwInfoIsL3HashModeEnabled) {
@@ -199,8 +173,15 @@ TYPED_TEST_CASE(CnlHwInfoTests, cnlTestTypes);
 TYPED_TEST(CnlHwInfoTests, gtSetupIsCorrect) {
     GT_SYSTEM_INFO gtSystemInfo;
     FeatureTable featureTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
     memset(&gtSystemInfo, 0, sizeof(gtSystemInfo));
-    TypeParam::setupHardwareInfo(&gtSystemInfo, &featureTable, false);
+    TypeParam::setupHardwareInfo(&hwInfo, false);
     EXPECT_GT(gtSystemInfo.EUCount, 0u);
     EXPECT_GT(gtSystemInfo.ThreadCount, 0u);
     EXPECT_GT(gtSystemInfo.SliceCount, 0u);
diff --git a/unit_tests/gen10/test_hw_info_config_cnl.cpp b/unit_tests/gen10/test_hw_info_config_cnl.cpp
index 095167f522..330adb8fdb 100644
--- a/unit_tests/gen10/test_hw_info_config_cnl.cpp
+++ b/unit_tests/gen10/test_hw_info_config_cnl.cpp
@@ -13,48 +13,124 @@ TEST(CnlHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorr
     if (IGFX_CANNONLAKE != productFamily) {
         return;
     }
-    GT_SYSTEM_INFO gInfo;
-    FeatureTable fTable;
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+
     std::string strConfig = "1x2x8";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 2u);
-    EXPECT_EQ(gInfo.EUCount, 15u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(2u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(15u, gtSystemInfo.EUCount);
 
     strConfig = "1x3x8";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 23u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(23u, gtSystemInfo.EUCount);
 
     strConfig = "2x4x8";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 2u);
-    EXPECT_EQ(gInfo.SubSliceCount, 8u);
-    EXPECT_EQ(gInfo.EUCount, 31u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(2u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(8u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(31u, gtSystemInfo.EUCount);
 
     strConfig = "2x5x8";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 2u);
-    EXPECT_EQ(gInfo.SubSliceCount, 10u);
-    EXPECT_EQ(gInfo.EUCount, 39u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(2u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(10u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(39u, gtSystemInfo.EUCount);
 
     strConfig = "4x9x8";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 4u);
-    EXPECT_EQ(gInfo.SubSliceCount, 36u);
-    EXPECT_EQ(gInfo.EUCount, 71u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(4u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(36u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(71u, gtSystemInfo.EUCount);
 
     strConfig = "default";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 2u);
-    EXPECT_EQ(gInfo.SubSliceCount, 10u);
-    EXPECT_EQ(gInfo.EUCount, 39u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(2u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(10u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(39u, gtSystemInfo.EUCount);
 
     strConfig = "erroneous";
-    gInfo = {0};
-    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
-    EXPECT_EQ(gInfo.SliceCount, 0u);
-    EXPECT_EQ(gInfo.SubSliceCount, 0u);
-    EXPECT_EQ(gInfo.EUCount, 0u);
+    gtSystemInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&hwInfo, false, strConfig));
+    EXPECT_EQ(0u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.EUCount);
+}
+
+using CnlHwInfo = ::testing::Test;
+
+CNLTEST_F(CnlHwInfo, givenBoolWhenCallCnlHardwareInfoSetupThenFeatureTableAndWorkaroundTableAreSetCorrect) {
+    std::string strConfig[] = {
+        "1x2x8",
+        "1x3x8",
+        "2x5x8",
+        "2x4x8",
+        "4x9x8"};
+    bool boolValue[]{
+        true, false};
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    FeatureTable pSkuTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &pSkuTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
+
+    for (auto &config : strConfig) {
+        for (auto setParamBool : boolValue) {
+
+            gtSystemInfo = {0};
+            pSkuTable = {};
+            pWaTable = {};
+
+            pPlatform.usRevId = 9;
+            hardwareInfoSetup[productFamily](&hwInfo, setParamBool, config);
+
+            EXPECT_EQ(setParamBool, pSkuTable.ftrGpGpuMidThreadLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dMidBatchPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dObjectLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPerCtxtPreemptionGranularityControl);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPPGTT);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrSVM);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrIA32eGfxPTEs);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrStandardMipTailFormat);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrDisplayYTiling);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrUserModeTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTileMappedResource);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrEnableGuC);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc2AddressTranslation);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcBlitterTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcCpuTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrAstcHdr2D);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrAstcLdr2D);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTileY);
+
+            EXPECT_EQ(setParamBool, pWaTable.wa4kAlignUVOffsetNV12LinearSurface);
+            EXPECT_EQ(setParamBool, pWaTable.waSendMIFLUSHBeforeVFE);
+            EXPECT_EQ(setParamBool, pWaTable.waReportPerfCountUseGlobalContextID);
+            EXPECT_EQ(setParamBool, pWaTable.waSamplerCacheFlushBetweenRedescribedSurfaceReads);
+            EXPECT_EQ(false, pWaTable.waFbcLinearSurfaceStride);
+            EXPECT_EQ(false, pWaTable.waEncryptedEdramOnlyPartials);
+
+            pPlatform.usRevId = 0;
+            pWaTable = {};
+            hardwareInfoSetup[productFamily](&hwInfo, true, config);
+
+            EXPECT_EQ(true, pWaTable.waFbcLinearSurfaceStride);
+            EXPECT_EQ(true, pWaTable.waEncryptedEdramOnlyPartials);
+        }
+    }
 }
diff --git a/unit_tests/gen11/icllp/linux/hw_info_config_tests_icllp.cpp b/unit_tests/gen11/icllp/linux/hw_info_config_tests_icllp.cpp
index 6d864ff9b5..2cafa703f9 100644
--- a/unit_tests/gen11/icllp/linux/hw_info_config_tests_icllp.cpp
+++ b/unit_tests/gen11/icllp/linux/hw_info_config_tests_icllp.cpp
@@ -40,7 +40,7 @@ ICLLPTEST_F(HwInfoConfigTestLinuxIcllp, configureHwInfo) {
     EXPECT_FALSE(outHwInfo.pSkuTable->ftrGTA);
     EXPECT_FALSE(outHwInfo.pSkuTable->ftrGTC);
     EXPECT_FALSE(outHwInfo.pSkuTable->ftrGTX);
-    EXPECT_TRUE(outHwInfo.pSkuTable->ftrTileY);
+    EXPECT_FALSE(outHwInfo.pSkuTable->ftrTileY);
 }
 
 ICLLPTEST_F(HwInfoConfigTestLinuxIcllp, negative) {
@@ -78,6 +78,13 @@ ICLLPTEST_F(IcllpHwInfoTests, icllp1x8x8systemInfo) {
     GT_SYSTEM_INFO requestedGtSystemInfo = {};
     GT_SYSTEM_INFO expectedGtSystemInfo = {};
     FeatureTable featureTable = {};
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &requestedGtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
 
     expectedGtSystemInfo.EUCount = 63;
     expectedGtSystemInfo.ThreadCount = 63 * ICLLP::threadsPerEu;
@@ -98,7 +105,7 @@ ICLLPTEST_F(IcllpHwInfoTests, icllp1x8x8systemInfo) {
     expectedGtSystemInfo.IsL3HashModeEnabled = false;
     expectedGtSystemInfo.IsDynamicallyPopulated = false;
 
-    ICLLP_1x8x8::setupHardwareInfo(&requestedGtSystemInfo, &featureTable, false);
+    ICLLP_1x8x8::setupHardwareInfo(&hwInfo, false);
     EXPECT_TRUE(memcmp(&requestedGtSystemInfo, &expectedGtSystemInfo, sizeof(GT_SYSTEM_INFO)) == 0);
 }
 
@@ -106,6 +113,13 @@ ICLLPTEST_F(IcllpHwInfoTests, icllp1x4x8systemInfo) {
     GT_SYSTEM_INFO requestedGtSystemInfo = {};
     GT_SYSTEM_INFO expectedGtSystemInfo = {};
     FeatureTable featureTable = {};
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &requestedGtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
 
     expectedGtSystemInfo.EUCount = 31;
     expectedGtSystemInfo.ThreadCount = 31 * ICLLP::threadsPerEu;
@@ -126,7 +140,7 @@ ICLLPTEST_F(IcllpHwInfoTests, icllp1x4x8systemInfo) {
     expectedGtSystemInfo.IsL3HashModeEnabled = false;
     expectedGtSystemInfo.IsDynamicallyPopulated = false;
 
-    ICLLP_1x4x8::setupHardwareInfo(&requestedGtSystemInfo, &featureTable, false);
+    ICLLP_1x4x8::setupHardwareInfo(&hwInfo, false);
     EXPECT_TRUE(memcmp(&requestedGtSystemInfo, &expectedGtSystemInfo, sizeof(GT_SYSTEM_INFO)) == 0);
 }
 
@@ -134,6 +148,13 @@ ICLLPTEST_F(IcllpHwInfoTests, icllp1x6x8systemInfo) {
     GT_SYSTEM_INFO requestedGtSystemInfo = {};
     GT_SYSTEM_INFO expectedGtSystemInfo = {};
     FeatureTable featureTable = {};
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &requestedGtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
 
     expectedGtSystemInfo.EUCount = 47;
     expectedGtSystemInfo.ThreadCount = 47 * ICLLP::threadsPerEu;
@@ -154,7 +175,7 @@ ICLLPTEST_F(IcllpHwInfoTests, icllp1x6x8systemInfo) {
     expectedGtSystemInfo.IsL3HashModeEnabled = false;
     expectedGtSystemInfo.IsDynamicallyPopulated = false;
 
-    ICLLP_1x6x8::setupHardwareInfo(&requestedGtSystemInfo, &featureTable, false);
+    ICLLP_1x6x8::setupHardwareInfo(&hwInfo, false);
     EXPECT_TRUE(memcmp(&requestedGtSystemInfo, &expectedGtSystemInfo, sizeof(GT_SYSTEM_INFO)) == 0);
 }
 
@@ -162,6 +183,13 @@ ICLLPTEST_F(IcllpHwInfoTests, icllp1x1x8systemInfo) {
     GT_SYSTEM_INFO requestedGtSystemInfo = {};
     GT_SYSTEM_INFO expectedGtSystemInfo = {};
     FeatureTable featureTable = {};
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &requestedGtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
 
     expectedGtSystemInfo.EUCount = 8;
     expectedGtSystemInfo.ThreadCount = 8 * ICLLP::threadsPerEu;
@@ -182,6 +210,6 @@ ICLLPTEST_F(IcllpHwInfoTests, icllp1x1x8systemInfo) {
     expectedGtSystemInfo.IsL3HashModeEnabled = false;
     expectedGtSystemInfo.IsDynamicallyPopulated = false;
 
-    ICLLP_1x1x8::setupHardwareInfo(&requestedGtSystemInfo, &featureTable, false);
+    ICLLP_1x1x8::setupHardwareInfo(&hwInfo, false);
     EXPECT_TRUE(memcmp(&requestedGtSystemInfo, &expectedGtSystemInfo, sizeof(GT_SYSTEM_INFO)) == 0);
 }
diff --git a/unit_tests/gen11/icllp/test_hw_info_config_icllp.cpp b/unit_tests/gen11/icllp/test_hw_info_config_icllp.cpp
index 3805dbcd94..136f94a0de 100644
--- a/unit_tests/gen11/icllp/test_hw_info_config_icllp.cpp
+++ b/unit_tests/gen11/icllp/test_hw_info_config_icllp.cpp
@@ -14,45 +14,99 @@ TEST(IcllpHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCo
         return;
     }
     GT_SYSTEM_INFO gInfo = {0};
-    FeatureTable fTable;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gInfo;
+
     std::string strConfig = "1x8x8";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 8u);
-    EXPECT_EQ(gInfo.EUCount, 63u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gInfo.SliceCount);
+    EXPECT_EQ(8u, gInfo.SubSliceCount);
+    EXPECT_EQ(63u, gInfo.EUCount);
 
     strConfig = "1x4x8";
     gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 4u);
-    EXPECT_EQ(gInfo.EUCount, 31u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gInfo.SliceCount);
+    EXPECT_EQ(4u, gInfo.SubSliceCount);
+    EXPECT_EQ(31u, gInfo.EUCount);
 
     strConfig = "1x6x8";
     gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 6u);
-    EXPECT_EQ(gInfo.EUCount, 47u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gInfo.SliceCount);
+    EXPECT_EQ(6u, gInfo.SubSliceCount);
+    EXPECT_EQ(47u, gInfo.EUCount);
 
     strConfig = "1x1x8";
     gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 1u);
-    EXPECT_EQ(gInfo.EUCount, 8u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gInfo.SliceCount);
+    EXPECT_EQ(1u, gInfo.SubSliceCount);
+    EXPECT_EQ(8u, gInfo.EUCount);
 
     strConfig = "default";
     gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 8u);
-    EXPECT_EQ(gInfo.EUCount, 63u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gInfo.SliceCount);
+    EXPECT_EQ(8u, gInfo.SubSliceCount);
+    EXPECT_EQ(63u, gInfo.EUCount);
 
     strConfig = "erroneous";
     gInfo = {0};
-    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
-    EXPECT_EQ(gInfo.SliceCount, 0u);
-    EXPECT_EQ(gInfo.SubSliceCount, 0u);
-    EXPECT_EQ(gInfo.EUCount, 0u);
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&hwInfo, false, strConfig));
+    EXPECT_EQ(0u, gInfo.SliceCount);
+    EXPECT_EQ(0u, gInfo.SubSliceCount);
+    EXPECT_EQ(0u, gInfo.EUCount);
+}
+
+using IcllpHwInfo = ::testing::Test;
+
+ICLLPTEST_F(IcllpHwInfo, givenBoolWhenCallIcllpHardwareInfoSetupThenFeatureTableAndWorkaroundTableAreSetCorrect) {
+    std::string strConfig[] = {
+        "1x8x8",
+        "1x4x8",
+        "1x6x8",
+        "1x1x8"};
+    bool boolValue[]{
+        true, false};
+
+    GT_SYSTEM_INFO gInfo = {0};
+    FeatureTable pSkuTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gInfo;
+    hwInfo.pSkuTable = &pSkuTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
+
+    for (auto &config : strConfig) {
+        for (auto setParamBool : boolValue) {
+
+            gInfo = {0};
+            pSkuTable = {};
+            pWaTable = {};
+            hardwareInfoSetup[productFamily](&hwInfo, setParamBool, config);
+
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPPGTT);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrSVM);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrIA32eGfxPTEs);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrStandardMipTailFormat);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrDisplayYTiling);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrUserModeTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTileMappedResource);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrEnableGuC);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc2AddressTranslation);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcBlitterTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcCpuTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTileY);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrAstcHdr2D);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrAstcLdr2D);
+
+            EXPECT_EQ(setParamBool, pWaTable.wa4kAlignUVOffsetNV12LinearSurface);
+            EXPECT_EQ(setParamBool, pWaTable.waReportPerfCountUseGlobalContextID);
+        }
+    }
 }
diff --git a/unit_tests/gen11/lkf/linux/hw_info_config_tests_lkf.cpp b/unit_tests/gen11/lkf/linux/hw_info_config_tests_lkf.cpp
index 3d3f26f5d1..5f8e876a37 100644
--- a/unit_tests/gen11/lkf/linux/hw_info_config_tests_lkf.cpp
+++ b/unit_tests/gen11/lkf/linux/hw_info_config_tests_lkf.cpp
@@ -39,7 +39,7 @@ TEST_F(HwInfoConfigTestLinuxLkf, configureHwInfoLkf) {
     EXPECT_FALSE(outHwInfo.pSkuTable->ftrGTA);
     EXPECT_FALSE(outHwInfo.pSkuTable->ftrGTC);
     EXPECT_FALSE(outHwInfo.pSkuTable->ftrGTX);
-    EXPECT_TRUE(outHwInfo.pSkuTable->ftrTileY);
+    EXPECT_FALSE(outHwInfo.pSkuTable->ftrTileY);
 
     ReleaseOutHwInfoStructs();
 }
@@ -80,8 +80,15 @@ TYPED_TEST_CASE(LkfHwInfoTests, lkfTestTypes);
 TYPED_TEST(LkfHwInfoTests, gtSetupIsCorrect) {
     GT_SYSTEM_INFO gtSystemInfo;
     FeatureTable featureTable = {};
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
     memset(&gtSystemInfo, 0, sizeof(gtSystemInfo));
-    TypeParam::setupHardwareInfo(&gtSystemInfo, &featureTable, false);
+    TypeParam::setupHardwareInfo(&hwInfo, false);
     EXPECT_GT(gtSystemInfo.EUCount, 0u);
     EXPECT_GT(gtSystemInfo.ThreadCount, 0u);
     EXPECT_GT(gtSystemInfo.SliceCount, 0u);
diff --git a/unit_tests/gen11/lkf/test_hw_info_config_lkf.cpp b/unit_tests/gen11/lkf/test_hw_info_config_lkf.cpp
index 5f0f14e7aa..b1b3036aa8 100644
--- a/unit_tests/gen11/lkf/test_hw_info_config_lkf.cpp
+++ b/unit_tests/gen11/lkf/test_hw_info_config_lkf.cpp
@@ -14,24 +14,72 @@ TEST(LkfHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorr
         return;
     }
     GT_SYSTEM_INFO gInfo = {0};
-    FeatureTable fTable;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gInfo;
+
     std::string strConfig = "1x8x8";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 8u);
-    EXPECT_EQ(gInfo.EUCount, 64u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gInfo.SliceCount);
+    EXPECT_EQ(8u, gInfo.SubSliceCount);
+    EXPECT_EQ(64u, gInfo.EUCount);
 
     strConfig = "default";
     gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 8u);
-    EXPECT_EQ(gInfo.EUCount, 64u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gInfo.SliceCount);
+    EXPECT_EQ(8u, gInfo.SubSliceCount);
+    EXPECT_EQ(64u, gInfo.EUCount);
 
     strConfig = "erroneous";
     gInfo = {0};
-    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
-    EXPECT_EQ(gInfo.SliceCount, 0u);
-    EXPECT_EQ(gInfo.SubSliceCount, 0u);
-    EXPECT_EQ(gInfo.EUCount, 0u);
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&hwInfo, false, strConfig));
+    EXPECT_EQ(0u, gInfo.SliceCount);
+    EXPECT_EQ(0u, gInfo.SubSliceCount);
+    EXPECT_EQ(0u, gInfo.EUCount);
+}
+
+using LkfHwInfo = ::testing::Test;
+
+LKFTEST_F(LkfHwInfo, givenBoolWhenCallLkfHardwareInfoSetupThenFeatureTableAndWorkaroundTableAreSetCorrect) {
+    bool boolValue[]{
+        true, false};
+    GT_SYSTEM_INFO gInfo = {0};
+    FeatureTable pSkuTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gInfo;
+    hwInfo.pSkuTable = &pSkuTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
+
+    std::string strConfig = "1x8x8";
+
+    for (auto setParamBool : boolValue) {
+
+        gInfo = {0};
+        pSkuTable = {};
+        pWaTable = {};
+        hardwareInfoSetup[productFamily](&hwInfo, setParamBool, strConfig);
+
+        EXPECT_EQ(setParamBool, pSkuTable.ftrPPGTT);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrSVM);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrIA32eGfxPTEs);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrStandardMipTailFormat);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrDisplayYTiling);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrTranslationTable);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrUserModeTranslationTable);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrTileMappedResource);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrEnableGuC);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrFbc);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrFbc2AddressTranslation);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrFbcBlitterTracking);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrFbcCpuTracking);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrTileY);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrAstcHdr2D);
+        EXPECT_EQ(setParamBool, pSkuTable.ftrAstcLdr2D);
+
+        EXPECT_EQ(setParamBool, pWaTable.wa4kAlignUVOffsetNV12LinearSurface);
+        EXPECT_EQ(setParamBool, pWaTable.waReportPerfCountUseGlobalContextID);
+    }
 }
diff --git a/unit_tests/gen8/bdw/linux/hw_info_config_tests_bdw.cpp b/unit_tests/gen8/bdw/linux/hw_info_config_tests_bdw.cpp
index 31361afdeb..d1ebb7816a 100644
--- a/unit_tests/gen8/bdw/linux/hw_info_config_tests_bdw.cpp
+++ b/unit_tests/gen8/bdw/linux/hw_info_config_tests_bdw.cpp
@@ -41,8 +41,6 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, configureHwInfo) {
     EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGTC);
     EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGTX);
 
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTileY);
-
     ReleaseOutHwInfoStructs();
 
     drm->StoredDeviceID = IBDW_GT1_HALO_MOBL_DEVICE_F0_ID;
@@ -131,7 +129,6 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, configureHwInfoWaFlags) {
     drm->StoredDeviceRevID = 0;
     int ret = hwInfoConfig->configureHwInfo(pInHwInfo, &outHwInfo, osInterface);
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 
     ReleaseOutHwInfoStructs();
 }
@@ -176,8 +173,15 @@ TYPED_TEST_CASE(BdwHwInfoTests, bdwTestTypes);
 TYPED_TEST(BdwHwInfoTests, gtSetupIsCorrect) {
     GT_SYSTEM_INFO gtSystemInfo;
     FeatureTable featureTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
     memset(&gtSystemInfo, 0, sizeof(gtSystemInfo));
-    TypeParam::setupHardwareInfo(&gtSystemInfo, &featureTable, false);
+    TypeParam::setupHardwareInfo(&hwInfo, false);
     EXPECT_GT(gtSystemInfo.EUCount, 0u);
     EXPECT_GT(gtSystemInfo.ThreadCount, 0u);
     EXPECT_GT(gtSystemInfo.SliceCount, 0u);
diff --git a/unit_tests/gen8/bdw/test_hw_info_config_bdw.cpp b/unit_tests/gen8/bdw/test_hw_info_config_bdw.cpp
index 577cc809ea..79a7bbbea9 100644
--- a/unit_tests/gen8/bdw/test_hw_info_config_bdw.cpp
+++ b/unit_tests/gen8/bdw/test_hw_info_config_bdw.cpp
@@ -13,46 +13,95 @@ TEST(BdwHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorr
     if (IGFX_BROADWELL != productFamily) {
         return;
     }
-    GT_SYSTEM_INFO gInfo = {0};
-    FeatureTable fTable;
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+
     std::string strConfig = "1x3x8";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 23u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(23u, gtSystemInfo.EUCount);
 
     strConfig = "2x3x8";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 2u);
-    EXPECT_EQ(gInfo.SubSliceCount, 6u);
-    EXPECT_EQ(gInfo.EUCount, 47u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(2u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(6u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(47u, gtSystemInfo.EUCount);
 
     strConfig = "1x2x6";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 2u);
-    EXPECT_EQ(gInfo.EUCount, 12u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(2u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(12u, gtSystemInfo.EUCount);
 
     strConfig = "1x3x6";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 18u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(18u, gtSystemInfo.EUCount);
 
     strConfig = "default";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 23u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(23u, gtSystemInfo.EUCount);
 
     strConfig = "erroneous";
-    gInfo = {0};
-    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
-    EXPECT_EQ(gInfo.SliceCount, 0u);
-    EXPECT_EQ(gInfo.SubSliceCount, 0u);
-    EXPECT_EQ(gInfo.EUCount, 0u);
+    gtSystemInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&hwInfo, false, strConfig));
+
+    EXPECT_EQ(0u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.EUCount);
+}
+
+using BdwHwInfo = ::testing::Test;
+
+BDWTEST_F(BdwHwInfo, givenBoolWhenCallBdwHardwareInfoSetupThenFeatureTableAndWorkaroundTableAreSetCorrect) {
+    std::string strConfig[] = {
+        "1x3x8",
+        "2x3x8",
+        "1x2x6",
+        "1x3x6"};
+    bool boolValue[]{
+        true, false};
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    FeatureTable pSkuTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &pSkuTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
+
+    for (auto &config : strConfig) {
+        for (auto setParamBool : boolValue) {
+
+            gtSystemInfo = {0};
+            pSkuTable = {};
+            pWaTable = {};
+            hardwareInfoSetup[productFamily](&hwInfo, setParamBool, config);
+
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPPGTT);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrSVM);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrIA32eGfxPTEs);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc2AddressTranslation);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcBlitterTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcCpuTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTileY);
+
+            EXPECT_EQ(setParamBool, pWaTable.waDisableLSQCROPERFforOCL);
+            EXPECT_EQ(setParamBool, pWaTable.waReportPerfCountUseGlobalContextID);
+            EXPECT_EQ(setParamBool, pWaTable.waUseVAlign16OnTileXYBpp816);
+            EXPECT_EQ(setParamBool, pWaTable.waModifyVFEStateAfterGPGPUPreemption);
+            EXPECT_EQ(setParamBool, pWaTable.waSamplerCacheFlushBetweenRedescribedSurfaceReads);
+        }
+    }
 }
diff --git a/unit_tests/gen9/bxt/linux/hw_info_config_tests.cpp b/unit_tests/gen9/bxt/linux/hw_info_config_tests.cpp
index a419cc5092..4f0025c95d 100644
--- a/unit_tests/gen9/bxt/linux/hw_info_config_tests.cpp
+++ b/unit_tests/gen9/bxt/linux/hw_info_config_tests.cpp
@@ -40,27 +40,9 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, configureHwInfo) {
     //constant sysInfo/ftr flags
     EXPECT_EQ(1u, outHwInfo.pSysInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled);
     EXPECT_TRUE(outHwInfo.pSysInfo->VEBoxInfo.IsValid);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrVEBOX);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrULT);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuMidBatchPreempt);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuThreadGroupLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuMidThreadLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dMidBatchPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dObjectLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPerCtxtPreemptionGranularityControl);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrLCIA);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPPGTT);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrL3IACoherency);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrIA32eGfxPTEs);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrDisplayYTiling);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrUserModeTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrEnableGuC);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbc);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbc2AddressTranslation);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbcBlitterTracking);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbcCpuTracking);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTileY);
 
     EXPECT_EQ(GTTYPE_GTA, outHwInfo.pPlatform->eGTType);
     EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGT1);
@@ -87,7 +69,6 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, configureHwInfo) {
     EXPECT_EQ((unsigned int)drm->StoredHasPooledEU, outHwInfo.pSkuTable->ftrPooledEuEnabled);
     EXPECT_EQ((uint32_t)drm->StoredMinEUinPool, outHwInfo.pSysInfo->EuCountPerPoolMin);
     EXPECT_EQ((outHwInfo.pSysInfo->EUCount - outHwInfo.pSysInfo->EuCountPerPoolMin), outHwInfo.pSysInfo->EuCountPerPoolMax);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGttCacheInvalidation);
     EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
 
     EXPECT_EQ(GTTYPE_GTC, outHwInfo.pPlatform->eGTType);
@@ -244,7 +225,6 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, configureHwInfoWaFlags) {
     drm->StoredDeviceRevID = 0;
     int ret = hwInfoConfig->configureHwInfo(pInHwInfo, &outHwInfo, osInterface);
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 
     ReleaseOutHwInfoStructs();
 }
@@ -265,8 +245,15 @@ TYPED_TEST_CASE(BxtHwInfoTests, bxtTestTypes);
 TYPED_TEST(BxtHwInfoTests, gtSetupIsCorrect) {
     GT_SYSTEM_INFO gtSystemInfo;
     FeatureTable featureTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
     memset(&gtSystemInfo, 0, sizeof(gtSystemInfo));
-    TypeParam::setupHardwareInfo(&gtSystemInfo, &featureTable, false);
+    TypeParam::setupHardwareInfo(&hwInfo, false);
     EXPECT_GT(gtSystemInfo.EUCount, 0u);
     EXPECT_GT(gtSystemInfo.ThreadCount, 0u);
     EXPECT_GT(gtSystemInfo.SliceCount, 0u);
diff --git a/unit_tests/gen9/bxt/test_hw_info_config_bxt.cpp b/unit_tests/gen9/bxt/test_hw_info_config_bxt.cpp
index 0d1d0bad0d..4d5d89e1ca 100644
--- a/unit_tests/gen9/bxt/test_hw_info_config_bxt.cpp
+++ b/unit_tests/gen9/bxt/test_hw_info_config_bxt.cpp
@@ -13,32 +13,100 @@ TEST(BxtHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorr
     if (IGFX_BROXTON != productFamily) {
         return;
     }
-    GT_SYSTEM_INFO gInfo = {0};
-    FeatureTable fTable;
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+
     std::string strConfig = "1x2x6";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 2u);
-    EXPECT_EQ(gInfo.EUCount, 12u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(2u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(12u, gtSystemInfo.EUCount);
 
     strConfig = "1x3x6";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 18u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(18u, gtSystemInfo.EUCount);
 
     strConfig = "default";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 18u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(18u, gtSystemInfo.EUCount);
 
     strConfig = "erroneous";
-    gInfo = {0};
-    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
-    EXPECT_EQ(gInfo.SliceCount, 0u);
-    EXPECT_EQ(gInfo.SubSliceCount, 0u);
-    EXPECT_EQ(gInfo.EUCount, 0u);
+    gtSystemInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&hwInfo, false, strConfig));
+    EXPECT_EQ(0u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.EUCount);
+}
+
+using BxtHwInfo = ::testing::Test;
+
+BXTTEST_F(BxtHwInfo, givenBoolWhenCallBxtHardwareInfoSetupThenFeatureTableAndWorkaroundTableAreSetCorrect) {
+    std::string strConfig[] = {
+        "1x2x6",
+        "1x3x6"};
+    bool boolValue[]{
+        true, false};
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    FeatureTable pSkuTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &pSkuTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
+
+    for (auto &config : strConfig) {
+        for (auto setParamBool : boolValue) {
+
+            gtSystemInfo = {0};
+            pSkuTable = {};
+            pWaTable = {};
+            pPlatform.usRevId = 9;
+            hardwareInfoSetup[productFamily](&hwInfo, setParamBool, config);
+
+            EXPECT_EQ(setParamBool, pSkuTable.ftrVEBOX);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrULT);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrGpGpuMidThreadLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dMidBatchPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dObjectLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPerCtxtPreemptionGranularityControl);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrLCIA);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPPGTT);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrIA32eGfxPTEs);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrDisplayYTiling);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrUserModeTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrEnableGuC);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc2AddressTranslation);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcBlitterTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcCpuTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTileY);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrGttCacheInvalidation);
+
+            EXPECT_EQ(setParamBool, pWaTable.waLLCCachingUnsupported);
+            EXPECT_EQ(setParamBool, pWaTable.waMsaa8xTileYDepthPitchAlignment);
+            EXPECT_EQ(setParamBool, pWaTable.waFbcLinearSurfaceStride);
+            EXPECT_EQ(setParamBool, pWaTable.wa4kAlignUVOffsetNV12LinearSurface);
+            EXPECT_EQ(setParamBool, pWaTable.waEnablePreemptionGranularityControlByUMD);
+            EXPECT_EQ(setParamBool, pWaTable.waSendMIFLUSHBeforeVFE);
+            EXPECT_EQ(setParamBool, pWaTable.waForcePcBbFullCfgRestore);
+            EXPECT_EQ(setParamBool, pWaTable.waReportPerfCountUseGlobalContextID);
+            EXPECT_EQ(setParamBool, pWaTable.waSamplerCacheFlushBetweenRedescribedSurfaceReads);
+
+            pPlatform.usRevId = 1;
+            pSkuTable = {};
+            hardwareInfoSetup[productFamily](&hwInfo, true, config);
+
+            EXPECT_EQ(false, pSkuTable.ftrGttCacheInvalidation);
+        }
+    }
 }
diff --git a/unit_tests/gen9/cfl/linux/hw_info_config_tests_cfl.cpp b/unit_tests/gen9/cfl/linux/hw_info_config_tests_cfl.cpp
index 93b7d51331..234e5cf8ca 100644
--- a/unit_tests/gen9/cfl/linux/hw_info_config_tests_cfl.cpp
+++ b/unit_tests/gen9/cfl/linux/hw_info_config_tests_cfl.cpp
@@ -42,26 +42,11 @@ CFLTEST_F(HwInfoConfigTestLinuxCfl, configureHwInfo) {
     //constant sysInfo/ftr flags
     EXPECT_EQ(1u, outHwInfo.pSysInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled);
     EXPECT_TRUE(outHwInfo.pSysInfo->VEBoxInfo.IsValid);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrVEBOX);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuMidBatchPreempt);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuThreadGroupLevelPreempt);
     EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGpGpuMidThreadLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dMidBatchPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dObjectLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPerCtxtPreemptionGranularityControl);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPPGTT);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrSVM);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrL3IACoherency);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrIA32eGfxPTEs);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrDisplayYTiling);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrUserModeTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrEnableGuC);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbc);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbc2AddressTranslation);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbcBlitterTracking);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbcCpuTracking);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTileY);
 
     ReleaseOutHwInfoStructs();
 
@@ -161,7 +146,6 @@ CFLTEST_F(HwInfoConfigTestLinuxCfl, configureHwInfoWaFlags) {
     drm->StoredDeviceRevID = 0;
     int ret = hwInfoConfig->configureHwInfo(pInHwInfo, &outHwInfo, osInterface);
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 
     ReleaseOutHwInfoStructs();
 }
@@ -206,8 +190,15 @@ TYPED_TEST_CASE(CflHwInfoTests, cflTestTypes);
 TYPED_TEST(CflHwInfoTests, gtSetupIsCorrect) {
     GT_SYSTEM_INFO gtSystemInfo;
     FeatureTable featureTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
     memset(&gtSystemInfo, 0, sizeof(gtSystemInfo));
-    TypeParam::setupHardwareInfo(&gtSystemInfo, &featureTable, false);
+    TypeParam::setupHardwareInfo(&hwInfo, false);
     EXPECT_GT(gtSystemInfo.EUCount, 0u);
     EXPECT_GT(gtSystemInfo.ThreadCount, 0u);
     EXPECT_GT(gtSystemInfo.SliceCount, 0u);
diff --git a/unit_tests/gen9/cfl/test_hw_info_config_cfl.cpp b/unit_tests/gen9/cfl/test_hw_info_config_cfl.cpp
index 6a07e76236..a20a68e4d6 100644
--- a/unit_tests/gen9/cfl/test_hw_info_config_cfl.cpp
+++ b/unit_tests/gen9/cfl/test_hw_info_config_cfl.cpp
@@ -13,53 +13,114 @@ TEST(CflHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorr
     if (IGFX_COFFEELAKE != productFamily) {
         return;
     }
-    GT_SYSTEM_INFO gInfo = {0};
-    FeatureTable fTable;
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+
     std::string strConfig = "1x3x8";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 23u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(23u, gtSystemInfo.EUCount);
 
     strConfig = "2x3x8";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 2u);
-    EXPECT_EQ(gInfo.SubSliceCount, 6u);
-    EXPECT_EQ(gInfo.EUCount, 47u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(2u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(6u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(47u, gtSystemInfo.EUCount);
 
     strConfig = "3x3x8";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 3u);
-    EXPECT_EQ(gInfo.SubSliceCount, 9u);
-    EXPECT_EQ(gInfo.EUCount, 71u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(3u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(9u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(71u, gtSystemInfo.EUCount);
 
     strConfig = "1x2x6";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 2u);
-    EXPECT_EQ(gInfo.EUCount, 11u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(2u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(11u, gtSystemInfo.EUCount);
 
     strConfig = "1x3x6";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 17u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(17u, gtSystemInfo.EUCount);
 
     strConfig = "default";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 17u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(17u, gtSystemInfo.EUCount);
 
     strConfig = "erroneous";
-    gInfo = {0};
-    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
-    EXPECT_EQ(gInfo.SliceCount, 0u);
-    EXPECT_EQ(gInfo.SubSliceCount, 0u);
-    EXPECT_EQ(gInfo.EUCount, 0u);
+    gtSystemInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&hwInfo, false, strConfig));
+    EXPECT_EQ(0u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.EUCount);
+}
+
+using CflHwInfo = ::testing::Test;
+
+CFLTEST_F(CflHwInfo, givenBoolWhenCallCflHardwareInfoSetupThenFeatureTableAndWorkaroundTableAreSetCorrect) {
+    std::string strConfig[] = {
+        "1x3x8",
+        "2x3x8",
+        "3x3x8",
+        "1x2x6",
+        "1x3x6"};
+    bool boolValue[]{
+        true, false};
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    FeatureTable pSkuTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &pSkuTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
+
+    for (auto &config : strConfig) {
+        for (auto setParamBool : boolValue) {
+
+            gtSystemInfo = {0};
+            pSkuTable = {};
+            pWaTable = {};
+            hardwareInfoSetup[productFamily](&hwInfo, setParamBool, config);
+
+            EXPECT_EQ(setParamBool, pSkuTable.ftrVEBOX);
+            EXPECT_EQ(false, pSkuTable.ftrGpGpuMidThreadLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dMidBatchPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dObjectLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPerCtxtPreemptionGranularityControl);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPPGTT);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrSVM);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrIA32eGfxPTEs);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrDisplayYTiling);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrUserModeTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrEnableGuC);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc2AddressTranslation);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcBlitterTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcCpuTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTileY);
+
+            EXPECT_EQ(setParamBool, pWaTable.waEnablePreemptionGranularityControlByUMD);
+            EXPECT_EQ(setParamBool, pWaTable.waSendMIFLUSHBeforeVFE);
+            EXPECT_EQ(setParamBool, pWaTable.waReportPerfCountUseGlobalContextID);
+            EXPECT_EQ(setParamBool, pWaTable.waMsaa8xTileYDepthPitchAlignment);
+            EXPECT_EQ(setParamBool, pWaTable.waLosslessCompressionSurfaceStride);
+            EXPECT_EQ(setParamBool, pWaTable.waFbcLinearSurfaceStride);
+            EXPECT_EQ(setParamBool, pWaTable.wa4kAlignUVOffsetNV12LinearSurface);
+            EXPECT_EQ(setParamBool, pWaTable.waSamplerCacheFlushBetweenRedescribedSurfaceReads);
+        }
+    }
 }
diff --git a/unit_tests/gen9/glk/linux/hw_info_config_tests_glk.cpp b/unit_tests/gen9/glk/linux/hw_info_config_tests_glk.cpp
index 52b4321170..e3a2e70090 100644
--- a/unit_tests/gen9/glk/linux/hw_info_config_tests_glk.cpp
+++ b/unit_tests/gen9/glk/linux/hw_info_config_tests_glk.cpp
@@ -49,22 +49,7 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, configureHwInfo) {
     EXPECT_TRUE(outHwInfo.pSysInfo->VEBoxInfo.IsValid);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuMidBatchPreempt);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuThreadGroupLevelPreempt);
-    EXPECT_EQ(0u, outHwInfo.pSkuTable->ftrGpGpuMidThreadLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dMidBatchPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dObjectLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPerCtxtPreemptionGranularityControl);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrLCIA);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPPGTT);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrL3IACoherency);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrIA32eGfxPTEs);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrUserModeTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrEnableGuC);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTileMappedResource);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrULT);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrAstcHdr2D);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrAstcLdr2D);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTileY);
 
     ReleaseOutHwInfoStructs();
 
@@ -232,7 +217,6 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, configureHwInfoWaFlags) {
     drm->StoredDeviceRevID = 0;
     int ret = hwInfoConfig->configureHwInfo(pInHwInfo, &outHwInfo, osInterface);
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 
     ReleaseOutHwInfoStructs();
 }
@@ -253,8 +237,15 @@ TYPED_TEST_CASE(GlkHwInfoTests, glkTestTypes);
 TYPED_TEST(GlkHwInfoTests, gtSetupIsCorrect) {
     GT_SYSTEM_INFO gtSystemInfo;
     FeatureTable featureTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
     memset(&gtSystemInfo, 0, sizeof(gtSystemInfo));
-    TypeParam::setupHardwareInfo(&gtSystemInfo, &featureTable, false);
+    TypeParam::setupHardwareInfo(&hwInfo, false);
     EXPECT_GT(gtSystemInfo.EUCount, 0u);
     EXPECT_GT(gtSystemInfo.ThreadCount, 0u);
     EXPECT_GT(gtSystemInfo.SliceCount, 0u);
diff --git a/unit_tests/gen9/glk/test_hw_info_config_glk.cpp b/unit_tests/gen9/glk/test_hw_info_config_glk.cpp
index a006f3038d..4b19d485e3 100644
--- a/unit_tests/gen9/glk/test_hw_info_config_glk.cpp
+++ b/unit_tests/gen9/glk/test_hw_info_config_glk.cpp
@@ -13,32 +13,95 @@ TEST(GlkHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorr
     if (IGFX_GEMINILAKE != productFamily) {
         return;
     }
-    GT_SYSTEM_INFO gInfo = {0};
-    FeatureTable fTable;
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    FeatureTable pSkuTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &pSkuTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
+
     std::string strConfig = "1x2x6";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 2u);
-    EXPECT_EQ(gInfo.EUCount, 12u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(2u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(12u, gtSystemInfo.EUCount);
 
     strConfig = "1x3x6";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 18u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(18u, gtSystemInfo.EUCount);
 
     strConfig = "default";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 18u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(18u, gtSystemInfo.EUCount);
 
     strConfig = "erroneous";
-    gInfo = {0};
-    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
-    EXPECT_EQ(gInfo.SliceCount, 0u);
-    EXPECT_EQ(gInfo.SubSliceCount, 0u);
-    EXPECT_EQ(gInfo.EUCount, 0u);
+    gtSystemInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&hwInfo, false, strConfig));
+    EXPECT_EQ(0u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.EUCount);
+}
+
+using GlkHwInfo = ::testing::Test;
+
+GLKTEST_F(GlkHwInfo, givenBoolWhenCallGlkHardwareInfoSetupThenFeatureTableAndWorkaroundTableAreSetCorrect) {
+    std::string strConfig[] = {
+        "1x2x6",
+        "1x3x6"};
+    bool boolValue[]{
+        true, false};
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    FeatureTable pSkuTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &pSkuTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
+
+    for (auto &config : strConfig) {
+        for (auto setParamBool : boolValue) {
+
+            gtSystemInfo = {0};
+            pSkuTable = {};
+            pWaTable = {};
+            hardwareInfoSetup[productFamily](&hwInfo, setParamBool, config);
+
+            EXPECT_EQ(false, pSkuTable.ftrGpGpuMidThreadLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dMidBatchPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dObjectLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPerCtxtPreemptionGranularityControl);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrLCIA);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPPGTT);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrIA32eGfxPTEs);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrUserModeTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrEnableGuC);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTileMappedResource);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrULT);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrAstcHdr2D);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrAstcLdr2D);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTileY);
+
+            EXPECT_EQ(setParamBool, pWaTable.waLLCCachingUnsupported);
+            EXPECT_EQ(setParamBool, pWaTable.waMsaa8xTileYDepthPitchAlignment);
+            EXPECT_EQ(setParamBool, pWaTable.waFbcLinearSurfaceStride);
+            EXPECT_EQ(setParamBool, pWaTable.wa4kAlignUVOffsetNV12LinearSurface);
+            EXPECT_EQ(setParamBool, pWaTable.waEnablePreemptionGranularityControlByUMD);
+            EXPECT_EQ(setParamBool, pWaTable.waSendMIFLUSHBeforeVFE);
+            EXPECT_EQ(setParamBool, pWaTable.waForcePcBbFullCfgRestore);
+            EXPECT_EQ(setParamBool, pWaTable.waReportPerfCountUseGlobalContextID);
+            EXPECT_EQ(setParamBool, pWaTable.waSamplerCacheFlushBetweenRedescribedSurfaceReads);
+        }
+    }
 }
diff --git a/unit_tests/gen9/kbl/linux/hw_info_config_tests_kbl.cpp b/unit_tests/gen9/kbl/linux/hw_info_config_tests_kbl.cpp
index 4b79525a8e..d12b295807 100644
--- a/unit_tests/gen9/kbl/linux/hw_info_config_tests_kbl.cpp
+++ b/unit_tests/gen9/kbl/linux/hw_info_config_tests_kbl.cpp
@@ -42,26 +42,10 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, configureHwInfo) {
     //constant sysInfo/ftr flags
     EXPECT_EQ(1u, outHwInfo.pSysInfo->VEBoxInfo.Instances.Bits.VEBox0Enabled);
     EXPECT_TRUE(outHwInfo.pSysInfo->VEBoxInfo.IsValid);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrVEBOX);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuMidBatchPreempt);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuThreadGroupLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuMidThreadLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dMidBatchPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dObjectLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPerCtxtPreemptionGranularityControl);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPPGTT);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrSVM);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrL3IACoherency);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrIA32eGfxPTEs);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrDisplayYTiling);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrUserModeTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrEnableGuC);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbc);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbc2AddressTranslation);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbcBlitterTracking);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbcCpuTracking);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTileY);
 
     ReleaseOutHwInfoStructs();
 
@@ -207,10 +191,6 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, configureHwInfoWaFlags) {
     drm->StoredDeviceRevID = 0;
     int ret = hwInfoConfig->configureHwInfo(pInHwInfo, &outHwInfo, osInterface);
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waDisableLSQCROPERFforOCL);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waEncryptedEdramOnlyPartials);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waForcePcBbFullCfgRestore);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 
     ReleaseOutHwInfoStructs();
 
@@ -219,8 +199,6 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, configureHwInfoWaFlags) {
     EXPECT_EQ(0, ret);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waDisableLSQCROPERFforOCL);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waEncryptedEdramOnlyPartials);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waForcePcBbFullCfgRestore);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 
     ReleaseOutHwInfoStructs();
 
@@ -230,7 +208,6 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, configureHwInfoWaFlags) {
     EXPECT_EQ(0u, outHwInfo.pWaTable->waDisableLSQCROPERFforOCL);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waEncryptedEdramOnlyPartials);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waForcePcBbFullCfgRestore);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 }
 
 KBLTEST_F(HwInfoConfigTestLinuxKbl, configureHwInfoEdram) {
@@ -273,8 +250,15 @@ TYPED_TEST_CASE(KblHwInfoTests, kblTestTypes);
 TYPED_TEST(KblHwInfoTests, gtSetupIsCorrect) {
     GT_SYSTEM_INFO gtSystemInfo;
     FeatureTable featureTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
     memset(&gtSystemInfo, 0, sizeof(gtSystemInfo));
-    TypeParam::setupHardwareInfo(&gtSystemInfo, &featureTable, false);
+    TypeParam::setupHardwareInfo(&hwInfo, false);
     EXPECT_GT(gtSystemInfo.EUCount, 0u);
     EXPECT_GT(gtSystemInfo.ThreadCount, 0u);
     EXPECT_GT(gtSystemInfo.SliceCount, 0u);
diff --git a/unit_tests/gen9/kbl/test_hw_info_config_kbl.cpp b/unit_tests/gen9/kbl/test_hw_info_config_kbl.cpp
index 82cb7c3c95..172ab5ece3 100644
--- a/unit_tests/gen9/kbl/test_hw_info_config_kbl.cpp
+++ b/unit_tests/gen9/kbl/test_hw_info_config_kbl.cpp
@@ -13,53 +13,126 @@ TEST(KblHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorr
     if (IGFX_KABYLAKE != productFamily) {
         return;
     }
-    GT_SYSTEM_INFO gInfo = {0};
-    FeatureTable fTable;
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+
     std::string strConfig = "1x3x8";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 23u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(23u, gtSystemInfo.EUCount);
 
     strConfig = "2x3x8";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 2u);
-    EXPECT_EQ(gInfo.SubSliceCount, 6u);
-    EXPECT_EQ(gInfo.EUCount, 47u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(2u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(6u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(47u, gtSystemInfo.EUCount);
 
     strConfig = "3x3x8";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 3u);
-    EXPECT_EQ(gInfo.SubSliceCount, 9u);
-    EXPECT_EQ(gInfo.EUCount, 71u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(3u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(9u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(71u, gtSystemInfo.EUCount);
 
     strConfig = "1x2x6";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 2u);
-    EXPECT_EQ(gInfo.EUCount, 11u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(2u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(11u, gtSystemInfo.EUCount);
 
     strConfig = "1x3x6";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 17u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(17u, gtSystemInfo.EUCount);
 
     strConfig = "default";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 17u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(17u, gtSystemInfo.EUCount);
 
     strConfig = "erroneous";
-    gInfo = {0};
-    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
-    EXPECT_EQ(gInfo.SliceCount, 0u);
-    EXPECT_EQ(gInfo.SubSliceCount, 0u);
-    EXPECT_EQ(gInfo.EUCount, 0u);
+    gtSystemInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&hwInfo, false, strConfig));
+    EXPECT_EQ(0u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.EUCount);
+}
+
+using KblHwInfo = ::testing::Test;
+
+KBLTEST_F(KblHwInfo, givenBoolWhenCallKblHardwareInfoSetupThenFeatureTableAndWorkaroundTableAreSetCorrect) {
+    std::string strConfig[] = {
+        "1x3x8",
+        "2x3x8",
+        "3x3x8",
+        "1x2x6",
+        "1x3x6"};
+    bool boolValue[]{
+        true, false};
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    FeatureTable pSkuTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &pSkuTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
+
+    for (auto &config : strConfig) {
+        for (auto setParamBool : boolValue) {
+
+            gtSystemInfo = {0};
+            pSkuTable = {};
+            pWaTable = {};
+            pPlatform.usRevId = 9;
+            hardwareInfoSetup[productFamily](&hwInfo, setParamBool, config);
+
+            EXPECT_EQ(setParamBool, pSkuTable.ftrVEBOX);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrGpGpuMidThreadLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dMidBatchPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dObjectLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPerCtxtPreemptionGranularityControl);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPPGTT);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrSVM);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrIA32eGfxPTEs);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrDisplayYTiling);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrUserModeTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrEnableGuC);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc2AddressTranslation);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcBlitterTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcCpuTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTileY);
+
+            EXPECT_EQ(setParamBool, pWaTable.waEnablePreemptionGranularityControlByUMD);
+            EXPECT_EQ(setParamBool, pWaTable.waSendMIFLUSHBeforeVFE);
+            EXPECT_EQ(setParamBool, pWaTable.waReportPerfCountUseGlobalContextID);
+            EXPECT_EQ(setParamBool, pWaTable.waMsaa8xTileYDepthPitchAlignment);
+            EXPECT_EQ(setParamBool, pWaTable.waLosslessCompressionSurfaceStride);
+            EXPECT_EQ(setParamBool, pWaTable.waFbcLinearSurfaceStride);
+            EXPECT_EQ(setParamBool, pWaTable.wa4kAlignUVOffsetNV12LinearSurface);
+            EXPECT_EQ(setParamBool, pWaTable.waSamplerCacheFlushBetweenRedescribedSurfaceReads);
+            EXPECT_EQ(false, pWaTable.waDisableLSQCROPERFforOCL);
+            EXPECT_EQ(false, pWaTable.waEncryptedEdramOnlyPartials);
+            EXPECT_EQ(false, pWaTable.waForcePcBbFullCfgRestore);
+
+            pPlatform.usRevId = 1;
+            pWaTable = {};
+            hardwareInfoSetup[productFamily](&hwInfo, true, config);
+
+            EXPECT_EQ(true, pWaTable.waDisableLSQCROPERFforOCL);
+            EXPECT_EQ(true, pWaTable.waEncryptedEdramOnlyPartials);
+            EXPECT_EQ(true, pWaTable.waForcePcBbFullCfgRestore);
+        }
+    }
 }
diff --git a/unit_tests/gen9/skl/linux/hw_info_config_tests_skl.cpp b/unit_tests/gen9/skl/linux/hw_info_config_tests_skl.cpp
index 7ab4164f61..483ae5536a 100644
--- a/unit_tests/gen9/skl/linux/hw_info_config_tests_skl.cpp
+++ b/unit_tests/gen9/skl/linux/hw_info_config_tests_skl.cpp
@@ -46,25 +46,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, configureHwInfo) {
     EXPECT_TRUE(outHwInfo.pSysInfo->VDBoxInfo.IsValid);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuMidBatchPreempt);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuThreadGroupLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrGpGpuMidThreadLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dMidBatchPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftr3dObjectLevelPreempt);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPerCtxtPreemptionGranularityControl);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrPPGTT);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrSVM);
     EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrL3IACoherency);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrIA32eGfxPTEs);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrDisplayYTiling);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrUserModeTranslationTable);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrEnableGuC);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbc);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbc2AddressTranslation);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbcBlitterTracking);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrFbcCpuTracking);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrVEBOX);
-    EXPECT_EQ(1u, outHwInfo.pSkuTable->ftrTileY);
-
     ReleaseOutHwInfoStructs();
 
     drm->StoredDeviceID = ISKL_GT1_DT_DEVICE_F0_ID;
@@ -207,22 +189,12 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, configureHwInfoWaFlags) {
     drm->StoredDeviceRevID = 1;
     int ret = hwInfoConfig->configureHwInfo(pInHwInfo, &outHwInfo, osInterface);
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waCompressedResourceRequiresConstVA21);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waModifyVFEStateAfterGPGPUPreemption);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waDisablePerCtxtPreemptionGranularityControl);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waCSRUncachable);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
-
     ReleaseOutHwInfoStructs();
 
     drm->StoredDeviceRevID = 0;
     ret = hwInfoConfig->configureHwInfo(pInHwInfo, &outHwInfo, osInterface);
     EXPECT_EQ(0, ret);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waCompressedResourceRequiresConstVA21);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waModifyVFEStateAfterGPGPUPreemption);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waDisablePerCtxtPreemptionGranularityControl);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waCSRUncachable);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 
     ReleaseOutHwInfoStructs();
 
@@ -232,8 +204,6 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, configureHwInfoWaFlags) {
     EXPECT_EQ(0u, outHwInfo.pWaTable->waCompressedResourceRequiresConstVA21);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waModifyVFEStateAfterGPGPUPreemption);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waDisablePerCtxtPreemptionGranularityControl);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waCSRUncachable);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 
     ReleaseOutHwInfoStructs();
 
@@ -244,7 +214,6 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, configureHwInfoWaFlags) {
     EXPECT_EQ(0u, outHwInfo.pWaTable->waModifyVFEStateAfterGPGPUPreemption);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waDisablePerCtxtPreemptionGranularityControl);
     EXPECT_EQ(0u, outHwInfo.pWaTable->waCSRUncachable);
-    EXPECT_EQ(1u, outHwInfo.pWaTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads);
 }
 
 SKLTEST_F(HwInfoConfigTestLinuxSkl, configureHwInfoEdram) {
@@ -314,8 +283,15 @@ TYPED_TEST_CASE(SklHwInfoTests, sklTestTypes);
 TYPED_TEST(SklHwInfoTests, gtSetupIsCorrect) {
     GT_SYSTEM_INFO gtSystemInfo;
     FeatureTable featureTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &featureTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
     memset(&gtSystemInfo, 0, sizeof(gtSystemInfo));
-    TypeParam::setupHardwareInfo(&gtSystemInfo, &featureTable, false);
+    TypeParam::setupHardwareInfo(&hwInfo, false);
     EXPECT_GT(gtSystemInfo.EUCount, 0u);
     EXPECT_GT(gtSystemInfo.ThreadCount, 0u);
     EXPECT_GT(gtSystemInfo.SliceCount, 0u);
diff --git a/unit_tests/gen9/skl/test_hw_info_config_skl.cpp b/unit_tests/gen9/skl/test_hw_info_config_skl.cpp
index 7a3ef7d386..be441ed096 100644
--- a/unit_tests/gen9/skl/test_hw_info_config_skl.cpp
+++ b/unit_tests/gen9/skl/test_hw_info_config_skl.cpp
@@ -13,53 +13,161 @@ TEST(SklHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorr
     if (IGFX_SKYLAKE != productFamily) {
         return;
     }
-    GT_SYSTEM_INFO gInfo = {0};
-    FeatureTable fTable;
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+
     std::string strConfig = "1x3x8";
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 23u);
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(23u, gtSystemInfo.EUCount);
 
     strConfig = "2x3x8";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 2u);
-    EXPECT_EQ(gInfo.SubSliceCount, 6u);
-    EXPECT_EQ(gInfo.EUCount, 47u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(2u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(6u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(47u, gtSystemInfo.EUCount);
 
     strConfig = "3x3x8";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 3u);
-    EXPECT_EQ(gInfo.SubSliceCount, 9u);
-    EXPECT_EQ(gInfo.EUCount, 71u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(3u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(9u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(71u, gtSystemInfo.EUCount);
 
     strConfig = "1x2x6";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 2u);
-    EXPECT_EQ(gInfo.EUCount, 11u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(2u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(11u, gtSystemInfo.EUCount);
 
     strConfig = "1x3x6";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 17u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(17u, gtSystemInfo.EUCount);
 
     strConfig = "default";
-    gInfo = {0};
-    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
-    EXPECT_EQ(gInfo.SliceCount, 1u);
-    EXPECT_EQ(gInfo.SubSliceCount, 3u);
-    EXPECT_EQ(gInfo.EUCount, 23u);
+    gtSystemInfo = {0};
+    hardwareInfoSetup[productFamily](&hwInfo, false, strConfig);
+    EXPECT_EQ(1u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(3u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(23u, gtSystemInfo.EUCount);
 
     strConfig = "erroneous";
-    gInfo = {0};
-    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
-    EXPECT_EQ(gInfo.SliceCount, 0u);
-    EXPECT_EQ(gInfo.SubSliceCount, 0u);
-    EXPECT_EQ(gInfo.EUCount, 0u);
+
+    gtSystemInfo = {0};
+
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&hwInfo, false, strConfig));
+    EXPECT_EQ(0u, gtSystemInfo.SliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.SubSliceCount);
+    EXPECT_EQ(0u, gtSystemInfo.EUCount);
+}
+
+using SklHwInfo = ::testing::Test;
+
+SKLTEST_F(SklHwInfo, givenBoolWhenCallSklHardwareInfoSetupThenFeatureTableAndWorkaroundTableAreSetCorrect) {
+    std::string strConfig[] = {
+        "1x3x8",
+        "2x3x8",
+        "3x3x8",
+        "1x2x6",
+        "1x3x6"};
+    bool boolValue[]{
+        true, false};
+    GT_SYSTEM_INFO gtSystemInfo = {0};
+    FeatureTable pSkuTable;
+    WorkaroundTable pWaTable;
+    PLATFORM pPlatform;
+    HardwareInfo hwInfo;
+    hwInfo.pSysInfo = &gtSystemInfo;
+    hwInfo.pSkuTable = &pSkuTable;
+    hwInfo.pWaTable = &pWaTable;
+    hwInfo.pPlatform = &pPlatform;
+
+    for (auto &config : strConfig) {
+        for (auto setParamBool : boolValue) {
+
+            gtSystemInfo = {0};
+            pSkuTable = {};
+            pWaTable = {};
+            pPlatform.usRevId = 9;
+            hardwareInfoSetup[productFamily](&hwInfo, setParamBool, config);
+
+            EXPECT_EQ(setParamBool, pSkuTable.ftrGpGpuMidThreadLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dMidBatchPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftr3dObjectLevelPreempt);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPerCtxtPreemptionGranularityControl);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrPPGTT);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrSVM);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrIA32eGfxPTEs);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrDisplayYTiling);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrUserModeTranslationTable);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrEnableGuC);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbc2AddressTranslation);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcBlitterTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrFbcCpuTracking);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrVEBOX);
+            EXPECT_EQ(setParamBool, pSkuTable.ftrTileY);
+            EXPECT_EQ(false, pSkuTable.ftrSingleVeboxSlice);
+            EXPECT_EQ(false, pSkuTable.ftrVcs2);
+
+            EXPECT_EQ(setParamBool, pWaTable.waEnablePreemptionGranularityControlByUMD);
+            EXPECT_EQ(setParamBool, pWaTable.waSendMIFLUSHBeforeVFE);
+            EXPECT_EQ(setParamBool, pWaTable.waReportPerfCountUseGlobalContextID);
+            EXPECT_EQ(setParamBool, pWaTable.waDisableLSQCROPERFforOCL);
+            EXPECT_EQ(setParamBool, pWaTable.waMsaa8xTileYDepthPitchAlignment);
+            EXPECT_EQ(setParamBool, pWaTable.waLosslessCompressionSurfaceStride);
+            EXPECT_EQ(setParamBool, pWaTable.waFbcLinearSurfaceStride);
+            EXPECT_EQ(setParamBool, pWaTable.wa4kAlignUVOffsetNV12LinearSurface);
+            EXPECT_EQ(setParamBool, pWaTable.waEncryptedEdramOnlyPartials);
+            EXPECT_EQ(setParamBool, pWaTable.waDisableEdramForDisplayRT);
+            EXPECT_EQ(setParamBool, pWaTable.waForcePcBbFullCfgRestore);
+            EXPECT_EQ(setParamBool, pWaTable.waSamplerCacheFlushBetweenRedescribedSurfaceReads);
+            EXPECT_EQ(false, pWaTable.waCompressedResourceRequiresConstVA21);
+            EXPECT_EQ(false, pWaTable.waDisablePerCtxtPreemptionGranularityControl);
+            EXPECT_EQ(false, pWaTable.waModifyVFEStateAfterGPGPUPreemption);
+            EXPECT_EQ(false, pWaTable.waCSRUncachable);
+
+            pPlatform.usRevId = 1;
+            pWaTable = {};
+            pSkuTable = {};
+            pSkuTable.ftrGT1 = true;
+            pSkuTable.ftrGT3 = true;
+            hardwareInfoSetup[productFamily](&hwInfo, true, config);
+
+            EXPECT_EQ(true, pWaTable.waCompressedResourceRequiresConstVA21);
+            EXPECT_EQ(true, pWaTable.waDisablePerCtxtPreemptionGranularityControl);
+            EXPECT_EQ(true, pWaTable.waModifyVFEStateAfterGPGPUPreemption);
+            EXPECT_EQ(true, pWaTable.waCSRUncachable);
+            EXPECT_EQ(true, pSkuTable.ftrSingleVeboxSlice);
+            EXPECT_EQ(true, pSkuTable.ftrVcs2);
+
+            pWaTable = {};
+            pSkuTable = {};
+            pSkuTable.ftrGT2 = true;
+            pSkuTable.ftrGT4 = true;
+            hardwareInfoSetup[productFamily](&hwInfo, true, config);
+
+            EXPECT_EQ(true, pSkuTable.ftrSingleVeboxSlice);
+            EXPECT_EQ(true, pSkuTable.ftrVcs2);
+
+            pWaTable = {};
+            pSkuTable = {};
+            pSkuTable.ftrGT1 = true;
+            pSkuTable.ftrGT2 = true;
+            pSkuTable.ftrGT3 = true;
+            pSkuTable.ftrGT4 = true;
+            hardwareInfoSetup[productFamily](&hwInfo, true, config);
+
+            EXPECT_EQ(true, pSkuTable.ftrSingleVeboxSlice);
+            EXPECT_EQ(true, pSkuTable.ftrVcs2);
+        }
+    }
 }
diff --git a/unit_tests/main.cpp b/unit_tests/main.cpp
index 0ab2d39dc0..52896526a1 100644
--- a/unit_tests/main.cpp
+++ b/unit_tests/main.cpp
@@ -173,7 +173,7 @@ int main(int argc, char **argv) {
     int retVal = 0;
     bool useDefaultListener = false;
     bool enable_alarm = true;
-    bool setupFeatureTable = testMode == TestMode::AubTests ? true : false;
+    bool setupFeatureTableAndWorkaroundTable = testMode == TestMode::AubTests ? true : false;
     bool enableMemoryDumps = false;
 
     applyWorkarounds();
@@ -196,9 +196,10 @@ int main(int argc, char **argv) {
     std::string hwInfoConfig = "default";
     auto numDevices = numPlatformDevices;
     HardwareInfo device = DEFAULT_TEST_PLATFORM::hwInfo;
-    hardwareInfoSetup[device.pPlatform->eProductFamily](const_cast<GT_SYSTEM_INFO *>(device.pSysInfo), const_cast<FeatureTable *>(device.pSkuTable), setupFeatureTable, hwInfoConfig);
+    hardwareInfoSetup[device.pPlatform->eProductFamily](&device, setupFeatureTableAndWorkaroundTable, hwInfoConfig);
     GT_SYSTEM_INFO gtSystemInfo = *device.pSysInfo;
     FeatureTable featureTable = *device.pSkuTable;
+    WorkaroundTable workaroundTable = *device.pWaTable;
 
     size_t revisionId = device.pPlatform->usRevId;
     uint32_t euPerSubSlice = 0;
@@ -307,13 +308,15 @@ int main(int argc, char **argv) {
         return -1;
     }
     platform = *hardwareInfo->pPlatform;
-    featureTable = *hardwareInfo->pSkuTable;
-    gtSystemInfo = *hardwareInfo->pSysInfo;
 
     platform.usRevId = (uint16_t)revisionId;
-
+    HardwareInfo hwInfo = *hardwareInfo;
     // set Gt and FeatureTable to initial state
-    hardwareInfoSetup[productFamily](&gtSystemInfo, &featureTable, setupFeatureTable, hwInfoConfig);
+    hardwareInfoSetup[productFamily](&hwInfo, setupFeatureTableAndWorkaroundTable, hwInfoConfig);
+    featureTable = *hwInfo.pSkuTable;
+    gtSystemInfo = *hwInfo.pSysInfo;
+    workaroundTable = *hwInfo.pWaTable;
+
     // and adjust dynamic values if not secified
     sliceCount = sliceCount > 0 ? sliceCount : gtSystemInfo.SliceCount;
     subSlicePerSliceCount = subSlicePerSliceCount > 0 ? subSlicePerSliceCount : (gtSystemInfo.SubSliceCount / sliceCount);
@@ -335,6 +338,7 @@ int main(int argc, char **argv) {
     device.pPlatform = &platform;
     device.pSysInfo = &gtSystemInfo;
     device.pSkuTable = &featureTable;
+    device.pWaTable = &workaroundTable;
     device.capabilityTable = hardwareInfo->capabilityTable;
 
     binaryNameSuffix.append(familyName[device.pPlatform->eRenderCoreFamily]);