Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove not used GT type info

Browse Source 
Signed-off-by: Bartosz Dunajski <bartosz.dunajski@intel.com>
This commit is contained in:
Bartosz Dunajski
2022-01-26 16:25:28 +00:00
committed by Compute-Runtime-Automation
parent a5067d6b0b
commit 72edadb265
50 changed files with 505 additions and 935 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
opencl/test/unit_test/gen11/ehl/linux/dll/device_id_tests_ehl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,15 +11,15 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenEhlSpportedDeviceIdWhenCheckingHwSetupThenItIsCorrect) {
std::array<DeviceDescriptor, 9> expectedDescriptors = {{
{0x4500, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4541, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4551, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4571, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4555, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4E51, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4E61, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4E71, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4E55, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4500, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4541, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4551, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4571, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4555, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4E51, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4E61, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4E71, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4E55, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

17
opencl/test/unit_test/gen11/ehl/linux/hw_info_config_tests_ehl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -15,7 +15,7 @@ struct HwInfoConfigTestLinuxEhl : HwInfoConfigTestLinux {
HwInfoConfigTestLinux::SetUp();
drm->storedDeviceID = IEHL_1x4x8_SUPERSKU_DEVICE_A0_ID;
drm->setGtType(GTTYPE_GT1);
drm->storedSSVal = 8;
}
};
@ -29,17 +29,6 @@ EHLTEST_F(HwInfoConfigTestLinuxEhl, GivenEhlThenHwInfoIsCorrect) {
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.platform.eGTType);
EXPECT_TRUE(outHwInfo.featureTable.flags.ftrGT1);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT2);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT3);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT4);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTA);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTC);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTX);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
EHLTEST_F(HwInfoConfigTestLinuxEhl, GivenInvalidDeviceIdWhenConfiguringHwInfoThenNegativeOneReturned) {
@ -75,7 +64,7 @@ TEST(EhlHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &EHL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &EHL_HW_CONFIG::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

18
opencl/test/unit_test/gen11/icllp/linux/dll/device_id_tests_icllp.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,16 +11,16 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenIcllpSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 8> expectedDescriptors = {{
{0xFF05, &ICLLP_1x4x8::hwInfo, &ICLLP_1x4x8::setupHardwareInfo, GTTYPE_GT1},
{0x8A56, &ICLLP_1x4x8::hwInfo, &ICLLP_1x4x8::setupHardwareInfo, GTTYPE_GT1},
{0x8A58, &ICLLP_1x4x8::hwInfo, &ICLLP_1x4x8::setupHardwareInfo, GTTYPE_GT1},
{0xFF05, &ICLLP_1x4x8::hwInfo, &ICLLP_1x4x8::setupHardwareInfo},
{0x8A56, &ICLLP_1x4x8::hwInfo, &ICLLP_1x4x8::setupHardwareInfo},
{0x8A58, &ICLLP_1x4x8::hwInfo, &ICLLP_1x4x8::setupHardwareInfo},
{0x8A5C, &ICLLP_1x6x8::hwInfo, &ICLLP_1x6x8::setupHardwareInfo, GTTYPE_GT1},
{0x8A5A, &ICLLP_1x6x8::hwInfo, &ICLLP_1x6x8::setupHardwareInfo, GTTYPE_GT1},
{0x8A5C, &ICLLP_1x6x8::hwInfo, &ICLLP_1x6x8::setupHardwareInfo},
{0x8A5A, &ICLLP_1x6x8::hwInfo, &ICLLP_1x6x8::setupHardwareInfo},
{0x8A50, &ICLLP_1x8x8::hwInfo, &ICLLP_1x8x8::setupHardwareInfo, GTTYPE_GT2},
{0x8A52, &ICLLP_1x8x8::hwInfo, &ICLLP_1x8x8::setupHardwareInfo, GTTYPE_GT2},
{0x8A51, &ICLLP_1x8x8::hwInfo, &ICLLP_1x8x8::setupHardwareInfo, GTTYPE_GT2},
{0x8A50, &ICLLP_1x8x8::hwInfo, &ICLLP_1x8x8::setupHardwareInfo},
{0x8A52, &ICLLP_1x8x8::hwInfo, &ICLLP_1x8x8::setupHardwareInfo},
{0x8A51, &ICLLP_1x8x8::hwInfo, &ICLLP_1x8x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

14
opencl/test/unit_test/gen11/icllp/linux/hw_info_config_tests_icllp.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -15,7 +15,6 @@ struct HwInfoConfigTestLinuxIcllp : HwInfoConfigTestLinux {
HwInfoConfigTestLinux::SetUp();
drm->storedDeviceID = IICL_LP_GT1_MOB_DEVICE_F0_ID;
drm->setGtType(GTTYPE_GT1);
}
};
@ -30,15 +29,6 @@ ICLLPTEST_F(HwInfoConfigTestLinuxIcllp, GivenIcllpThenHwInfoIsCorrect) {
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.platform.eGTType);
EXPECT_TRUE(outHwInfo.featureTable.flags.ftrGT1);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT2);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT3);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT4);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTA);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTC);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTX);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
@ -77,7 +67,7 @@ TYPED_TEST(IcllpHwInfoTests, WhenGettingSystemInfoThenParamsAreValid) {
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

4
opencl/test/unit_test/gen11/lkf/linux/dll/device_id_tests_lkf.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,7 +11,7 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenLkfSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 1> expectedDescriptors = {{
{0x9840, &LKF_1x8x8::hwInfo, &LKF_1x8x8::setupHardwareInfo, GTTYPE_GT1},
{0x9840, &LKF_1x8x8::hwInfo, &LKF_1x8x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

15
opencl/test/unit_test/gen11/lkf/linux/hw_info_config_tests_lkf.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -15,7 +15,7 @@ struct HwInfoConfigTestLinuxLkf : HwInfoConfigTestLinux {
HwInfoConfigTestLinux::SetUp();
drm->storedDeviceID = ILKF_1x8x8_DESK_DEVICE_F0_ID;
drm->setGtType(GTTYPE_GT1);
drm->storedSSVal = 8;
}
};
@ -30,15 +30,6 @@ LKFTEST_F(HwInfoConfigTestLinuxLkf, configureHwInfoLkf) {
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.platform.eGTType);
EXPECT_TRUE(outHwInfo.featureTable.flags.ftrGT1);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT2);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT3);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT4);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTA);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTC);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTX);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
@ -77,7 +68,7 @@ TYPED_TEST(LkfHwInfoTests, gtSetupIsCorrect) {
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

38
opencl/test/unit_test/gen12lp/adlp/linux/dll/device_id_tests_adlp.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,24 +11,24 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenAdlpSupportedDeviceIdThenDeviceDescriptorTableExists) {
std::array<DeviceDescriptor, 18> expectedDescriptors = {{
{0x46A0, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46B0, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46A1, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46A2, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46A3, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46A6, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46A8, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46AA, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x462A, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x4626, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x4628, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46B1, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46B2, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46B3, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46C0, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46C1, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46C2, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46C3, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x46A0, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46B0, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46A1, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46A2, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46A3, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46A6, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46A8, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46AA, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x462A, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x4626, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x4628, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46B1, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46B2, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46B3, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46C0, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46C1, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46C2, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46C3, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

14
opencl/test/unit_test/gen12lp/adlp/linux/hw_info_config_tests_adlp.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -22,7 +22,6 @@ struct HwInfoConfigTestLinuxAdlp : HwInfoConfigTestLinux {
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
drm->storedDeviceID = IGFX_ALDERLAKE_P;
drm->setGtType(GTTYPE_GT2);
}
};
@ -36,15 +35,6 @@ ADLPTEST_F(HwInfoConfigTestLinuxAdlp, WhenConfiguringHwInfoThenInfoIsSetCorrectl
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(GTTYPE_GT2, outHwInfo.platform.eGTType);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT1);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_TRUE(outHwInfo.featureTable.flags.ftrGT2);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT3);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT4);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTA);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTC);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTX);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
@ -85,7 +75,7 @@ TYPED_TEST(AdlpConfigHwInfoTests, givenAdlpConfigWhenSetupHardwareInfoThenGtSyst
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
auto &featureTable = hwInfo.featureTable;
auto &workaroundTable = hwInfo.workaroundTable;
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

16
opencl/test/unit_test/gen12lp/adls/linux/dll/device_id_tests_adls.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,13 +11,13 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenAdlsSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 7> expectedDescriptors = {{
{0x4680, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4682, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4688, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x468A, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4690, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4692, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4693, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4680, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x4682, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x4688, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x468A, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x4690, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x4692, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x4693, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

14
opencl/test/unit_test/gen12lp/adls/linux/hw_info_config_tests_adls.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -21,7 +21,6 @@ struct HwInfoConfigTestLinuxAdls : HwInfoConfigTestLinux {
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
drm->storedDeviceID = IGFX_ALDERLAKE_S;
drm->setGtType(GTTYPE_GT1);
}
};
@ -35,15 +34,6 @@ ADLSTEST_F(HwInfoConfigTestLinuxAdls, WhenConfiguringHwInfoThenConfigIsCorrect)
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.platform.eGTType);
EXPECT_TRUE(outHwInfo.featureTable.flags.ftrGT1);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT2);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT3);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT4);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTA);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTC);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTX);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
@ -78,7 +68,7 @@ TEST(AdlsHwInfoTests, WhenSettingUpHwInfoThenConfigIsCorrect) {
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

10
opencl/test/unit_test/gen12lp/dg1/linux/dll/device_id_tests_dg1.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -10,10 +10,10 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenDg1SupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 4> expectedDescriptors = {{
{0x4905, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x4906, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x4907, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x4908, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo, GTTYPE_GT2},
{0x4905, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo},
{0x4906, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo},
{0x4907, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo},
{0x4908, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

14
opencl/test/unit_test/gen12lp/rkl/linux/dll/device_id_tests_rkl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -10,12 +10,12 @@
using namespace NEO;
TEST_F(DeviceIdTests, GivenRklSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 6> expectedDescriptors = {{{0x4C80, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4C8A, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4C8B, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4C8C, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT0_5},
{0x4C90, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1},
{0x4C9A, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1}}};
std::array<DeviceDescriptor, 6> expectedDescriptors = {{{0x4C80, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo},
{0x4C8A, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo},
{0x4C8B, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo},
{0x4C8C, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo},
{0x4C90, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo},
{0x4C9A, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo}}};
testImpl(expectedDescriptors);
}

14
opencl/test/unit_test/gen12lp/rkl/linux/hw_info_config_tests_rkl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -21,7 +21,6 @@ struct HwInfoConfigTestLinuxRkl : HwInfoConfigTestLinux {
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
drm->storedDeviceID = 0x4C8A;
drm->setGtType(GTTYPE_GT1);
}
};
@ -35,15 +34,6 @@ RKLTEST_F(HwInfoConfigTestLinuxRkl, WhenConfiguringHwInfoThenConfigIsCorrect) {
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.platform.eGTType);
EXPECT_TRUE(outHwInfo.featureTable.flags.ftrGT1);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT2);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT3);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT4);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTA);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTC);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTX);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
@ -78,7 +68,7 @@ TEST(RklHwInfoTests, WhenSettingUpHwInfoThenConfigIsCorrect) {
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &RKL_HW_CONFIG::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &RKL_HW_CONFIG::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

18
opencl/test/unit_test/gen12lp/tgllp/linux/dll/device_id_tests_tgllp.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,14 +11,14 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenTgllpSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 8> expectedDescriptors = {{
{0xFF20, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo, GTTYPE_GT2},
{0x9A49, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo, GTTYPE_GT2},
{0x9A40, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo, GTTYPE_GT2},
{0x9A59, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo, GTTYPE_GT2},
{0x9A60, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo, GTTYPE_GT2},
{0x9A68, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo, GTTYPE_GT2},
{0x9A70, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo, GTTYPE_GT2},
{0x9A78, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo, GTTYPE_GT2},
{0xFF20, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo},
{0x9A49, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo},
{0x9A40, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo},
{0x9A59, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo},
{0x9A60, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo},
{0x9A68, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo},
{0x9A70, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo},
{0x9A78, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

14
opencl/test/unit_test/gen12lp/tgllp/linux/hw_info_config_tests_tgllp.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -24,7 +24,6 @@ struct HwInfoConfigTestLinuxTgllp : HwInfoConfigTestLinux {
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
drm->storedDeviceID = 0xFF20;
drm->setGtType(GTTYPE_GT1);
}
};
@ -49,15 +48,6 @@ TGLLPTEST_F(HwInfoConfigTestLinuxTgllp, configureHwInfo) {
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.platform.eGTType);
EXPECT_TRUE(outHwInfo.featureTable.flags.ftrGT1);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT2);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT3);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGT4);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTA);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTC);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGTX);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
@ -96,7 +86,7 @@ TYPED_TEST(TgllpHwInfoTests, gtSetupIsCorrect) {
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

34
opencl/test/unit_test/gen8/bdw/linux/dll/device_id_tests_bdw.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,24 +11,24 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenBdwSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 16> expectedDescriptors = {{
{0x1602, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x160A, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x1606, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x160E, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x160D, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x1602, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo},
{0x160A, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo},
{0x1606, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo},
{0x160E, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo},
{0x160D, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo},
{0x1612, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x161A, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x1616, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x161E, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x161D, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x1612, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo},
{0x161A, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo},
{0x1616, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo},
{0x161E, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo},
{0x161D, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo},
{0x1622, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x162A, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x1626, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x162B, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x162E, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x162D, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x1622, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
{0x162A, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
{0x1626, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
{0x162B, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
{0x162E, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
{0x162D, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

41
opencl/test/unit_test/gen8/bdw/linux/hw_info_config_tests_bdw.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -14,7 +14,6 @@ struct HwInfoConfigTestLinuxBdw : HwInfoConfigTestLinux {
void SetUp() override {
HwInfoConfigTestLinux::SetUp();
drm->storedDeviceID = 0x1616;
drm->setGtType(GTTYPE_GT2);
}
};
@ -30,18 +29,8 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT2, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x1602;
drm->setGtType(GTTYPE_GT1);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ((unsigned short)drm->storedDeviceID, outHwInfo.platform.usDeviceID);
@ -50,18 +39,8 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.platform.eGTType);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x1626;
drm->setGtType(GTTYPE_GT3);
drm->storedSSVal = 6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
@ -71,16 +50,6 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(2u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT3, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
}
BDWTEST_F(HwInfoConfigTestLinuxBdw, GivenUnknownDevIdWhenConfiguringHwInfoThenErrorIsReturned) {
@ -137,7 +106,7 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, WhenConfiguringHwInfoThenEdramInformationIsC
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram);
drm->storedDeviceID = 0x1622;
drm->setGtType(GTTYPE_GT3);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
@ -162,7 +131,7 @@ TYPED_TEST(BdwHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

18
opencl/test/unit_test/gen9/bxt/linux/dll/device_id_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,14 +11,14 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenBxtSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 8> expectedDescriptors = {{
{0x9906, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo, GTTYPE_GTA},
{0x9907, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo, GTTYPE_GTA},
{0x0A84, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo, GTTYPE_GTA},
{0x5A84, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo, GTTYPE_GTA},
{0x5A85, &BXT_1x2x6::hwInfo, &BXT_1x2x6::setupHardwareInfo, GTTYPE_GTA},
{0x1A85, &BXT_1x2x6::hwInfo, &BXT_1x2x6::setupHardwareInfo, GTTYPE_GTA},
{0x1A84, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo, GTTYPE_GTA},
{0x9908, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo, GTTYPE_GTA},
{0x9906, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
{0x9907, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
{0x0A84, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
{0x5A84, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
{0x5A85, &BXT_1x2x6::hwInfo, &BXT_1x2x6::setupHardwareInfo},
{0x1A85, &BXT_1x2x6::hwInfo, &BXT_1x2x6::setupHardwareInfo},
{0x1A84, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
{0x9908, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

38
opencl/test/unit_test/gen9/bxt/linux/hw_info_config_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -15,7 +15,7 @@ struct HwInfoConfigTestLinuxBxt : HwInfoConfigTestLinux {
void SetUp() override {
HwInfoConfigTestLinux::SetUp();
drm->storedDeviceID = 0x5A84;
drm->setGtType(GTTYPE_GTA);
drm->storedEUVal = 18;
drm->storedHasPooledEU = 1;
drm->storedMinEUinPool = 3;
@ -41,18 +41,7 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, WhenConfiguringHwInfoThenConfigIsCorrect) {
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled);
EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid);
EXPECT_EQ(GTTYPE_GTA, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x5A85;
drm->setGtType(GTTYPE_GTC); //0x5A85 is GTA, but for test make it GTC
drm->storedMinEUinPool = 6;
drm->storedDeviceRevID = 4;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
@ -66,18 +55,7 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, WhenConfiguringHwInfoThenConfigIsCorrect) {
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GTC, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x5A85;
drm->setGtType(GTTYPE_GTX); //0x5A85 is GTA, but for test make it GTX
drm->storedMinEUinPool = 9;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
@ -90,16 +68,6 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, WhenConfiguringHwInfoThenConfigIsCorrect) {
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GTX, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGTX);
auto &outKmdNotifyProperties = outHwInfo.capabilityTable.kmdNotifyProperties;
EXPECT_TRUE(outKmdNotifyProperties.enableKmdNotify);
EXPECT_EQ(50000, outKmdNotifyProperties.delayKmdNotifyMicroseconds);
@ -222,7 +190,7 @@ TYPED_TEST(BxtHwInfoTests, WhenConfiguringHwInfoThenConfigIsCorrect) {
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

86
opencl/test/unit_test/gen9/cfl/linux/dll/device_id_tests_cfl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,54 +11,54 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenCflSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 42> expectedDescriptors = {{
{0x3E90, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x3E93, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x3EA4, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x3E99, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x3EA1, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x3E90, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x3E93, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x3EA4, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x3E99, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x3EA1, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x3E92, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x3E9B, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x3E94, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x3E91, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x3E96, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x3E9A, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x3EA3, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x3EA9, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x3EA0, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x3E98, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x3E92, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E9B, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E94, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E91, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E96, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E9A, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3EA3, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3EA9, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3EA0, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E98, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E95, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x3EA6, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x3EA7, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x3EA8, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x3EA5, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x3EA2, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x3E95, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
{0x3EA6, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
{0x3EA7, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
{0x3EA8, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
{0x3EA5, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
{0x3EA2, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
// CML GT1
{0x9B21, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x9BAA, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x9BAB, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x9BAC, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x9BA0, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x9BA5, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x9BA8, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x9BA4, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x9BA2, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x9B21, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BAA, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BAB, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BAC, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BA0, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BA5, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BA8, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BA4, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BA2, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
// CML GT2
{0x9B41, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9BCA, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9BCB, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9BCC, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9BC0, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9BC5, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9BC8, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9BC4, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9BC2, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9B41, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BCA, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BCB, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BCC, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BC0, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BC5, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BC8, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BC4, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BC2, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
// CML WORKSTATION
{0x9BC6, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9BE6, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9BF6, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9BC6, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BE6, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BF6, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

41
opencl/test/unit_test/gen9/cfl/linux/hw_info_config_tests_cfl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -16,7 +16,6 @@ struct HwInfoConfigTestLinuxCfl : HwInfoConfigTestLinux {
void SetUp() override {
HwInfoConfigTestLinux::SetUp();
drm->storedDeviceID = 0x3E92;
drm->setGtType(GTTYPE_GT2);
}
};
@ -30,23 +29,13 @@ CFLTEST_F(HwInfoConfigTestLinuxCfl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT2, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
//constant sysInfo/ftr flags
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled);
EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid);
drm->storedDeviceID = 0x3E90;
drm->storedSSVal = 3;
drm->setGtType(GTTYPE_GT1);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ((unsigned short)drm->storedDeviceID, outHwInfo.platform.usDeviceID);
@ -56,19 +45,9 @@ CFLTEST_F(HwInfoConfigTestLinuxCfl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.platform.eGTType);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x3EA5;
drm->storedSSVal = 6;
drm->setGtType(GTTYPE_GT3);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ((unsigned short)drm->storedDeviceID, outHwInfo.platform.usDeviceID);
@ -78,16 +57,6 @@ CFLTEST_F(HwInfoConfigTestLinuxCfl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ(2u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT3, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
auto &outKmdNotifyProperties = outHwInfo.capabilityTable.kmdNotifyProperties;
EXPECT_TRUE(outKmdNotifyProperties.enableKmdNotify);
EXPECT_EQ(50000, outKmdNotifyProperties.delayKmdNotifyMicroseconds);
@ -153,7 +122,7 @@ CFLTEST_F(HwInfoConfigTestLinuxCfl, WhenConfiguringHwInfoThenEdramInformationIsC
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram);
drm->storedDeviceID = 0x3EA8;
drm->setGtType(GTTYPE_GT3);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
@ -178,7 +147,7 @@ TYPED_TEST(CflHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

6
opencl/test/unit_test/gen9/glk/linux/dll/device_id_tests_glk.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,8 +11,8 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenGlkSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 2> expectedDescriptors = {{
{0x3184, &GLK_1x3x6::hwInfo, &GLK_1x3x6::setupHardwareInfo, GTTYPE_GTA},
{0x3185, &GLK_1x2x6::hwInfo, &GLK_1x2x6::setupHardwareInfo, GTTYPE_GTA},
{0x3184, &GLK_1x3x6::hwInfo, &GLK_1x3x6::setupHardwareInfo},
{0x3185, &GLK_1x2x6::hwInfo, &GLK_1x2x6::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

40
opencl/test/unit_test/gen9/glk/linux/hw_info_config_tests_glk.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -15,7 +15,7 @@ struct HwInfoConfigTestLinuxGlk : HwInfoConfigTestLinux {
HwInfoConfigTestLinux::SetUp();
drm->storedDeviceID = 0x3185;
drm->setGtType(GTTYPE_GTA);
drm->storedEUVal = 18;
drm->storedHasPooledEU = 1;
drm->storedMinEUinPool = 3;
@ -33,22 +33,12 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GTA, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
//constant sysInfo/ftr flags
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled);
EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid);
drm->storedDeviceID = 0x3184;
drm->setGtType(GTTYPE_GTC); //0x3184 is GTA, but for test make it GTC
drm->storedMinEUinPool = 6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
@ -61,18 +51,8 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GTC, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x3185;
drm->setGtType(GTTYPE_GTX); //0x3185 is GTA, but for test make it GTX
drm->storedMinEUinPool = 9;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
@ -85,16 +65,6 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GTX, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGTX);
auto &outKmdNotifyProperties = outHwInfo.capabilityTable.kmdNotifyProperties;
EXPECT_TRUE(outKmdNotifyProperties.enableKmdNotify);
EXPECT_EQ(50000, outKmdNotifyProperties.delayKmdNotifyMicroseconds);
@ -214,7 +184,7 @@ TYPED_TEST(GlkHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

54
opencl/test/unit_test/gen9/kbl/linux/dll/device_id_tests_kbl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,36 +11,36 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenKblSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 26> expectedDescriptors = {{
{0x5902, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x590B, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x590A, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x5906, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x590E, &KBL_1x3x6::hwInfo, &KBL_1x3x6::setupHardwareInfo, GTTYPE_GT1},
{0x5908, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x5902, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x590B, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x590A, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x5906, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x590E, &KBL_1x3x6::hwInfo, &KBL_1x3x6::setupHardwareInfo},
{0x5908, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x5913, &KBL_1x3x6::hwInfo, &KBL_1x3x6::setupHardwareInfo, GTTYPE_GT1_5},
{0x5915, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo, GTTYPE_GT1_5},
{0x5913, &KBL_1x3x6::hwInfo, &KBL_1x3x6::setupHardwareInfo},
{0x5915, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x5912, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x591B, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x5917, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x591A, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x5916, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x591E, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x591D, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x591C, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x5921, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x5912, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x591B, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x5917, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x591A, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x5916, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x591E, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x591D, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x591C, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x5921, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x5926, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x5927, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x592B, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x592A, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x5923, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x5926, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo},
{0x5927, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo},
{0x592B, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo},
{0x592A, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo},
{0x5923, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo},
{0x5932, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo, GTTYPE_GT4},
{0x593B, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo, GTTYPE_GT4},
{0x593A, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo, GTTYPE_GT4},
{0x593D, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo, GTTYPE_GT4},
{0x5932, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo},
{0x593B, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo},
{0x593A, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo},
{0x593D, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

65
opencl/test/unit_test/gen9/kbl/linux/hw_info_config_tests_kbl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -16,7 +16,6 @@ struct HwInfoConfigTestLinuxKbl : HwInfoConfigTestLinux {
void SetUp() override {
HwInfoConfigTestLinux::SetUp();
drm->storedDeviceID = 0x5912;
drm->setGtType(GTTYPE_GT2);
}
};
@ -30,23 +29,13 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT2, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
//constant sysInfo/ftr flags
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled);
EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid);
drm->storedDeviceID = 0x5906;
drm->storedSSVal = 3;
drm->setGtType(GTTYPE_GT1);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ((unsigned short)drm->storedDeviceID, outHwInfo.platform.usDeviceID);
@ -56,18 +45,8 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.platform.eGTType);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x5915;
drm->setGtType(GTTYPE_GT1_5);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ((unsigned short)drm->storedDeviceID, outHwInfo.platform.usDeviceID);
@ -76,19 +55,9 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1_5, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x5923;
drm->storedSSVal = 6;
drm->setGtType(GTTYPE_GT3);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ((unsigned short)drm->storedDeviceID, outHwInfo.platform.usDeviceID);
@ -98,19 +67,9 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ(2u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT3, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x593B;
drm->storedSSVal = 6;
drm->setGtType(GTTYPE_GT4);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ((unsigned short)drm->storedDeviceID, outHwInfo.platform.usDeviceID);
@ -120,16 +79,6 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ(2u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT4, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
auto &outKmdNotifyProperties = outHwInfo.capabilityTable.kmdNotifyProperties;
EXPECT_TRUE(outKmdNotifyProperties.enableKmdNotify);
EXPECT_EQ(50000, outKmdNotifyProperties.delayKmdNotifyMicroseconds);
@ -208,7 +157,7 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenEdramInformationIsC
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram);
drm->storedDeviceID = 0x5927;
drm->setGtType(GTTYPE_GT3);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
@ -233,7 +182,7 @@ TYPED_TEST(KblHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

54
opencl/test/unit_test/gen9/skl/linux/dll/device_id_tests_skl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,36 +11,36 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenSklSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 26> expectedDescriptors = {{
{0x1902, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x190B, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x190A, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x1906, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x190E, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo, GTTYPE_GT1},
{0x1902, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo},
{0x190B, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo},
{0x190A, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo},
{0x1906, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo},
{0x190E, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo},
{0x1917, &SKL_1x3x6::hwInfo, &SKL_1x3x6::setupHardwareInfo, GTTYPE_GT1_5},
{0x1913, &SKL_1x3x6::hwInfo, &SKL_1x3x6::setupHardwareInfo, GTTYPE_GT1_5},
{0x1915, &SKL_1x3x6::hwInfo, &SKL_1x3x6::setupHardwareInfo, GTTYPE_GT1_5},
{0x1917, &SKL_1x3x6::hwInfo, &SKL_1x3x6::setupHardwareInfo},
{0x1913, &SKL_1x3x6::hwInfo, &SKL_1x3x6::setupHardwareInfo},
{0x1915, &SKL_1x3x6::hwInfo, &SKL_1x3x6::setupHardwareInfo},
{0x1912, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x191B, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x191A, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x1916, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x191E, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x191D, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x1921, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x9905, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo, GTTYPE_GT2},
{0x1912, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x191B, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x191A, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x1916, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x191E, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x191D, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x1921, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x9905, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x192B, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x192D, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x192A, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x1923, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x1926, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x1927, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo, GTTYPE_GT3},
{0x192B, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x192D, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x192A, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x1923, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x1926, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x1927, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x1932, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo, GTTYPE_GT4},
{0x193B, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo, GTTYPE_GT4},
{0x193A, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo, GTTYPE_GT4},
{0x193D, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo, GTTYPE_GT4},
{0x1932, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo},
{0x193B, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo},
{0x193A, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo},
{0x193D, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

67
opencl/test/unit_test/gen9/skl/linux/hw_info_config_tests_skl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -14,7 +14,6 @@ struct HwInfoConfigTestLinuxSkl : HwInfoConfigTestLinux {
void SetUp() override {
HwInfoConfigTestLinux::SetUp();
drm->storedDeviceID = 0x0902;
drm->setGtType(GTTYPE_GT2);
}
};
@ -28,16 +27,6 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT2, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
//constant sysInfo/ftr flags
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VDBoxInfo.Instances.Bits.VDBox0Enabled);
@ -45,7 +34,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_TRUE(outHwInfo.gtSystemInfo.VDBoxInfo.IsValid);
drm->storedDeviceID = 0x1902;
drm->setGtType(GTTYPE_GT1);
drm->storedSSVal = 3;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
@ -56,18 +45,8 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1, outHwInfo.platform.eGTType);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x1917;
drm->setGtType(GTTYPE_GT1_5);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ((unsigned short)drm->storedDeviceID, outHwInfo.platform.usDeviceID);
@ -76,18 +55,8 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT1_5, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x0903;
drm->setGtType(GTTYPE_GT3);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ((unsigned short)drm->storedDeviceID, outHwInfo.platform.usDeviceID);
@ -96,18 +65,8 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT3, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
drm->storedDeviceID = 0x0904;
drm->setGtType(GTTYPE_GT4);
drm->storedSSVal = 6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
@ -118,16 +77,6 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrec
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(GTTYPE_GT4, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
auto &outKmdNotifyProperties = outHwInfo.capabilityTable.kmdNotifyProperties;
EXPECT_TRUE(outKmdNotifyProperties.enableKmdNotify);
EXPECT_EQ(50000, outKmdNotifyProperties.delayKmdNotifyMicroseconds);
@ -213,7 +162,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenEdramInformationIsC
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram);
drm->storedDeviceID = 0x1926;
drm->setGtType(GTTYPE_GT3);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
@ -232,7 +181,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenEdramInformationIsC
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);
drm->storedDeviceID = 0x193B;
drm->setGtType(GTTYPE_GT4);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
@ -257,7 +206,7 @@ TYPED_TEST(SklHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo, GTTYPE_GT1};
DeviceDescriptor device = {0, &hwInfo, &TypeParam::setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);

27
opencl/test/unit_test/gen9/skl/test_hw_info_config_skl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -95,36 +95,13 @@ SKLTEST_F(SklHwInfo, givenBoolWhenCallSklHardwareInfoSetupThenFeatureTableAndWor
pPlatform.usRevId = 1;
workaroundTable = {};
featureTable = {};
featureTable.flags.ftrGT1 = true;
featureTable.flags.ftrGT3 = true;
hardwareInfoSetup[productFamily](&hwInfo, true, config);
EXPECT_EQ(true, workaroundTable.flags.waCompressedResourceRequiresConstVA21);
EXPECT_EQ(true, workaroundTable.flags.waDisablePerCtxtPreemptionGranularityControl);
EXPECT_EQ(true, workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption);
EXPECT_EQ(true, workaroundTable.flags.waCSRUncachable);
EXPECT_EQ(true, featureTable.flags.ftrSingleVeboxSlice);
EXPECT_EQ(true, featureTable.flags.ftrVcs2);
workaroundTable = {};
featureTable = {};
featureTable.flags.ftrGT2 = true;
featureTable.flags.ftrGT4 = true;
hardwareInfoSetup[productFamily](&hwInfo, true, config);
EXPECT_EQ(true, featureTable.flags.ftrSingleVeboxSlice);
EXPECT_EQ(true, featureTable.flags.ftrVcs2);
workaroundTable = {};
featureTable = {};
featureTable.flags.ftrGT1 = true;
featureTable.flags.ftrGT2 = true;
featureTable.flags.ftrGT3 = true;
featureTable.flags.ftrGT4 = true;
hardwareInfoSetup[productFamily](&hwInfo, true, config);
EXPECT_EQ(true, featureTable.flags.ftrSingleVeboxSlice);
EXPECT_EQ(true, featureTable.flags.ftrVcs2);
}
}
}

2
opencl/test/unit_test/linux/main_linux_dll.cpp
View File

@ -70,7 +70,7 @@ class DrmTestsFixture {
typedef Test<DrmTestsFixture> DrmTests;
void initializeTestedDevice() {
for (uint32_t i = 0; deviceDescriptorTable[i].eGtType != GTTYPE::GTTYPE_UNDEFINED; i++) {
for (uint32_t i = 0; deviceDescriptorTable[i].deviceId != 0; i++) {
if (defaultHwInfo->platform.eProductFamily == deviceDescriptorTable[i].pHwInfo->platform.eProductFamily) {
deviceId = deviceDescriptorTable[i].deviceId;
break;

5
opencl/test/unit_test/os_interface/linux/device_factory_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -26,9 +26,6 @@ TEST_F(DeviceFactoryLinuxTest, WhenPreparingDeviceEnvironmentsThenInitializedCor
EXPECT_EQ((int)hwInfo->gtSystemInfo.EUCount, 16);
EXPECT_EQ((int)hwInfo->gtSystemInfo.SubSliceCount, 8);
EXPECT_EQ((int)hwInfo->gtSystemInfo.DualSubSliceCount, 8);
//temporararily return GT2.
EXPECT_EQ(1u, hwInfo->featureTable.flags.ftrGT2);
}
TEST_F(DeviceFactoryLinuxTest, givenSomeDisabledSSAndEUWhenPrepareDeviceEnvironmentsThenCorrectObtainEUCntSSCnt) {

3
opencl/test/unit_test/os_interface/linux/device_factory_tests.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -27,7 +27,6 @@ struct DeviceFactoryLinuxTest : public ::testing::Test {
void SetUp() override {
pDrm = new DrmMock(*executionEnvironment.rootDeviceEnvironments[0]);
pDrmToReturnFromCreateFunc = reinterpret_cast<Drm **>(&pDrm);
pDrm->setGtType(GTTYPE_GT2);
}
void TearDown() override {

8
opencl/test/unit_test/os_interface/linux/drm_system_info_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -67,7 +67,7 @@ TEST(DrmSystemInfoTest, givenSetupHardwareInfoWhenQuerySystemInfoFalseThenSystem
HardwareInfo hwInfo = *defaultHwInfo;
auto setupHardwareInfo = [](HardwareInfo *, bool) {};
DeviceDescriptor device = {0, &hwInfo, setupHardwareInfo, GTTYPE_UNDEFINED};
DeviceDescriptor device = {0, &hwInfo, setupHardwareInfo};
::testing::internal::CaptureStdout();
@ -134,7 +134,7 @@ TEST(DrmSystemInfoTest, givenSetupHardwareInfoWhenQuerySystemInfoFailsThenSystem
HardwareInfo hwInfo = *defaultHwInfo;
auto setupHardwareInfo = [](HardwareInfo *, bool) {};
DeviceDescriptor device = {0, &hwInfo, setupHardwareInfo, GTTYPE_UNDEFINED};
DeviceDescriptor device = {0, &hwInfo, setupHardwareInfo};
::testing::internal::CaptureStdout();
@ -157,7 +157,7 @@ TEST(DrmSystemInfoTest, givenSetupHardwareInfoWhenQuerySystemInfoSucceedsThenSys
auto setupHardwareInfo = [](HardwareInfo *, bool) {};
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
DeviceDescriptor device = {0, &hwInfo, setupHardwareInfo, GTTYPE_UNDEFINED};
DeviceDescriptor device = {0, &hwInfo, setupHardwareInfo};
int ret = drm.setupHardwareInfo(&device, false);
EXPECT_EQ(ret, 0);

2
opencl/test/unit_test/os_interface/linux/drm_tests.cpp
View File

@ -732,7 +732,7 @@ TEST(DrmQueryTest, GivenDrmWhenSetupHardwareInfoCalledThenCorrectMaxValuesInGtSy
hwInfo->gtSystemInfo.SliceCount = 2;
auto setupHardwareInfo = [](HardwareInfo *, bool) {};
DeviceDescriptor device = {0, hwInfo, setupHardwareInfo, GTTYPE_UNDEFINED};
DeviceDescriptor device = {0, hwInfo, setupHardwareInfo};
drm.setupHardwareInfo(&device, false);

63
opencl/test/unit_test/os_interface/linux/hw_info_config_linux_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -98,7 +98,7 @@ struct HwInfoConfigTestLinuxDummy : HwInfoConfigTestLinux {
HwInfoConfigTestLinux::SetUp();
drm->storedDeviceID = 1;
drm->setGtType(GTTYPE_GT0);
testPlatform->eRenderCoreFamily = defaultHwInfo->platform.eRenderCoreFamily;
}
@ -113,10 +113,6 @@ TEST_F(HwInfoConfigTestLinuxDummy, GivenDummyConfigWhenConfiguringHwInfoThenSucc
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
}
GTTYPE GtTypes[] = {
GTTYPE_GT1, GTTYPE_GT2, GTTYPE_GT1_5, GTTYPE_GT2_5, GTTYPE_GT3, GTTYPE_GT4, GTTYPE_GTA, GTTYPE_GTC, GTTYPE_GTX};
using HwInfoConfigCommonLinuxTest = ::testing::Test;
HWTEST2_F(HwInfoConfigCommonLinuxTest, givenDebugFlagSetWhenEnablingBlitterOperationsSupportThenIgnore, IsAtMostGen11) {
@ -130,51 +126,6 @@ HWTEST2_F(HwInfoConfigCommonLinuxTest, givenDebugFlagSetWhenEnablingBlitterOpera
EXPECT_FALSE(hardwareInfo.capabilityTable.blitterOperationsSupported);
}
TEST_F(HwInfoConfigTestLinuxDummy, GivenDummyConfigGtTypesThenFtrIsSetCorrectly) {
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ(GTTYPE_GT0, outHwInfo.platform.eGTType);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT1_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT2_5);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT3);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGT4);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTA);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTC);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGTX);
size_t arrSize = sizeof(GtTypes) / sizeof(GTTYPE);
uint32_t FtrSum = 0;
for (uint32_t i = 0; i < arrSize; i++) {
drm->setGtType(GtTypes[i]);
ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_EQ(GtTypes[i], outHwInfo.platform.eGTType);
bool FtrPresent = (outHwInfo.featureTable.flags.ftrGT1 ||
outHwInfo.featureTable.flags.ftrGT1_5 ||
outHwInfo.featureTable.flags.ftrGT2 ||
outHwInfo.featureTable.flags.ftrGT2_5 ||
outHwInfo.featureTable.flags.ftrGT3 ||
outHwInfo.featureTable.flags.ftrGT4 ||
outHwInfo.featureTable.flags.ftrGTA ||
outHwInfo.featureTable.flags.ftrGTC ||
outHwInfo.featureTable.flags.ftrGTX);
EXPECT_TRUE(FtrPresent);
FtrSum += (outHwInfo.featureTable.flags.ftrGT1 +
outHwInfo.featureTable.flags.ftrGT1_5 +
outHwInfo.featureTable.flags.ftrGT2 +
outHwInfo.featureTable.flags.ftrGT2_5 +
outHwInfo.featureTable.flags.ftrGT3 +
outHwInfo.featureTable.flags.ftrGT4 +
outHwInfo.featureTable.flags.ftrGTA +
outHwInfo.featureTable.flags.ftrGTC +
outHwInfo.featureTable.flags.ftrGTX);
}
EXPECT_EQ(arrSize, FtrSum);
}
TEST_F(HwInfoConfigTestLinuxDummy, GivenDummyConfigThenEdramIsDetected) {
drm->storedDeviceID = 30;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
@ -196,13 +147,6 @@ TEST_F(HwInfoConfigTestLinuxDummy, givenDisabledPlatformCoherencyWhenConfiguring
EXPECT_FALSE(outHwInfo.capabilityTable.ftrSupportsCoherency);
}
TEST_F(HwInfoConfigTestLinuxDummy, GivenUnknownGtTypeWhenConfiguringHwInfoThenFails) {
drm->setGtType(GTTYPE_UNDEFINED);
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(-1, ret);
}
TEST_F(HwInfoConfigTestLinuxDummy, GivenUnknownDevIdWhenConfiguringHwInfoThenFails) {
drm->storedDeviceID = 0;
@ -292,7 +236,6 @@ TEST_F(HwInfoConfigTestLinuxDummy, GivenFailingCustomConfigWhenConfiguringHwInfo
TEST_F(HwInfoConfigTestLinuxDummy, GivenUnknownDeviceIdWhenConfiguringHwInfoThenFails) {
drm->storedDeviceID = 0;
drm->setGtType(GTTYPE_GT1);
auto hwConfig = DummyHwConfig{};
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
@ -509,7 +452,6 @@ HWTEST2_F(HwConfigLinux, GivenDifferentValuesFromTopologyQueryWhenConfiguringHwI
*executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = *NEO::defaultHwInfo.get();
auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
drm->setGtType(GTTYPE_GT1);
auto osInterface = std::make_unique<OSInterface>();
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
@ -562,7 +504,6 @@ HWTEST2_F(HwConfigLinux, givenSliceCountWhenConfigureHwInfoDrmThenProperInitiali
*executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = *NEO::defaultHwInfo.get();
auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
drm->setGtType(GTTYPE_GT1);
auto osInterface = std::make_unique<OSInterface>();
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));

4
opencl/test/unit_test/xe_hp_core/xehp/linux/dll/device_id_tests_xehp.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -10,7 +10,7 @@
using namespace NEO;
TEST_F(DeviceIdTests, GivenXeHpSdvSupportedDeviceIdThenConfigIsCorrect) {
std::array<DeviceDescriptor, 1> expectedDescriptors = {{{0x0201, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo, GTTYPE_GT4}}};
std::array<DeviceDescriptor, 1> expectedDescriptors = {{{0x0201, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo}}};
testImpl(expectedDescriptors);
}

3
opencl/test/unit_test/xe_hp_core/xehp/linux/hw_info_config_tests_xehp.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -22,7 +22,6 @@ struct HwInfoConfigTestLinuxXeHp : HwInfoConfigTestLinux {
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
drm->storedDeviceID = 0x0201;
drm->setGtType(GTTYPE_GT4);
}
};

6
opencl/test/unit_test/xe_hpc_core/pvc/linux/dll/device_id_tests_pvc.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,8 +11,8 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenPvcSupportedDeviceIdThenConfigIsCorrect) {
std::array<DeviceDescriptor, 2> expectedDescriptors = {{
{0x0BD0, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x0BD5, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x0BD0, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo},
{0x0BD5, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

3
opencl/test/unit_test/xe_hpc_core/pvc/linux/hw_info_config_tests_pvc.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -22,7 +22,6 @@ struct HwInfoConfigTestLinuxPvc : HwInfoConfigTestLinux {
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
drm->storedDeviceID = 0x0BD0;
drm->setGtType(GTTYPE_GT4);
}
};

38
opencl/test/unit_test/xe_hpg_core/dg2/linux/dll/device_id_tests_dg2.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,24 +11,24 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenDg2SupportedDeviceIdThenDeviceDescriptorTableExists) {
std::array<DeviceDescriptor, 18> expectedDescriptors = {{
{0x4F80, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x4F81, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x4F82, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x4F83, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x4F84, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x4F87, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x4F88, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x5690, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x5691, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x5692, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x5693, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x5694, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x5695, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x56A0, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x56A1, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x56A2, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x56A5, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x56A6, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo, GTTYPE_GT4},
{0x4F80, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F81, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F82, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F83, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F84, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F87, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F88, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5690, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5691, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5692, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5693, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5694, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5695, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56A0, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56A1, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56A2, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56A5, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56A6, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

1
opencl/test/unit_test/xe_hpg_core/dg2/linux/hw_info_config_tests_dg2.cpp
View File

@ -22,7 +22,6 @@ struct HwInfoConfigTestLinuxDg2 : HwInfoConfigTestLinux {
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
drm->storedDeviceID = 0x1234;
drm->setGtType(GTTYPE_GT4);
}
};

4
shared/offline_compiler/source/ocloc_arg_helper.cpp
View File

@ -50,8 +50,8 @@ OclocArgHelper::OclocArgHelper(const uint32_t numSources, const uint8_t **dataSo
: numOutputs(numOutputs), nameOutputs(nameOutputs),
dataOutputs(dataOutputs), lenOutputs(lenOutputs), hasOutput(numOutputs != nullptr),
messagePrinter(hasOutput), deviceProductTable({
#define NAMEDDEVICE(devId, product, ignored_gtType, ignored_devName) {devId, NEO::hardwarePrefix[NEO::product::hwInfo.platform.eProductFamily]},
#define DEVICE(devId, product, ignored_gtType) {devId, NEO::hardwarePrefix[NEO::product::hwInfo.platform.eProductFamily]},
#define NAMEDDEVICE(devId, product, ignored_devName) {devId, NEO::hardwarePrefix[NEO::product::hwInfo.platform.eProductFamily]},
#define DEVICE(devId, product) {devId, NEO::hardwarePrefix[NEO::product::hwInfo.platform.eProductFamily]},
#include "devices.inl"
#undef DEVICE
#undef NAMEDDEVICE

78
shared/source/dll/devices/devices_additional.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -7,53 +7,53 @@
#if SUPPORT_XE_HPC_CORE
#ifdef SUPPORT_PVC
DEVICE(0x0BD0, PVC_CONFIG, GTTYPE_GT4)
DEVICE(0x0BD5, PVC_CONFIG, GTTYPE_GT4)
DEVICE(0x0BD0, PVC_CONFIG)
DEVICE(0x0BD5, PVC_CONFIG)
#endif
#endif
#ifdef SUPPORT_XE_HPG_CORE
#ifdef SUPPORT_DG2
DEVICE(0x4F80, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x4F81, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x4F82, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x4F83, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x4F84, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x4F87, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x4F88, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x5690, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x5691, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x5692, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x5693, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x5694, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x5695, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x56A0, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x56A1, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x56A2, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x56A5, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x56A6, DG2_CONFIG, GTTYPE_GT4)
DEVICE(0x4F80, DG2_CONFIG)
DEVICE(0x4F81, DG2_CONFIG)
DEVICE(0x4F82, DG2_CONFIG)
DEVICE(0x4F83, DG2_CONFIG)
DEVICE(0x4F84, DG2_CONFIG)
DEVICE(0x4F87, DG2_CONFIG)
DEVICE(0x4F88, DG2_CONFIG)
DEVICE(0x5690, DG2_CONFIG)
DEVICE(0x5691, DG2_CONFIG)
DEVICE(0x5692, DG2_CONFIG)
DEVICE(0x5693, DG2_CONFIG)
DEVICE(0x5694, DG2_CONFIG)
DEVICE(0x5695, DG2_CONFIG)
DEVICE(0x56A0, DG2_CONFIG)
DEVICE(0x56A1, DG2_CONFIG)
DEVICE(0x56A2, DG2_CONFIG)
DEVICE(0x56A5, DG2_CONFIG)
DEVICE(0x56A6, DG2_CONFIG)
#endif
#endif
#ifdef SUPPORT_GEN12LP
#ifdef SUPPORT_ADLP
DEVICE(0x46A0, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46B0, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46A1, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46A2, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46A3, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46A6, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46A8, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46AA, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x462A, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x4626, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x4628, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46B1, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46B2, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46B3, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46C0, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46C1, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46C2, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46C3, ADLP_CONFIG, GTTYPE_GT2)
DEVICE(0x46A0, ADLP_CONFIG)
DEVICE(0x46B0, ADLP_CONFIG)
DEVICE(0x46A1, ADLP_CONFIG)
DEVICE(0x46A2, ADLP_CONFIG)
DEVICE(0x46A3, ADLP_CONFIG)
DEVICE(0x46A6, ADLP_CONFIG)
DEVICE(0x46A8, ADLP_CONFIG)
DEVICE(0x46AA, ADLP_CONFIG)
DEVICE(0x462A, ADLP_CONFIG)
DEVICE(0x4626, ADLP_CONFIG)
DEVICE(0x4628, ADLP_CONFIG)
DEVICE(0x46B1, ADLP_CONFIG)
DEVICE(0x46B2, ADLP_CONFIG)
DEVICE(0x46B3, ADLP_CONFIG)
DEVICE(0x46C0, ADLP_CONFIG)
DEVICE(0x46C1, ADLP_CONFIG)
DEVICE(0x46C2, ADLP_CONFIG)
DEVICE(0x46C3, ADLP_CONFIG)
#endif
#endif

362
shared/source/dll/devices/devices_base.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -8,237 +8,219 @@
// clang-format off
#ifdef SUPPORT_XE_HP_CORE
#ifdef SUPPORT_XE_HP_SDV
DEVICE(0x0201, XE_HP_SDV_CONFIG, GTTYPE_GT4)
DEVICE(0x0201, XE_HP_SDV_CONFIG)
#endif
#endif
#ifdef SUPPORT_GEN12LP
#ifdef SUPPORT_TGLLP
DEVICE( 0xFF20, TGLLP_1x6x16, GTTYPE_GT2 )
NAMEDDEVICE( 0x9A49, TGLLP_1x6x16, GTTYPE_GT2, "Intel(R) Iris(R) Xe Graphics" )
NAMEDDEVICE( 0x9A40, TGLLP_1x6x16, GTTYPE_GT2, "Intel(R) Iris(R) Xe Graphics" )
DEVICE( 0x9A59, TGLLP_1x6x16, GTTYPE_GT2 )
NAMEDDEVICE( 0x9A60, TGLLP_1x2x16, GTTYPE_GT2, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x9A68, TGLLP_1x2x16, GTTYPE_GT2, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x9A70, TGLLP_1x2x16, GTTYPE_GT2, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x9A78, TGLLP_1x2x16, GTTYPE_GT2, "Intel(R) UHD Graphics" )
DEVICE( 0xFF20, TGLLP_1x6x16 )
NAMEDDEVICE( 0x9A49, TGLLP_1x6x16, "Intel(R) Iris(R) Xe Graphics" )
NAMEDDEVICE( 0x9A40, TGLLP_1x6x16, "Intel(R) Iris(R) Xe Graphics" )
DEVICE( 0x9A59, TGLLP_1x6x16 )
NAMEDDEVICE( 0x9A60, TGLLP_1x2x16, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x9A68, TGLLP_1x2x16, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x9A70, TGLLP_1x2x16, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x9A78, TGLLP_1x2x16, "Intel(R) UHD Graphics" )
#endif
#ifdef SUPPORT_DG1
NAMEDDEVICE( 0x4905, DG1_CONFIG, GTTYPE_GT2, "Intel(R) Iris(R) Xe MAX Graphics" )
DEVICE( 0x4906, DG1_CONFIG, GTTYPE_GT2 )
NAMEDDEVICE( 0x4907, DG1_CONFIG, GTTYPE_GT2, "Intel(R) Server GPU SG-18M" )
NAMEDDEVICE( 0x4908, DG1_CONFIG, GTTYPE_GT2, "Intel(R) Iris(R) Xe Graphics" )
NAMEDDEVICE( 0x4905, DG1_CONFIG, "Intel(R) Iris(R) Xe MAX Graphics" )
DEVICE( 0x4906, DG1_CONFIG )
NAMEDDEVICE( 0x4907, DG1_CONFIG, "Intel(R) Server GPU SG-18M" )
NAMEDDEVICE( 0x4908, DG1_CONFIG, "Intel(R) Iris(R) Xe Graphics" )
#endif
#ifdef SUPPORT_RKL
DEVICE( 0x4C80, RKL_HW_CONFIG, GTTYPE_GT1 )
NAMEDDEVICE( 0x4C8A, RKL_HW_CONFIG, GTTYPE_GT1, "Intel(R) UHD Graphics 750" )
NAMEDDEVICE( 0x4C8B, RKL_HW_CONFIG, GTTYPE_GT1, "Intel(R) UHD Graphics 730" )
DEVICE( 0x4C8C, RKL_HW_CONFIG, GTTYPE_GT0_5 )
NAMEDDEVICE( 0x4C90, RKL_HW_CONFIG, GTTYPE_GT1, "Intel(R) UHD Graphics P750" )
DEVICE( 0x4C9A, RKL_HW_CONFIG, GTTYPE_GT1 )
DEVICE( 0x4C80, RKL_HW_CONFIG )
NAMEDDEVICE( 0x4C8A, RKL_HW_CONFIG, "Intel(R) UHD Graphics 750" )
NAMEDDEVICE( 0x4C8B, RKL_HW_CONFIG, "Intel(R) UHD Graphics 730" )
DEVICE( 0x4C8C, RKL_HW_CONFIG )
NAMEDDEVICE( 0x4C90, RKL_HW_CONFIG, "Intel(R) UHD Graphics P750" )
DEVICE( 0x4C9A, RKL_HW_CONFIG )
#endif
#ifdef SUPPORT_ADLS
NAMEDDEVICE( 0x4680, ADLS_HW_CONFIG, GTTYPE_GT1, "Intel(R) UHD Graphics 770" )
DEVICE( 0x4682, ADLS_HW_CONFIG, GTTYPE_GT1 )
DEVICE( 0x4688, ADLS_HW_CONFIG, GTTYPE_GT1 )
DEVICE( 0x468A, ADLS_HW_CONFIG, GTTYPE_GT1 )
DEVICE( 0x4690, ADLS_HW_CONFIG, GTTYPE_GT1 )
DEVICE( 0x4692, ADLS_HW_CONFIG, GTTYPE_GT1 )
DEVICE( 0x4693, ADLS_HW_CONFIG, GTTYPE_GT1 )
NAMEDDEVICE( 0x4680, ADLS_HW_CONFIG, "Intel(R) UHD Graphics 770" )
DEVICE( 0x4682, ADLS_HW_CONFIG )
DEVICE( 0x4688, ADLS_HW_CONFIG )
DEVICE( 0x468A, ADLS_HW_CONFIG )
DEVICE( 0x4690, ADLS_HW_CONFIG )
DEVICE( 0x4692, ADLS_HW_CONFIG )
DEVICE( 0x4693, ADLS_HW_CONFIG )
#endif
#endif
#ifdef SUPPORT_GEN11
#ifdef SUPPORT_ICLLP
// GT1
DEVICE( 0xFF05, ICLLP_1x4x8, GTTYPE_GT1 )
NAMEDDEVICE( 0x8A56, ICLLP_1x4x8, GTTYPE_GT1, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x8A58, ICLLP_1x4x8, GTTYPE_GT1, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x8A5C, ICLLP_1x6x8, GTTYPE_GT1, "Intel(R) Iris(R) Plus Graphics" )
NAMEDDEVICE( 0x8A5A, ICLLP_1x6x8, GTTYPE_GT1, "Intel(R) Iris(R) Plus Graphics" )
// GT2
DEVICE( 0x8A50, ICLLP_1x8x8, GTTYPE_GT2 )
NAMEDDEVICE( 0x8A52, ICLLP_1x8x8, GTTYPE_GT2, "Intel(R) Iris(R) Plus Graphics" )
NAMEDDEVICE( 0x8A51, ICLLP_1x8x8, GTTYPE_GT2, "Intel(R) Iris(R) Plus Graphics" )
#ifdef SUPPORT_ICLLP
DEVICE( 0xFF05, ICLLP_1x4x8 )
NAMEDDEVICE( 0x8A56, ICLLP_1x4x8, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x8A58, ICLLP_1x4x8, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x8A5C, ICLLP_1x6x8, "Intel(R) Iris(R) Plus Graphics" )
NAMEDDEVICE( 0x8A5A, ICLLP_1x6x8, "Intel(R) Iris(R) Plus Graphics" )
DEVICE( 0x8A50, ICLLP_1x8x8 )
NAMEDDEVICE( 0x8A52, ICLLP_1x8x8, "Intel(R) Iris(R) Plus Graphics" )
NAMEDDEVICE( 0x8A51, ICLLP_1x8x8, "Intel(R) Iris(R) Plus Graphics" )
#endif
#ifdef SUPPORT_LKF
NAMEDDEVICE( 0x9840, LKF_1x8x8, GTTYPE_GT1, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x9840, LKF_1x8x8, "Intel(R) UHD Graphics" )
#endif
#ifdef SUPPORT_EHL
DEVICE( 0x4500, EHL_HW_CONFIG, GTTYPE_GT1 )
DEVICE( 0x4541, EHL_HW_CONFIG, GTTYPE_GT1 )
DEVICE( 0x4551, EHL_HW_CONFIG, GTTYPE_GT1 )
NAMEDDEVICE( 0x4571, EHL_HW_CONFIG, GTTYPE_GT1, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x4555, EHL_HW_CONFIG, GTTYPE_GT1, "Intel(R) UHD Graphics" )
DEVICE( 0x4E51, EHL_HW_CONFIG, GTTYPE_GT1 )
NAMEDDEVICE( 0x4E61, EHL_HW_CONFIG, GTTYPE_GT1, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x4E71, EHL_HW_CONFIG, GTTYPE_GT1, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x4E55, EHL_HW_CONFIG, GTTYPE_GT1, "Intel(R) UHD Graphics" )
DEVICE( 0x4500, EHL_HW_CONFIG )
DEVICE( 0x4541, EHL_HW_CONFIG )
DEVICE( 0x4551, EHL_HW_CONFIG )
NAMEDDEVICE( 0x4571, EHL_HW_CONFIG, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x4555, EHL_HW_CONFIG, "Intel(R) UHD Graphics" )
DEVICE( 0x4E51, EHL_HW_CONFIG )
NAMEDDEVICE( 0x4E61, EHL_HW_CONFIG, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x4E71, EHL_HW_CONFIG, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x4E55, EHL_HW_CONFIG, "Intel(R) UHD Graphics" )
#endif
#endif
#ifdef SUPPORT_GEN9
#ifdef SUPPORT_SKL
// GT1
NAMEDDEVICE( 0x1902, SKL_1x2x6, GTTYPE_GT1, "Intel(R) HD Graphics 510" )
NAMEDDEVICE( 0x190B, SKL_1x2x6, GTTYPE_GT1, "Intel(R) HD Graphics 510" )
DEVICE( 0x190A, SKL_1x2x6, GTTYPE_GT1 )
NAMEDDEVICE( 0x1906, SKL_1x2x6, GTTYPE_GT1, "Intel(R) HD Graphics 510" )
DEVICE( 0x190E, SKL_1x2x6, GTTYPE_GT1 )
// GT1_5
DEVICE( 0x1917, SKL_1x3x6, GTTYPE_GT1_5 )
DEVICE( 0x1913, SKL_1x3x6, GTTYPE_GT1_5 )
DEVICE( 0X1915, SKL_1x3x6, GTTYPE_GT1_5 )
// GT2
NAMEDDEVICE( 0x1912, SKL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 530" )
NAMEDDEVICE( 0x191B, SKL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 530" )
DEVICE( 0x191A, SKL_1x3x8, GTTYPE_GT2 )
NAMEDDEVICE( 0x1916, SKL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 520" )
NAMEDDEVICE( 0x191E, SKL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 515" )
NAMEDDEVICE( 0x191D, SKL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics P530" )
NAMEDDEVICE( 0x1921, SKL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 520" )
DEVICE( 0x9905, SKL_1x3x8, GTTYPE_GT2 )
// GT3
NAMEDDEVICE( 0x192B, SKL_2x3x8, GTTYPE_GT3, "Intel(R) Iris(R) Graphics 555" )
NAMEDDEVICE( 0x192D, SKL_2x3x8, GTTYPE_GT3, "Intel(R) Iris(R) Graphics P555" )
DEVICE( 0x192A, SKL_2x3x8, GTTYPE_GT3 )
NAMEDDEVICE( 0x1923, SKL_2x3x8, GTTYPE_GT3, "Intel(R) HD Graphics 535" )
NAMEDDEVICE( 0x1926, SKL_2x3x8, GTTYPE_GT3, "Intel(R) Iris(R) Graphics 540" )
NAMEDDEVICE( 0x1927, SKL_2x3x8, GTTYPE_GT3, "Intel(R) Iris(R) Graphics 550" )
// GT4
DEVICE( 0x1932, SKL_3x3x8, GTTYPE_GT4 )
NAMEDDEVICE( 0x193B, SKL_3x3x8, GTTYPE_GT4, "Intel(R) Iris(R) Pro Graphics 580" )
NAMEDDEVICE( 0x193A, SKL_3x3x8, GTTYPE_GT4, "Intel(R) Iris(R) Pro Graphics P580" )
NAMEDDEVICE( 0x193D, SKL_3x3x8, GTTYPE_GT4, "Intel(R) Iris(R) Pro Graphics P580" )
NAMEDDEVICE( 0x1902, SKL_1x2x6, "Intel(R) HD Graphics 510" )
NAMEDDEVICE( 0x190B, SKL_1x2x6, "Intel(R) HD Graphics 510" )
DEVICE( 0x190A, SKL_1x2x6 )
NAMEDDEVICE( 0x1906, SKL_1x2x6, "Intel(R) HD Graphics 510" )
DEVICE( 0x190E, SKL_1x2x6 )
DEVICE( 0x1917, SKL_1x3x6 )
DEVICE( 0x1913, SKL_1x3x6 )
DEVICE( 0X1915, SKL_1x3x6 )
NAMEDDEVICE( 0x1912, SKL_1x3x8, "Intel(R) HD Graphics 530" )
NAMEDDEVICE( 0x191B, SKL_1x3x8, "Intel(R) HD Graphics 530" )
DEVICE( 0x191A, SKL_1x3x8 )
NAMEDDEVICE( 0x1916, SKL_1x3x8, "Intel(R) HD Graphics 520" )
NAMEDDEVICE( 0x191E, SKL_1x3x8, "Intel(R) HD Graphics 515" )
NAMEDDEVICE( 0x191D, SKL_1x3x8, "Intel(R) HD Graphics P530" )
NAMEDDEVICE( 0x1921, SKL_1x3x8, "Intel(R) HD Graphics 520" )
DEVICE( 0x9905, SKL_1x3x8 )
NAMEDDEVICE( 0x192B, SKL_2x3x8, "Intel(R) Iris(R) Graphics 555" )
NAMEDDEVICE( 0x192D, SKL_2x3x8, "Intel(R) Iris(R) Graphics P555" )
DEVICE( 0x192A, SKL_2x3x8 )
NAMEDDEVICE( 0x1923, SKL_2x3x8, "Intel(R) HD Graphics 535" )
NAMEDDEVICE( 0x1926, SKL_2x3x8, "Intel(R) Iris(R) Graphics 540" )
NAMEDDEVICE( 0x1927, SKL_2x3x8, "Intel(R) Iris(R) Graphics 550" )
DEVICE( 0x1932, SKL_3x3x8 )
NAMEDDEVICE( 0x193B, SKL_3x3x8, "Intel(R) Iris(R) Pro Graphics 580" )
NAMEDDEVICE( 0x193A, SKL_3x3x8, "Intel(R) Iris(R) Pro Graphics P580" )
NAMEDDEVICE( 0x193D, SKL_3x3x8, "Intel(R) Iris(R) Pro Graphics P580" )
#endif
#ifdef SUPPORT_KBL
// GT1
NAMEDDEVICE( 0x5902, KBL_1x2x6, GTTYPE_GT1, "Intel(R) HD Graphics 610" )
NAMEDDEVICE( 0x590B, KBL_1x2x6, GTTYPE_GT1, "Intel(R) HD Graphics 610" )
DEVICE( 0x590A, KBL_1x2x6, GTTYPE_GT1 )
NAMEDDEVICE( 0x5906, KBL_1x2x6, GTTYPE_GT1, "Intel(R) HD Graphics 610" )
DEVICE( 0x590E, KBL_1x3x6, GTTYPE_GT1 )
DEVICE( 0x5908, KBL_1x2x6, GTTYPE_GT1 )
// GT1_5
DEVICE( 0x5913, KBL_1x3x6, GTTYPE_GT1_5 )
DEVICE( 0x5915, KBL_1x2x6, GTTYPE_GT1_5 )
// GT2
NAMEDDEVICE( 0x5912, KBL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 630" )
NAMEDDEVICE( 0x591B, KBL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 630" )
NAMEDDEVICE( 0x5917, KBL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics 620" )
DEVICE( 0x591A, KBL_1x3x8, GTTYPE_GT2 )
NAMEDDEVICE( 0x5916, KBL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 620" )
NAMEDDEVICE( 0x591E, KBL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 615" )
NAMEDDEVICE( 0x591D, KBL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics P630" )
NAMEDDEVICE( 0x591C, KBL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics 615" )
NAMEDDEVICE( 0x5921, KBL_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 620" )
// GT3
NAMEDDEVICE( 0x5926, KBL_2x3x8, GTTYPE_GT3, "Intel(R) Iris(R) Plus Graphics 640" )
NAMEDDEVICE( 0x5927, KBL_2x3x8, GTTYPE_GT3, "Intel(R) Iris(R) Plus Graphics 650" )
DEVICE( 0x592B, KBL_2x3x8, GTTYPE_GT3 )
DEVICE( 0x592A, KBL_2x3x8, GTTYPE_GT3 )
DEVICE( 0x5923, KBL_2x3x8, GTTYPE_GT3 )
// GT4
DEVICE( 0x5932, KBL_3x3x8, GTTYPE_GT4 )
DEVICE( 0x593B, KBL_3x3x8, GTTYPE_GT4 )
DEVICE( 0x593A, KBL_3x3x8, GTTYPE_GT4 )
DEVICE( 0x593D, KBL_3x3x8, GTTYPE_GT4 )
NAMEDDEVICE( 0x5902, KBL_1x2x6, "Intel(R) HD Graphics 610" )
NAMEDDEVICE( 0x590B, KBL_1x2x6, "Intel(R) HD Graphics 610" )
DEVICE( 0x590A, KBL_1x2x6 )
NAMEDDEVICE( 0x5906, KBL_1x2x6, "Intel(R) HD Graphics 610" )
DEVICE( 0x590E, KBL_1x3x6 )
DEVICE( 0x5908, KBL_1x2x6 )
DEVICE( 0x5913, KBL_1x3x6 )
DEVICE( 0x5915, KBL_1x2x6 )
NAMEDDEVICE( 0x5912, KBL_1x3x8, "Intel(R) HD Graphics 630" )
NAMEDDEVICE( 0x591B, KBL_1x3x8, "Intel(R) HD Graphics 630" )
NAMEDDEVICE( 0x5917, KBL_1x3x8, "Intel(R) UHD Graphics 620" )
DEVICE( 0x591A, KBL_1x3x8 )
NAMEDDEVICE( 0x5916, KBL_1x3x8, "Intel(R) HD Graphics 620" )
NAMEDDEVICE( 0x591E, KBL_1x3x8, "Intel(R) HD Graphics 615" )
NAMEDDEVICE( 0x591D, KBL_1x3x8, "Intel(R) HD Graphics P630" )
NAMEDDEVICE( 0x591C, KBL_1x3x8, "Intel(R) UHD Graphics 615" )
NAMEDDEVICE( 0x5921, KBL_1x3x8, "Intel(R) HD Graphics 620" )
NAMEDDEVICE( 0x5926, KBL_2x3x8, "Intel(R) Iris(R) Plus Graphics 640" )
NAMEDDEVICE( 0x5927, KBL_2x3x8, "Intel(R) Iris(R) Plus Graphics 650" )
DEVICE( 0x592B, KBL_2x3x8 )
DEVICE( 0x592A, KBL_2x3x8 )
DEVICE( 0x5923, KBL_2x3x8 )
DEVICE( 0x5932, KBL_3x3x8 )
DEVICE( 0x593B, KBL_3x3x8 )
DEVICE( 0x593A, KBL_3x3x8 )
DEVICE( 0x593D, KBL_3x3x8 )
#endif
#ifdef SUPPORT_CFL
// GT1
NAMEDDEVICE( 0x3E90, CFL_1x2x6, GTTYPE_GT1, "Intel(R) UHD Graphics 610" )
NAMEDDEVICE( 0x3E93, CFL_1x2x6, GTTYPE_GT1, "Intel(R) UHD Graphics 610" )
DEVICE( 0x3EA4, CFL_1x2x6, GTTYPE_GT1 )
DEVICE( 0x3E99, CFL_1x2x6, GTTYPE_GT1 )
NAMEDDEVICE( 0x3EA1, CFL_1x2x6, GTTYPE_GT1, "Intel(R) UHD Graphics 610" )
// GT2
NAMEDDEVICE( 0x3E92, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics 630" )
NAMEDDEVICE( 0x3E9B, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics 630" )
NAMEDDEVICE( 0x3E94, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics P630" )
NAMEDDEVICE( 0x3E91, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics 630" )
NAMEDDEVICE( 0x3E96, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics P630" )
NAMEDDEVICE( 0x3E9A, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics P630" )
DEVICE( 0x3EA3, CFL_1x3x8, GTTYPE_GT2 )
NAMEDDEVICE( 0x3EA9, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics 620" )
NAMEDDEVICE( 0x3EA0, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics 620" )
NAMEDDEVICE( 0x3E98, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics 630" )
// GT3
DEVICE( 0x3E95, CFL_2x3x8, GTTYPE_GT3 )
NAMEDDEVICE( 0x3EA6, CFL_2x3x8, GTTYPE_GT3, "Intel(R) Iris(R) Plus Graphics 645" )
DEVICE( 0x3EA7, CFL_2x3x8, GTTYPE_GT3 )
NAMEDDEVICE( 0x3EA8, CFL_2x3x8, GTTYPE_GT3, "Intel(R) Iris(R) Plus Graphics 655" )
NAMEDDEVICE( 0x3EA5, CFL_2x3x8, GTTYPE_GT3, "Intel(R) Iris(R) Plus Graphics 655" )
DEVICE( 0x3EA2, CFL_2x3x8, GTTYPE_GT3 )
// CML GT1
NAMEDDEVICE( 0x9B21, CFL_1x2x6, GTTYPE_GT1, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x9BAA, CFL_1x2x6, GTTYPE_GT1, "Intel(R) UHD Graphics" )
DEVICE( 0x9BAB, CFL_1x2x6, GTTYPE_GT1 )
NAMEDDEVICE( 0x9BAC, CFL_1x2x6, GTTYPE_GT1, "Intel(R) UHD Graphics" )
DEVICE( 0x9BA0, CFL_1x2x6, GTTYPE_GT1 )
DEVICE( 0x9BA5, CFL_1x2x6, GTTYPE_GT1 )
NAMEDDEVICE( 0x9BA8, CFL_1x2x6, GTTYPE_GT1, "Intel(R) UHD Graphics 610" )
DEVICE( 0x9BA4, CFL_1x2x6, GTTYPE_GT1 )
DEVICE( 0x9BA2, CFL_1x2x6, GTTYPE_GT1 )
// CML GT2
NAMEDDEVICE( 0x9B41, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x9BCA, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics" )
DEVICE( 0x9BCB, CFL_1x3x8, GTTYPE_GT2 )
NAMEDDEVICE( 0x9BCC, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics" )
DEVICE( 0x9BC0, CFL_1x3x8, GTTYPE_GT2 )
NAMEDDEVICE( 0x9BC5, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics 630" )
NAMEDDEVICE( 0x9BC8, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics 630" )
NAMEDDEVICE( 0x9BC4, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics" )
DEVICE( 0x9BC2, CFL_1x3x8, GTTYPE_GT2 )
// CML WORKSTATION
NAMEDDEVICE( 0x9BC6, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics P630" )
NAMEDDEVICE( 0x9BE6, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics P630" )
NAMEDDEVICE( 0x9BF6, CFL_1x3x8, GTTYPE_GT2, "Intel(R) UHD Graphics P630" )
NAMEDDEVICE( 0x3E90, CFL_1x2x6, "Intel(R) UHD Graphics 610" )
NAMEDDEVICE( 0x3E93, CFL_1x2x6, "Intel(R) UHD Graphics 610" )
DEVICE( 0x3EA4, CFL_1x2x6 )
DEVICE( 0x3E99, CFL_1x2x6 )
NAMEDDEVICE( 0x3EA1, CFL_1x2x6, "Intel(R) UHD Graphics 610" )
NAMEDDEVICE( 0x3E92, CFL_1x3x8, "Intel(R) UHD Graphics 630" )
NAMEDDEVICE( 0x3E9B, CFL_1x3x8, "Intel(R) UHD Graphics 630" )
NAMEDDEVICE( 0x3E94, CFL_1x3x8, "Intel(R) UHD Graphics P630" )
NAMEDDEVICE( 0x3E91, CFL_1x3x8, "Intel(R) UHD Graphics 630" )
NAMEDDEVICE( 0x3E96, CFL_1x3x8, "Intel(R) UHD Graphics P630" )
NAMEDDEVICE( 0x3E9A, CFL_1x3x8, "Intel(R) UHD Graphics P630" )
DEVICE( 0x3EA3, CFL_1x3x8 )
NAMEDDEVICE( 0x3EA9, CFL_1x3x8, "Intel(R) UHD Graphics 620" )
NAMEDDEVICE( 0x3EA0, CFL_1x3x8, "Intel(R) UHD Graphics 620" )
NAMEDDEVICE( 0x3E98, CFL_1x3x8, "Intel(R) UHD Graphics 630" )
DEVICE( 0x3E95, CFL_2x3x8 )
NAMEDDEVICE( 0x3EA6, CFL_2x3x8, "Intel(R) Iris(R) Plus Graphics 645" )
DEVICE( 0x3EA7, CFL_2x3x8 )
NAMEDDEVICE( 0x3EA8, CFL_2x3x8, "Intel(R) Iris(R) Plus Graphics 655" )
NAMEDDEVICE( 0x3EA5, CFL_2x3x8, "Intel(R) Iris(R) Plus Graphics 655" )
DEVICE( 0x3EA2, CFL_2x3x8 )
NAMEDDEVICE( 0x9B21, CFL_1x2x6, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x9BAA, CFL_1x2x6, "Intel(R) UHD Graphics" )
DEVICE( 0x9BAB, CFL_1x2x6 )
NAMEDDEVICE( 0x9BAC, CFL_1x2x6, "Intel(R) UHD Graphics" )
DEVICE( 0x9BA0, CFL_1x2x6 )
DEVICE( 0x9BA5, CFL_1x2x6 )
NAMEDDEVICE( 0x9BA8, CFL_1x2x6, "Intel(R) UHD Graphics 610" )
DEVICE( 0x9BA4, CFL_1x2x6 )
DEVICE( 0x9BA2, CFL_1x2x6 )
NAMEDDEVICE( 0x9B41, CFL_1x3x8, "Intel(R) UHD Graphics" )
NAMEDDEVICE( 0x9BCA, CFL_1x3x8, "Intel(R) UHD Graphics" )
DEVICE( 0x9BCB, CFL_1x3x8 )
NAMEDDEVICE( 0x9BCC, CFL_1x3x8, "Intel(R) UHD Graphics" )
DEVICE( 0x9BC0, CFL_1x3x8 )
NAMEDDEVICE( 0x9BC5, CFL_1x3x8, "Intel(R) UHD Graphics 630" )
NAMEDDEVICE( 0x9BC8, CFL_1x3x8, "Intel(R) UHD Graphics 630" )
NAMEDDEVICE( 0x9BC4, CFL_1x3x8, "Intel(R) UHD Graphics" )
DEVICE( 0x9BC2, CFL_1x3x8 )
NAMEDDEVICE( 0x9BC6, CFL_1x3x8, "Intel(R) UHD Graphics P630" )
NAMEDDEVICE( 0x9BE6, CFL_1x3x8, "Intel(R) UHD Graphics P630" )
NAMEDDEVICE( 0x9BF6, CFL_1x3x8, "Intel(R) UHD Graphics P630" )
#endif
#ifdef SUPPORT_GLK
NAMEDDEVICE( 0x3184, GLK_1x3x6, GTTYPE_GTA, "Intel(R) UHD Graphics 605" )
NAMEDDEVICE( 0x3185, GLK_1x2x6, GTTYPE_GTA, "Intel(R) UHD Graphics 600" )
NAMEDDEVICE( 0x3184, GLK_1x3x6, "Intel(R) UHD Graphics 605" )
NAMEDDEVICE( 0x3185, GLK_1x2x6, "Intel(R) UHD Graphics 600" )
#endif
#ifdef SUPPORT_BXT
DEVICE( 0x9906, BXT_1x3x6, GTTYPE_GTA)
DEVICE( 0x9907, BXT_1x3x6, GTTYPE_GTA)
DEVICE( 0x0A84, BXT_1x3x6, GTTYPE_GTA)
NAMEDDEVICE( 0x5A84, BXT_1x3x6, GTTYPE_GTA, "Intel(R) HD Graphics 505" ) //18EU APL
NAMEDDEVICE( 0x5A85, BXT_1x2x6, GTTYPE_GTA, "Intel(R) HD Graphics 500" ) //12EU APL
DEVICE( 0x1A85, BXT_1x2x6, GTTYPE_GTA) //12EU APL
DEVICE( 0x1A84, BXT_1x3x6, GTTYPE_GTA)
DEVICE( 0x9908, BXT_1x3x6, GTTYPE_GTA)
DEVICE( 0x9906, BXT_1x3x6)
DEVICE( 0x9907, BXT_1x3x6)
DEVICE( 0x0A84, BXT_1x3x6)
NAMEDDEVICE( 0x5A84, BXT_1x3x6, "Intel(R) HD Graphics 505" )
NAMEDDEVICE( 0x5A85, BXT_1x2x6, "Intel(R) HD Graphics 500" )
DEVICE( 0x1A85, BXT_1x2x6)
DEVICE( 0x1A84, BXT_1x3x6)
DEVICE( 0x9908, BXT_1x3x6)
#endif
#endif
#ifdef SUPPORT_GEN8
// GT1
DEVICE( 0x1602, BDW_1x2x6, GTTYPE_GT1 )
DEVICE( 0x160A, BDW_1x2x6, GTTYPE_GT1 )
DEVICE( 0x1606, BDW_1x2x6, GTTYPE_GT1 )
NAMEDDEVICE( 0x160E, BDW_1x2x6, GTTYPE_GT1, "Intel(R) HD Graphics" )
DEVICE( 0x160D, BDW_1x2x6, GTTYPE_GT1 )
// GT2
NAMEDDEVICE( 0x1612, BDW_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 5600" )
NAMEDDEVICE( 0x161A, BDW_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics P5700" )
NAMEDDEVICE( 0x1616, BDW_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 5500" )
NAMEDDEVICE( 0x161E, BDW_1x3x8, GTTYPE_GT2, "Intel(R) HD Graphics 5300" )
DEVICE( 0x161D, BDW_1x3x8, GTTYPE_GT2 )
// GT3
DEVICE( 0x1622, BDW_2x3x8, GTTYPE_GT3 )
NAMEDDEVICE( 0x162A, BDW_2x3x8, GTTYPE_GT3, "Intel(R) Iris(TM) Pro Graphics P6300" )
NAMEDDEVICE( 0x1626, BDW_2x3x8, GTTYPE_GT3, "Intel(R) HD Graphics 6000" )
DEVICE( 0x162B, BDW_2x3x8, GTTYPE_GT3 )
DEVICE( 0x162E, BDW_2x3x8, GTTYPE_GT3 )
DEVICE( 0x162D, BDW_2x3x8, GTTYPE_GT3 )
DEVICE( 0x1602, BDW_1x2x6 )
DEVICE( 0x160A, BDW_1x2x6 )
DEVICE( 0x1606, BDW_1x2x6 )
NAMEDDEVICE( 0x160E, BDW_1x2x6, "Intel(R) HD Graphics" )
DEVICE( 0x160D, BDW_1x2x6 )
NAMEDDEVICE( 0x1612, BDW_1x3x8, "Intel(R) HD Graphics 5600" )
NAMEDDEVICE( 0x161A, BDW_1x3x8, "Intel(R) HD Graphics P5700" )
NAMEDDEVICE( 0x1616, BDW_1x3x8, "Intel(R) HD Graphics 5500" )
NAMEDDEVICE( 0x161E, BDW_1x3x8, "Intel(R) HD Graphics 5300" )
DEVICE( 0x161D, BDW_1x3x8 )
DEVICE( 0x1622, BDW_2x3x8 )
NAMEDDEVICE( 0x162A, BDW_2x3x8, "Intel(R) Iris(TM) Pro Graphics P6300" )
NAMEDDEVICE( 0x1626, BDW_2x3x8, "Intel(R) HD Graphics 6000" )
DEVICE( 0x162B, BDW_2x3x8 )
DEVICE( 0x162E, BDW_2x3x8 )
DEVICE( 0x162D, BDW_2x3x8 )
#endif
// clang-format on

11
shared/source/dll/linux/drm_neo_create.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -24,12 +24,12 @@
namespace NEO {
const DeviceDescriptor deviceDescriptorTable[] = {
#define NAMEDDEVICE(devId, gt, gtType, devName) {devId, &gt::hwInfo, &gt::setupHardwareInfo, gtType, devName},
#define DEVICE(devId, gt, gtType) {devId, &gt::hwInfo, &gt::setupHardwareInfo, gtType, ""},
#define NAMEDDEVICE(devId, gt, devName) {devId, &gt::hwInfo, &gt::setupHardwareInfo, devName},
#define DEVICE(devId, gt) {devId, &gt::hwInfo, &gt::setupHardwareInfo, ""},
#include "devices.inl"
#undef DEVICE
#undef NAMEDDEVICE
{0, nullptr, nullptr, GTTYPE_UNDEFINED}};
{0, nullptr, nullptr}};
Drm *Drm::create(std::unique_ptr<HwDeviceIdDrm> &&hwDeviceId, RootDeviceEnvironment &rootDeviceEnvironment) {
std::unique_ptr<Drm> drmObject;
@ -55,11 +55,9 @@ Drm *Drm::create(std::unique_ptr<HwDeviceIdDrm> &&hwDeviceId, RootDeviceEnvironm
const DeviceDescriptor *device = nullptr;
const char *devName = "";
GTTYPE eGtType = GTTYPE_UNDEFINED;
for (auto &d : deviceDescriptorTable) {
if (drmObject->deviceId == d.deviceId) {
device = &d;
eGtType = d.eGtType;
devName = d.devName;
break;
}
@ -69,7 +67,6 @@ Drm *Drm::create(std::unique_ptr<HwDeviceIdDrm> &&hwDeviceId, RootDeviceEnvironm
if (ret != 0) {
return nullptr;
}
drmObject->setGtType(eGtType);
rootDeviceEnvironment.setHwInfo(device->pHwInfo);
rootDeviceEnvironment.getMutableHardwareInfo()->capabilityTable.deviceName = devName;
} else {

2
shared/source/gen9/hw_info_skl.cpp
View File

@ -112,9 +112,7 @@ void SKL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrVcs2 = featureTable->flags.ftrGT3 || featureTable->flags.ftrGT4;
featureTable->flags.ftrVEBOX = true;
featureTable->flags.ftrSingleVeboxSlice = featureTable->flags.ftrGT1 || featureTable->flags.ftrGT2;
featureTable->flags.ftrTileY = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;

4
shared/source/os_interface/linux/drm_neo.h
View File

@ -51,7 +51,6 @@ struct DeviceDescriptor { // NOLINT(clang-analyzer-optin.performance.Padding)
unsigned short deviceId;
const HardwareInfo *pHwInfo;
void (*setupHardwareInfo)(HardwareInfo *, bool);
GTTYPE eGtType;
const char *devName;
};
@ -128,8 +127,6 @@ class Drm : public DriverModel {
unsigned int bindDrmContext(uint32_t drmContextId, uint32_t deviceIndex, aub_stream::EngineType engineType, bool engineInstancedDevice);
void setGtType(GTTYPE eGtType) { this->eGtType = eGtType; }
GTTYPE getGtType() const { return this->eGtType; }
MOCKABLE_VIRTUAL int getErrno();
bool setQueueSliceCount(uint64_t sliceCount);
void checkQueueSliceSupport();
@ -327,7 +324,6 @@ class Drm : public DriverModel {
int deviceId = 0;
int revisionId = 0;
GTTYPE eGtType = GTTYPE_UNDEFINED;
bool sliceCountChangeSupported = false;
bool preemptionSupported = false;

18
shared/source/os_interface/linux/hw_info_config_drm.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -143,22 +143,6 @@ int HwInfoConfig::configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo
int maxGpuFreq = 0;
drm->getMaxGpuFrequency(*outHwInfo, maxGpuFreq);
GTTYPE gtType = drm->getGtType();
if (gtType == GTTYPE_UNDEFINED) {
*outHwInfo = {};
return -1;
}
platform->eGTType = gtType;
featureTable->flags.ftrGTA = (gtType == GTTYPE_GTA) ? 1 : 0;
featureTable->flags.ftrGTC = (gtType == GTTYPE_GTC) ? 1 : 0;
featureTable->flags.ftrGTX = (gtType == GTTYPE_GTX) ? 1 : 0;
featureTable->flags.ftrGT1 = (gtType == GTTYPE_GT1) ? 1 : 0;
featureTable->flags.ftrGT1_5 = (gtType == GTTYPE_GT1_5) ? 1 : 0;
featureTable->flags.ftrGT2 = (gtType == GTTYPE_GT2) ? 1 : 0;
featureTable->flags.ftrGT2_5 = (gtType == GTTYPE_GT2_5) ? 1 : 0;
featureTable->flags.ftrGT3 = (gtType == GTTYPE_GT3) ? 1 : 0;
featureTable->flags.ftrGT4 = (gtType == GTTYPE_GT4) ? 1 : 0;
ret = configureHardwareCustom(outHwInfo, osIface);
if (ret != 0) {
*outHwInfo = {};

4
shared/test/common/fixtures/linux/device_id_fixture.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -30,7 +30,7 @@ struct DeviceIdTests : public ::testing::Test {
bool compareStructs(const DeviceDescriptor *first, const DeviceDescriptor *second) {
return first->deviceId == second->deviceId && first->pHwInfo == second->pHwInfo &&
first->setupHardwareInfo == second->setupHardwareInfo && first->eGtType == second->eGtType;
first->setupHardwareInfo == second->setupHardwareInfo;
}
};

4
shared/test/common/os_interface/linux/drm_neo_create.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -23,7 +23,7 @@ class DrmMockDefault : public DrmMock {
storedRetValForDeviceRevID = 0;
storedRetValForPooledEU = 0;
storedRetValForMinEUinPool = 0;
setGtType(GTTYPE_GT1);
if (hwDeviceIdIn != nullptr)
this->hwDeviceId = std::move(hwDeviceIdIn);
}

4
shared/test/unit_test/os_interface/linux/drm_query_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -78,8 +78,6 @@ HWTEST2_F(HwConfigTopologyQuery, WhenGettingTopologyFailsThenSetMaxValuesBasedOn
*executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = *NEO::defaultHwInfo.get();
auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
drm->setGtType(GTTYPE_GT1);
auto osInterface = std::make_unique<OSInterface>();
osInterface->setDriverModel(std::unique_ptr<Drm>(drm));