Create enum for Ioctl request values

Related-To: NEO-6852
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

level_zero/tools/source/debug/linux/prelim/debug_session.cpp

@@ -49,7 +49,7 @@ DebugSession *DebugSession::create(const zet_debug_config_t &config, Device *dev
         open.pid = config.pid;
         open.events = 0;
 
-        auto debugFd = DrmHelper::ioctl(device, PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN, &open);
+        auto debugFd = DrmHelper::ioctl(device, NEO::DrmIoctl::DebuggerOpen, &open);
         if (debugFd >= 0) {
             PRINT_DEBUGGER_INFO_LOG("PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN: open.pid: %d, open.events: %d, debugFd: %d\n",
                                     open.pid, open.events, debugFd);

level_zero/tools/source/debug/linux/prelim/drm_helper.cpp

@@ -9,9 +9,11 @@
 
 #include "shared/source/os_interface/linux/drm_neo.h"
 
+#include "level_zero/core/source/device/device.h"
+
 namespace L0 {
 
-int DrmHelper::ioctl(Device *device, unsigned long request, void *arg) {
+int DrmHelper::ioctl(Device *device, NEO::DrmIoctl request, void *arg) {
     auto drm = device->getOsInterface().getDriverModel()->as<NEO::Drm>();
     return drm->ioctl(request, arg);
 }

level_zero/tools/source/debug/linux/prelim/drm_helper.h

@@ -7,15 +7,18 @@
 
 #include "shared/source/helpers/topology_map.h"
 
-#include "level_zero/core/source/device/device.h"
-
 namespace NEO {
 struct EngineClassInstance;
+enum class DrmIoctl;
+} // namespace NEO
+namespace aub_stream {
+enum EngineType : uint32_t;
 }
 
 namespace L0 {
+struct Device;
 struct DrmHelper {
-    static int ioctl(Device *device, unsigned long request, void *arg);
+    static int ioctl(Device *device, NEO::DrmIoctl request, void *arg);
     static int getErrno(Device *device);
     static uint32_t getEngineTileIndex(Device *device, const NEO::EngineClassInstance &engine);
     static const NEO::EngineClassInstance *getEngineInstance(Device *device, uint32_t tile, aub_stream::EngineType engineType);

opencl/test/unit_test/linux/drm_null_device_tests.cpp

@@ -55,36 +55,36 @@ TEST_F(DrmNullDeviceTests, GIVENdrmNullDeviceWHENcallGetDeviceIdTHENreturnProper
 }
 
 TEST_F(DrmNullDeviceTests, GIVENdrmNullDeviceWHENcallIoctlTHENalwaysSuccess) {
-    EXPECT_EQ(drmNullDevice->ioctl(0, nullptr), 0);
+    EXPECT_EQ(drmNullDevice->ioctl(DrmIoctl::GemExecbuffer2, nullptr), 0);
 }
 
 TEST_F(DrmNullDeviceTests, GIVENdrmNullDeviceWHENregReadOtherThenTimestampReadTHENalwaysSuccess) {
     RegisterRead arg;
 
     arg.offset = 0;
-    ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), 0);
+    ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), 0);
 }
 
 TEST_F(DrmNullDeviceTests, GIVENdrmNullDeviceWHENgetGpuTimestamp32bOr64bTHENerror) {
     RegisterRead arg;
 
     arg.offset = REG_GLOBAL_TIMESTAMP_LDW;
-    ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), -1);
+    ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), -1);
 
     arg.offset = REG_GLOBAL_TIMESTAMP_UN;
-    ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), -1);
+    ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), -1);
 }
 
 TEST_F(DrmNullDeviceTests, GIVENdrmNullDeviceWHENgetGpuTimestamp36bTHENproperValues) {
     RegisterRead arg;
 
     arg.offset = REG_GLOBAL_TIMESTAMP_LDW | 1;
-    ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), 0);
+    ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), 0);
     EXPECT_EQ(arg.value, 1000ULL);
 
-    ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), 0);
+    ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), 0);
     EXPECT_EQ(arg.value, 2000ULL);
 
-    ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), 0);
+    ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), 0);
     EXPECT_EQ(arg.value, 3000ULL);
 }

opencl/test/unit_test/linux/main_linux_dll.cpp

@@ -283,9 +283,9 @@ TEST_F(DrmSimpleTests, givenPrintIoctlTimesWhenCallIoctlThenStatisticsAreGathere
     drm->setLowPriorityContextParam(contextId);
     EXPECT_EQ(2u, drm->ioctlStatistics.size());
 
-    auto euTotalData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GETPARAM);
+    auto euTotalData = drm->ioctlStatistics.find(DrmIoctl::Getparam);
     ASSERT_TRUE(euTotalData != drm->ioctlStatistics.end());
-    EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GETPARAM), euTotalData->first);
+    EXPECT_EQ(DrmIoctl::Getparam, euTotalData->first);
     EXPECT_EQ(2u, euTotalData->second.count);
     EXPECT_NE(0, euTotalData->second.totalTime);
     EXPECT_NE(initialMin, euTotalData->second.minTime);
@@ -295,9 +295,9 @@ TEST_F(DrmSimpleTests, givenPrintIoctlTimesWhenCallIoctlThenStatisticsAreGathere
     EXPECT_NE(initialMax, euTotalData->second.maxTime);
     auto firstTime = euTotalData->second.totalTime;
 
-    auto lowPriorityData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM);
+    auto lowPriorityData = drm->ioctlStatistics.find(DrmIoctl::GemContextSetparam);
     ASSERT_TRUE(lowPriorityData != drm->ioctlStatistics.end());
-    EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM), lowPriorityData->first);
+    EXPECT_EQ(DrmIoctl::GemContextSetparam, lowPriorityData->first);
     EXPECT_EQ(1u, lowPriorityData->second.count);
     EXPECT_NE(0, lowPriorityData->second.totalTime);
     EXPECT_NE(initialMin, lowPriorityData->second.minTime);
@@ -308,39 +308,39 @@ TEST_F(DrmSimpleTests, givenPrintIoctlTimesWhenCallIoctlThenStatisticsAreGathere
     drm->getEuTotal(euTotal);
     EXPECT_EQ(drm->ioctlStatistics.size(), 2u);
 
-    euTotalData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GETPARAM);
+    euTotalData = drm->ioctlStatistics.find(DrmIoctl::Getparam);
     ASSERT_TRUE(euTotalData != drm->ioctlStatistics.end());
-    EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GETPARAM), euTotalData->first);
+    EXPECT_EQ(DrmIoctl::Getparam, euTotalData->first);
     EXPECT_EQ(3u, euTotalData->second.count);
     EXPECT_NE(0u, euTotalData->second.totalTime);
 
     auto secondTime = euTotalData->second.totalTime;
     EXPECT_GT(secondTime, firstTime);
 
-    lowPriorityData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM);
+    lowPriorityData = drm->ioctlStatistics.find(DrmIoctl::GemContextSetparam);
     ASSERT_TRUE(lowPriorityData != drm->ioctlStatistics.end());
-    EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM), lowPriorityData->first);
+    EXPECT_EQ(DrmIoctl::GemContextSetparam, lowPriorityData->first);
     EXPECT_EQ(1u, lowPriorityData->second.count);
     EXPECT_NE(0, lowPriorityData->second.totalTime);
 
     drm->destroyDrmContext(contextId);
     EXPECT_EQ(3u, drm->ioctlStatistics.size());
 
-    euTotalData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GETPARAM);
+    euTotalData = drm->ioctlStatistics.find(DrmIoctl::Getparam);
     ASSERT_TRUE(euTotalData != drm->ioctlStatistics.end());
-    EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GETPARAM), euTotalData->first);
+    EXPECT_EQ(DrmIoctl::Getparam, euTotalData->first);
     EXPECT_EQ(3u, euTotalData->second.count);
     EXPECT_NE(0, euTotalData->second.totalTime);
 
-    lowPriorityData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM);
+    lowPriorityData = drm->ioctlStatistics.find(DrmIoctl::GemContextSetparam);
     ASSERT_TRUE(lowPriorityData != drm->ioctlStatistics.end());
-    EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM), lowPriorityData->first);
+    EXPECT_EQ(DrmIoctl::GemContextSetparam, lowPriorityData->first);
     EXPECT_EQ(1u, lowPriorityData->second.count);
     EXPECT_NE(0, lowPriorityData->second.totalTime);
 
-    auto destroyData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY);
+    auto destroyData = drm->ioctlStatistics.find(DrmIoctl::GemContextDestroy);
     ASSERT_TRUE(destroyData != drm->ioctlStatistics.end());
-    EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY), destroyData->first);
+    EXPECT_EQ(DrmIoctl::GemContextDestroy, destroyData->first);
     EXPECT_EQ(1u, destroyData->second.count);
     EXPECT_NE(0, destroyData->second.totalTime);
 
@@ -481,7 +481,7 @@ TEST_F(DrmTests, GivenErrorCodeWhenCreatingDrmThenDrmCreatedOnlyWithSpecificErro
     // check if device works, although there was EINTR error from KMD
     getParam.param = I915_PARAM_CHIPSET_ID;
     getParam.value = &lDeviceId;
-    auto ret = drm->ioctl(DRM_IOCTL_I915_GETPARAM, &getParam);
+    auto ret = drm->ioctl(DrmIoctl::Getparam, &getParam);
     EXPECT_EQ(0, ret);
     EXPECT_EQ(deviceId, lDeviceId);
 
@@ -491,7 +491,7 @@ TEST_F(DrmTests, GivenErrorCodeWhenCreatingDrmThenDrmCreatedOnlyWithSpecificErro
     // check if device works, although there was EAGAIN error from KMD
     getParam.param = I915_PARAM_CHIPSET_ID;
     getParam.value = &lDeviceId;
-    ret = drm->ioctl(DRM_IOCTL_I915_GETPARAM, &getParam);
+    ret = drm->ioctl(DrmIoctl::Getparam, &getParam);
     EXPECT_EQ(0, ret);
     EXPECT_EQ(deviceId, lDeviceId);
 
@@ -501,7 +501,7 @@ TEST_F(DrmTests, GivenErrorCodeWhenCreatingDrmThenDrmCreatedOnlyWithSpecificErro
     // check if device works, although there was EBUSY error from KMD
     getParam.param = I915_PARAM_CHIPSET_ID;
     getParam.value = &lDeviceId;
-    ret = drm->ioctl(DRM_IOCTL_I915_GETPARAM, &getParam);
+    ret = drm->ioctl(DrmIoctl::Getparam, &getParam);
     EXPECT_EQ(0, ret);
     EXPECT_EQ(deviceId, lDeviceId);
 
@@ -511,7 +511,7 @@ TEST_F(DrmTests, GivenErrorCodeWhenCreatingDrmThenDrmCreatedOnlyWithSpecificErro
     // we failed with any other error code
     getParam.param = I915_PARAM_CHIPSET_ID;
     getParam.value = &lDeviceId;
-    ret = drm->ioctl(DRM_IOCTL_I915_GETPARAM, &getParam);
+    ret = drm->ioctl(DrmIoctl::Getparam, &getParam);
     EXPECT_EQ(-1, ret);
     EXPECT_EQ(deviceId, lDeviceId);
 }

opencl/test/unit_test/mt_tests/os_interface/linux/drm_memory_manager_mt_tests.cpp

@@ -27,8 +27,8 @@ TEST(DrmMemoryManagerTest, givenDrmMemoryManagerWhenSharedAllocationIsCreatedFro
         using Drm::setupIoctlHelper;
         MockDrm(int fd, RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(fd, ""), rootDeviceEnvironment) {}
 
-        int ioctl(unsigned long request, void *arg) override {
+        int ioctl(DrmIoctl request, void *arg) override {
-            if (request == DRM_IOCTL_PRIME_FD_TO_HANDLE) {
+            if (request == DrmIoctl::PrimeFdToHandle) {
                 auto *primeToHandleParams = static_cast<PrimeHandle *>(arg);
                 primeToHandleParams->handle = 10;
             }
@@ -86,8 +86,8 @@ TEST(DrmMemoryManagerTest, givenMultipleThreadsWhenSharedAllocationIsCreatedThen
         std::atomic<int> primeFdHandle;
         std::atomic<int> closeHandle;
 
-        int ioctl(unsigned long request, void *arg) override {
+        int ioctl(DrmIoctl request, void *arg) override {
-            if (request == DRM_IOCTL_PRIME_FD_TO_HANDLE) {
+            if (request == DrmIoctl::PrimeFdToHandle) {
                 auto *primeToHandleParams = static_cast<PrimeHandle *>(arg);
                 primeToHandleParams->handle = primeFdHandle;
 
@@ -96,7 +96,7 @@ TEST(DrmMemoryManagerTest, givenMultipleThreadsWhenSharedAllocationIsCreatedThen
                 EXPECT_EQ(closeHandle.load(), primeFdHandle.load());
             }
 
-            else if (request == DRM_IOCTL_GEM_CLOSE) {
+            else if (request == DrmIoctl::GemClose) {
                 closeHandle++;
                 std::this_thread::yield();
 

opencl/test/unit_test/os_interface/linux/drm_gem_close_worker_tests.cpp

@@ -39,13 +39,8 @@ class DrmMockForWorker : public Drm {
     std::atomic<std::thread::id> ioctl_caller_thread_id;
     DrmMockForWorker(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(mockFd, mockPciPath), rootDeviceEnvironment) {
     }
-    int ioctl(unsigned long request, void *arg) override {
+    int ioctl(DrmIoctl request, void *arg) override {
-        if (_IOC_TYPE(request) == DRM_IOCTL_BASE) {
+        if (request == DrmIoctl::GemClose)
-            //when drm ioctl is called, try acquire mutex
-            //main thread can hold mutex, to prevent ioctl handling
-            std::lock_guard<std::mutex> lock(mutex);
-        }
-        if (request == DRM_IOCTL_GEM_CLOSE)
             gem_close_cnt++;
 
         ioctl_caller_thread_id = std::this_thread::get_id();

shared/source/os_interface/linux/device_time_drm.cpp

@@ -31,10 +31,10 @@ void DeviceTimeDrm::timestampTypeDetect() {
         return;
 
     reg.offset = (REG_GLOBAL_TIMESTAMP_LDW | 1);
-    err = pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &reg);
+    err = pDrm->ioctl(DrmIoctl::RegRead, &reg);
     if (err) {
         reg.offset = REG_GLOBAL_TIMESTAMP_UN;
-        err = pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &reg);
+        err = pDrm->ioctl(DrmIoctl::RegRead, &reg);
         if (err) {
             getGpuTime = &DeviceTimeDrm::getGpuTime32;
         } else {
@@ -50,7 +50,7 @@ bool DeviceTimeDrm::getGpuTime32(uint64_t *timestamp) {
 
     reg.offset = REG_GLOBAL_TIMESTAMP_LDW;
 
-    if (pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &reg)) {
+    if (pDrm->ioctl(DrmIoctl::RegRead, &reg)) {
         return false;
     }
     *timestamp = reg.value >> 32;
@@ -62,7 +62,7 @@ bool DeviceTimeDrm::getGpuTime36(uint64_t *timestamp) {
 
     reg.offset = REG_GLOBAL_TIMESTAMP_LDW | 1;
 
-    if (pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &reg)) {
+    if (pDrm->ioctl(DrmIoctl::RegRead, &reg)) {
         return false;
     }
     *timestamp = reg.value;
@@ -78,11 +78,11 @@ bool DeviceTimeDrm::getGpuTimeSplitted(uint64_t *timestamp) {
     regHi.offset = REG_GLOBAL_TIMESTAMP_UN;
     regLo.offset = REG_GLOBAL_TIMESTAMP_LDW;
 
-    err += pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &regHi);
+    err += pDrm->ioctl(DrmIoctl::RegRead, &regHi);
     do {
         tmpHi = regHi.value;
-        err += pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &regLo);
+        err += pDrm->ioctl(DrmIoctl::RegRead, &regLo);
-        err += pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &regHi);
+        err += pDrm->ioctl(DrmIoctl::RegRead, &regHi);
     } while (err == 0 && regHi.value != tmpHi && --loop);
 
     if (err) {

shared/source/os_interface/linux/drm_buffer_object.cpp

@@ -67,7 +67,7 @@ bool BufferObject::close() {
 
     PRINT_DEBUG_STRING(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "Calling gem close on handle: BO-%d\n", this->handle);
 
-    int ret = this->drm->ioctl(DRM_IOCTL_GEM_CLOSE, &close);
+    int ret = this->drm->ioctl(DrmIoctl::GemClose, &close);
     if (ret != 0) {
         int err = errno;
         PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(GEM_CLOSE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@@ -101,7 +101,7 @@ bool BufferObject::setTiling(uint32_t mode, uint32_t stride) {
     setTiling.tilingMode = mode;
     setTiling.stride = stride;
 
-    if (this->drm->ioctl(DRM_IOCTL_I915_GEM_SET_TILING, &setTiling) != 0) {
+    if (this->drm->ioctl(DrmIoctl::GemSetTiling, &setTiling) != 0) {
         return false;
     }
 

shared/source/os_interface/linux/drm_gem_close_worker.cpp

@@ -16,7 +16,6 @@
 #include <atomic>
 #include <iostream>
 #include <queue>
-#include <stdio.h>
 
 namespace NEO {
 

shared/source/os_interface/linux/drm_memory_manager.cpp

@@ -247,7 +247,7 @@ NEO::BufferObject *DrmMemoryManager::allocUserptr(uintptr_t address, size_t size
 
     auto &drm = this->getDrm(rootDeviceIndex);
 
-    if (drm.ioctl(DRM_IOCTL_I915_GEM_USERPTR, &userptr) != 0) {
+    if (drm.ioctl(DrmIoctl::GemUserptr, &userptr) != 0) {
         return nullptr;
     }
 
@@ -518,7 +518,7 @@ GraphicsAllocation *DrmMemoryManager::allocateMemoryByKMD(const AllocationData &
 
     auto &drm = getDrm(allocationData.rootDeviceIndex);
 
-    [[maybe_unused]] auto ret = drm.ioctl(DRM_IOCTL_I915_GEM_CREATE, &create);
+    [[maybe_unused]] auto ret = drm.ioctl(DrmIoctl::GemCreate, &create);
     DEBUG_BREAK_IF(ret != 0);
 
     auto patIndex = drm.getPatIndex(gmm.get(), allocationData.type, CacheRegion::Default, CachePolicy::WriteBack, false);
@@ -551,7 +551,7 @@ GraphicsAllocation *DrmMemoryManager::allocateGraphicsMemoryForImageImpl(const A
 
     auto &drm = this->getDrm(allocationData.rootDeviceIndex);
 
-    [[maybe_unused]] auto ret = drm.ioctl(DRM_IOCTL_I915_GEM_CREATE, &create);
+    [[maybe_unused]] auto ret = drm.ioctl(DrmIoctl::GemCreate, &create);
     DEBUG_BREAK_IF(ret != 0);
 
     auto patIndex = drm.getPatIndex(gmm.get(), allocationData.type, CacheRegion::Default, CachePolicy::WriteBack, false);
@@ -681,7 +681,7 @@ GraphicsAllocation *DrmMemoryManager::createGraphicsAllocationFromMultipleShared
         PrimeHandle openFd = {0, 0, 0};
         openFd.fileDescriptor = handle;
 
-        auto ret = this->getDrm(properties.rootDeviceIndex).ioctl(DRM_IOCTL_PRIME_FD_TO_HANDLE, &openFd);
+        auto ret = this->getDrm(properties.rootDeviceIndex).ioctl(DrmIoctl::PrimeFdToHandle, &openFd);
 
         if (ret != 0) {
             [[maybe_unused]] int err = errno;
@@ -767,7 +767,7 @@ GraphicsAllocation *DrmMemoryManager::createGraphicsAllocationFromSharedHandle(o
 
     auto &drm = this->getDrm(properties.rootDeviceIndex);
 
-    auto ret = drm.ioctl(DRM_IOCTL_PRIME_FD_TO_HANDLE, &openFd);
+    auto ret = drm.ioctl(DrmIoctl::PrimeFdToHandle, &openFd);
 
     if (ret != 0) {
         [[maybe_unused]] int err = errno;
@@ -817,7 +817,7 @@ GraphicsAllocation *DrmMemoryManager::createGraphicsAllocationFromSharedHandle(o
     if (properties.imgInfo) {
         GemGetTiling getTiling{};
         getTiling.handle = boHandle;
-        ret = drm.ioctl(DRM_IOCTL_I915_GEM_GET_TILING, &getTiling);
+        ret = drm.ioctl(DrmIoctl::GemGetTiling, &getTiling);
 
         if (ret == 0) {
             if (getTiling.isTilingDisabled()) {
@@ -856,7 +856,7 @@ GraphicsAllocation *DrmMemoryManager::createPaddedAllocation(GraphicsAllocation
         GemMmap mmapArg = {};
         mmapArg.handle = bo->peekHandle();
         mmapArg.size = bo->peekSize();
-        if (getDrm(rootDeviceIndex).ioctl(DRM_IOCTL_I915_GEM_MMAP, &mmapArg) != 0) {
+        if (getDrm(rootDeviceIndex).ioctl(DrmIoctl::GemMmap, &mmapArg) != 0) {
             return nullptr;
         }
         srcPtr = addrToPtr(mmapArg.addrPtr);
@@ -988,7 +988,7 @@ uint64_t DrmMemoryManager::getSystemSharedMemory(uint32_t rootDeviceIndex) {
 
     GemContextParam getContextParam = {};
     getContextParam.param = I915_CONTEXT_PARAM_GTT_SIZE;
-    [[maybe_unused]] auto ret = getDrm(rootDeviceIndex).ioctl(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &getContextParam);
+    [[maybe_unused]] auto ret = getDrm(rootDeviceIndex).ioctl(DrmIoctl::GemContextGetparam, &getContextParam);
     DEBUG_BREAK_IF(ret != 0);
 
     uint64_t gpuMemorySize = getContextParam.value;
@@ -1080,7 +1080,7 @@ bool DrmMemoryManager::setDomainCpu(GraphicsAllocation &graphicsAllocation, bool
     setDomain.readDomains = I915_GEM_DOMAIN_CPU;
     setDomain.writeDomain = writeEnable ? I915_GEM_DOMAIN_CPU : 0;
 
-    return getDrm(graphicsAllocation.getRootDeviceIndex()).ioctl(DRM_IOCTL_I915_GEM_SET_DOMAIN, &setDomain) == 0;
+    return getDrm(graphicsAllocation.getRootDeviceIndex()).ioctl(DrmIoctl::GemSetDomain, &setDomain) == 0;
 }
 
 void *DrmMemoryManager::lockResourceImpl(GraphicsAllocation &graphicsAllocation) {
@@ -1102,7 +1102,7 @@ void *DrmMemoryManager::lockResourceImpl(GraphicsAllocation &graphicsAllocation)
     GemMmap mmapArg = {};
     mmapArg.handle = bo->peekHandle();
     mmapArg.size = bo->peekSize();
-    if (getDrm(graphicsAllocation.getRootDeviceIndex()).ioctl(DRM_IOCTL_I915_GEM_MMAP, &mmapArg) != 0) {
+    if (getDrm(graphicsAllocation.getRootDeviceIndex()).ioctl(DrmIoctl::GemMmap, &mmapArg) != 0) {
         return nullptr;
     }
 
@@ -1139,7 +1139,7 @@ int DrmMemoryManager::obtainFdFromHandle(int boHandle, uint32_t rootDeviceindex)
     openFd.flags = DRM_CLOEXEC | DRM_RDWR;
     openFd.handle = boHandle;
 
-    getDrm(rootDeviceindex).ioctl(DRM_IOCTL_PRIME_HANDLE_TO_FD, &openFd);
+    getDrm(rootDeviceindex).ioctl(DrmIoctl::PrimeHandleToFd, &openFd);
 
     return openFd.fileDescriptor;
 }
@@ -1638,10 +1638,10 @@ bool DrmMemoryManager::retrieveMmapOffsetForBufferObject(uint32_t rootDeviceInde
     mmapOffset.handle = bo.peekHandle();
     mmapOffset.flags = isLocalMemorySupported(rootDeviceIndex) ? mmapOffsetFixed : flags;
     auto &drm = getDrm(rootDeviceIndex);
-    auto ret = drm.ioctl(DRM_IOCTL_I915_GEM_MMAP_OFFSET, &mmapOffset);
+    auto ret = drm.ioctl(DrmIoctl::GemMmapOffset, &mmapOffset);
     if (ret != 0 && isLocalMemorySupported(rootDeviceIndex)) {
         mmapOffset.flags = flags;
-        ret = drm.ioctl(DRM_IOCTL_I915_GEM_MMAP_OFFSET, &mmapOffset);
+        ret = drm.ioctl(DrmIoctl::GemMmapOffset, &mmapOffset);
     }
     if (ret != 0) {
         int err = drm.getErrno();
@@ -1884,7 +1884,7 @@ DrmAllocation *DrmMemoryManager::createUSMHostAllocationFromSharedHandle(osHandl
     auto &drm = this->getDrm(properties.rootDeviceIndex);
     auto patIndex = drm.getPatIndex(nullptr, properties.allocationType, CacheRegion::Default, CachePolicy::WriteBack, false);
 
-    auto ret = drm.ioctl(DRM_IOCTL_PRIME_FD_TO_HANDLE, &openFd);
+    auto ret = drm.ioctl(DrmIoctl::PrimeFdToHandle, &openFd);
     if (ret != 0) {
         int err = drm.getErrno();
         PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(PRIME_FD_TO_HANDLE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));

shared/source/os_interface/linux/drm_neo.cpp

@@ -70,131 +70,81 @@ std::string getIoctlParamString(int param) {
     }
 }
 
-std::string getIoctlString(unsigned long request) {
+std::string getIoctlString(DrmIoctl ioctlRequest) {
-    switch (request) {
+    switch (ioctlRequest) {
-    case DRM_IOCTL_I915_GEM_EXECBUFFER2:
+    case DrmIoctl::GemExecbuffer2:
         return "DRM_IOCTL_I915_GEM_EXECBUFFER2";
-    case DRM_IOCTL_I915_GEM_WAIT:
+    case DrmIoctl::GemWait:
         return "DRM_IOCTL_I915_GEM_WAIT";
-    case DRM_IOCTL_GEM_CLOSE:
+    case DrmIoctl::GemClose:
         return "DRM_IOCTL_GEM_CLOSE";
-    case DRM_IOCTL_I915_GEM_USERPTR:
+    case DrmIoctl::GemUserptr:
         return "DRM_IOCTL_I915_GEM_USERPTR";
-    case DRM_IOCTL_I915_INIT:
+    case DrmIoctl::Getparam:
-        return "DRM_IOCTL_I915_INIT";
-    case DRM_IOCTL_I915_FLUSH:
-        return "DRM_IOCTL_I915_FLUSH";
-    case DRM_IOCTL_I915_FLIP:
-        return "DRM_IOCTL_I915_FLIP";
-    case DRM_IOCTL_I915_BATCHBUFFER:
-        return "DRM_IOCTL_I915_BATCHBUFFER";
-    case DRM_IOCTL_I915_IRQ_EMIT:
-        return "DRM_IOCTL_I915_IRQ_EMIT";
-    case DRM_IOCTL_I915_IRQ_WAIT:
-        return "DRM_IOCTL_I915_IRQ_WAIT";
-    case DRM_IOCTL_I915_GETPARAM:
         return "DRM_IOCTL_I915_GETPARAM";
-    case DRM_IOCTL_I915_SETPARAM:
+    case DrmIoctl::GemCreate:
-        return "DRM_IOCTL_I915_SETPARAM";
-    case DRM_IOCTL_I915_ALLOC:
-        return "DRM_IOCTL_I915_ALLOC";
-    case DRM_IOCTL_I915_FREE:
-        return "DRM_IOCTL_I915_FREE";
-    case DRM_IOCTL_I915_INIT_HEAP:
-        return "DRM_IOCTL_I915_INIT_HEAP";
-    case DRM_IOCTL_I915_CMDBUFFER:
-        return "DRM_IOCTL_I915_CMDBUFFER";
-    case DRM_IOCTL_I915_DESTROY_HEAP:
-        return "DRM_IOCTL_I915_DESTROY_HEAP";
-    case DRM_IOCTL_I915_SET_VBLANK_PIPE:
-        return "DRM_IOCTL_I915_SET_VBLANK_PIPE";
-    case DRM_IOCTL_I915_GET_VBLANK_PIPE:
-        return "DRM_IOCTL_I915_GET_VBLANK_PIPE";
-    case DRM_IOCTL_I915_VBLANK_SWAP:
-        return "DRM_IOCTL_I915_VBLANK_SWAP";
-    case DRM_IOCTL_I915_HWS_ADDR:
-        return "DRM_IOCTL_I915_HWS_ADDR";
-    case DRM_IOCTL_I915_GEM_INIT:
-        return "DRM_IOCTL_I915_GEM_INIT";
-    case DRM_IOCTL_I915_GEM_EXECBUFFER:
-        return "DRM_IOCTL_I915_GEM_EXECBUFFER";
-    case DRM_IOCTL_I915_GEM_EXECBUFFER2_WR:
-        return "DRM_IOCTL_I915_GEM_EXECBUFFER2_WR";
-    case DRM_IOCTL_I915_GEM_PIN:
-        return "DRM_IOCTL_I915_GEM_PIN";
-    case DRM_IOCTL_I915_GEM_UNPIN:
-        return "DRM_IOCTL_I915_GEM_UNPIN";
-    case DRM_IOCTL_I915_GEM_BUSY:
-        return "DRM_IOCTL_I915_GEM_BUSY";
-    case DRM_IOCTL_I915_GEM_SET_CACHING:
-        return "DRM_IOCTL_I915_GEM_SET_CACHING";
-    case DRM_IOCTL_I915_GEM_GET_CACHING:
-        return "DRM_IOCTL_I915_GEM_GET_CACHING";
-    case DRM_IOCTL_I915_GEM_THROTTLE:
-        return "DRM_IOCTL_I915_GEM_THROTTLE";
-    case DRM_IOCTL_I915_GEM_ENTERVT:
-        return "DRM_IOCTL_I915_GEM_ENTERVT";
-    case DRM_IOCTL_I915_GEM_LEAVEVT:
-        return "DRM_IOCTL_I915_GEM_LEAVEVT";
-    case DRM_IOCTL_I915_GEM_CREATE:
         return "DRM_IOCTL_I915_GEM_CREATE";
-    case DRM_IOCTL_I915_GEM_PREAD:
+    case DrmIoctl::GemSetDomain:
-        return "DRM_IOCTL_I915_GEM_PREAD";
-    case DRM_IOCTL_I915_GEM_PWRITE:
-        return "DRM_IOCTL_I915_GEM_PWRITE";
-    case DRM_IOCTL_I915_GEM_SET_DOMAIN:
         return "DRM_IOCTL_I915_GEM_SET_DOMAIN";
-    case DRM_IOCTL_I915_GEM_SW_FINISH:
+    case DrmIoctl::GemSetTiling:
-        return "DRM_IOCTL_I915_GEM_SW_FINISH";
-    case DRM_IOCTL_I915_GEM_SET_TILING:
         return "DRM_IOCTL_I915_GEM_SET_TILING";
-    case DRM_IOCTL_I915_GEM_GET_TILING:
+    case DrmIoctl::GemGetTiling:
         return "DRM_IOCTL_I915_GEM_GET_TILING";
-    case DRM_IOCTL_I915_GEM_GET_APERTURE:
+    case DrmIoctl::GemContextCreateExt:
-        return "DRM_IOCTL_I915_GEM_GET_APERTURE";
-    case DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID:
-        return "DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID";
-    case DRM_IOCTL_I915_GEM_MADVISE:
-        return "DRM_IOCTL_I915_GEM_MADVISE";
-    case DRM_IOCTL_I915_OVERLAY_PUT_IMAGE:
-        return "DRM_IOCTL_I915_OVERLAY_PUT_IMAGE";
-    case DRM_IOCTL_I915_OVERLAY_ATTRS:
-        return "DRM_IOCTL_I915_OVERLAY_ATTRS";
-    case DRM_IOCTL_I915_SET_SPRITE_COLORKEY:
-        return "DRM_IOCTL_I915_SET_SPRITE_COLORKEY";
-    case DRM_IOCTL_I915_GET_SPRITE_COLORKEY:
-        return "DRM_IOCTL_I915_GET_SPRITE_COLORKEY";
-    case DRM_IOCTL_I915_GEM_CONTEXT_CREATE:
-        return "DRM_IOCTL_I915_GEM_CONTEXT_CREATE";
-    case DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT:
         return "DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT";
-    case DRM_IOCTL_I915_GEM_CONTEXT_DESTROY:
+    case DrmIoctl::GemContextDestroy:
         return "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY";
-    case DRM_IOCTL_I915_REG_READ:
+    case DrmIoctl::RegRead:
         return "DRM_IOCTL_I915_REG_READ";
-    case DRM_IOCTL_I915_GET_RESET_STATS:
+    case DrmIoctl::GetResetStats:
         return "DRM_IOCTL_I915_GET_RESET_STATS";
-    case DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM:
+    case DrmIoctl::GemContextGetparam:
         return "DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM";
-    case DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM:
+    case DrmIoctl::GemContextSetparam:
         return "DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM";
-    case DRM_IOCTL_I915_PERF_OPEN:
+    case DrmIoctl::Query:
-        return "DRM_IOCTL_I915_PERF_OPEN";
-    case DRM_IOCTL_I915_PERF_ADD_CONFIG:
-        return "DRM_IOCTL_I915_PERF_ADD_CONFIG";
-    case DRM_IOCTL_I915_PERF_REMOVE_CONFIG:
-        return "DRM_IOCTL_I915_PERF_REMOVE_CONFIG";
-    case DRM_IOCTL_I915_QUERY:
         return "DRM_IOCTL_I915_QUERY";
-    case DRM_IOCTL_I915_GEM_MMAP:
+    case DrmIoctl::GemMmap:
         return "DRM_IOCTL_I915_GEM_MMAP";
-    case DRM_IOCTL_PRIME_FD_TO_HANDLE:
+    case DrmIoctl::PrimeFdToHandle:
         return "DRM_IOCTL_PRIME_FD_TO_HANDLE";
-    case DRM_IOCTL_PRIME_HANDLE_TO_FD:
+    case DrmIoctl::PrimeHandleToFd:
         return "DRM_IOCTL_PRIME_HANDLE_TO_FD";
-    default:
+    case DrmIoctl::GemVmBind:
-        return getIoctlStringRemaining(request);
+        return "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND";
+    case DrmIoctl::GemVmUnbind:
+        return "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND";
+    case DrmIoctl::GemWaitUserFence:
+        return "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE";
+    case DrmIoctl::GemCreateExt:
+        return "DRM_IOCTL_I915_GEM_CREATE_EXT";
+    case DrmIoctl::DG1GemCreateExt:
+        return "DG1_DRM_IOCTL_I915_GEM_CREATE_EXT";
+    case DrmIoctl::GemVmAdvise:
+        return "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE";
+    case DrmIoctl::GemVmPrefetch:
+        return "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH";
+    case DrmIoctl::UuidRegister:
+        return "PRELIM_DRM_IOCTL_I915_UUID_REGISTER";
+    case DrmIoctl::UuidUnregister:
+        return "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER";
+    case DrmIoctl::DebuggerOpen:
+        return "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN";
+    case DrmIoctl::GemClosReserve:
+        return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE";
+    case DrmIoctl::GemClosFree:
+        return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE";
+    case DrmIoctl::GemCacheReserve:
+        return "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE";
+    case DrmIoctl::GemMmapOffset:
+        return "DRM_IOCTL_I915_GEM_MMAP_OFFSET";
+    case DrmIoctl::GemVmCreate:
+        return "DRM_IOCTL_I915_GEM_VM_CREATE";
+    case DrmIoctl::GemVmDestroy:
+        return "DRM_IOCTL_I915_GEM_VM_DESTROY";
     }
+    UNRECOVERABLE_IF(true);
+    return "";
 }
 
 } // namespace IoctlToStringHelper
@@ -212,7 +162,8 @@ void Drm::queryAndSetVmBindPatIndexProgrammingSupport() {
     this->vmBindPatIndexProgrammingSupported = HwInfoConfig::get(hwInfo->platform.eProductFamily)->isVmBindPatIndexProgrammingSupported();
 }
 
-int Drm::ioctl(unsigned long request, void *arg) {
+int Drm::ioctl(DrmIoctl request, void *arg) {
+    auto requestValue = getIoctlRequestValue(request, ioctlHelper.get());
     int ret;
     int returnedErrno;
     SYSTEM_ENTER();
@@ -230,7 +181,7 @@ int Drm::ioctl(unsigned long request, void *arg) {
         if (measureTime) {
             start = std::chrono::steady_clock::now();
         }
-        ret = SysCalls::ioctl(getFileDescriptor(), request, arg);
+        ret = SysCalls::ioctl(getFileDescriptor(), requestValue, arg);
 
         returnedErrno = errno;
 
@@ -272,7 +223,7 @@ int Drm::getParamIoctl(int param, int *dstValue) {
     getParam.param = param;
     getParam.value = dstValue;
 
-    int retVal = ioctl(DRM_IOCTL_I915_GETPARAM, &getParam);
+    int retVal = ioctl(DrmIoctl::Getparam, &getParam);
     if (DebugManager.flags.PrintIoctlEntries.get()) {
         printf("DRM_IOCTL_I915_GETPARAM: param: %s, output value: %d, retCode:% d\n",
                IoctlToStringHelper::getIoctlParamString(param).c_str(),
@@ -299,7 +250,7 @@ int Drm::enableTurboBoost() {
 
     contextParam.param = I915_CONTEXT_PRIVATE_PARAM_BOOST;
     contextParam.value = 1;
-    return ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &contextParam);
+    return ioctl(DrmIoctl::GemContextSetparam, &contextParam);
 }
 
 int Drm::getEnabledPooledEu(int &enabled) {
@@ -322,7 +273,7 @@ int Drm::queryGttSize(uint64_t &gttSizeOutput) {
     GemContextParam contextParam = {0};
     contextParam.param = I915_CONTEXT_PARAM_GTT_SIZE;
 
-    int ret = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &contextParam);
+    int ret = ioctl(DrmIoctl::GemContextGetparam, &contextParam);
     if (ret == 0) {
         gttSizeOutput = contextParam.value;
     }
@@ -338,7 +289,7 @@ bool Drm::isGpuHangDetected(OsContext &osContext) {
         ResetStats resetStats{};
         resetStats.contextId = drmContextId;
 
-        const auto retVal{ioctl(DRM_IOCTL_I915_GET_RESET_STATS, &resetStats)};
+        const auto retVal{ioctl(DrmIoctl::GetResetStats, &resetStats)};
         UNRECOVERABLE_IF(retVal != 0);
 
         if (resetStats.batchActive > 0 || resetStats.batchPending > 0) {
@@ -366,7 +317,7 @@ void Drm::setLowPriorityContextParam(uint32_t drmContextId) {
     gcp.param = I915_CONTEXT_PARAM_PRIORITY;
     gcp.value = -1023;
 
-    auto retVal = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &gcp);
+    auto retVal = ioctl(DrmIoctl::GemContextSetparam, &gcp);
     UNRECOVERABLE_IF(retVal != 0);
 }
 
@@ -378,7 +329,7 @@ int Drm::getQueueSliceCount(GemContextParamSseu *sseu) {
     contextParam.value = reinterpret_cast<uint64_t>(sseu);
     contextParam.size = sizeof(struct GemContextParamSseu);
 
-    return ioctl(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &contextParam);
+    return ioctl(DrmIoctl::GemContextGetparam, &contextParam);
 }
 
 uint64_t Drm::getSliceMask(uint64_t sliceCount) {
@@ -393,7 +344,7 @@ bool Drm::setQueueSliceCount(uint64_t sliceCount) {
         contextParam.contextId = 0;
         contextParam.value = reinterpret_cast<uint64_t>(&sseu);
         contextParam.size = sizeof(struct GemContextParamSseu);
-        int retVal = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &contextParam);
+        int retVal = ioctl(DrmIoctl::GemContextSetparam, &contextParam);
         if (retVal == 0) {
             return true;
         }
@@ -405,7 +356,7 @@ void Drm::checkNonPersistentContextsSupport() {
     GemContextParam contextParam = {};
     contextParam.param = I915_CONTEXT_PARAM_PERSISTENCE;
 
-    auto retVal = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &contextParam);
+    auto retVal = ioctl(DrmIoctl::GemContextGetparam, &contextParam);
     if (retVal == 0 && contextParam.value == 1) {
         nonPersistentContextsSupported = true;
     } else {
@@ -418,7 +369,7 @@ void Drm::setNonPersistentContext(uint32_t drmContextId) {
     contextParam.contextId = drmContextId;
     contextParam.param = I915_CONTEXT_PARAM_PERSISTENCE;
 
-    ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &contextParam);
+    ioctl(DrmIoctl::GemContextSetparam, &contextParam);
 }
 
 void Drm::setUnrecoverableContext(uint32_t drmContextId) {
@@ -428,7 +379,7 @@ void Drm::setUnrecoverableContext(uint32_t drmContextId) {
     contextParam.value = 0;
     contextParam.size = 0;
 
-    ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &contextParam);
+    ioctl(DrmIoctl::GemContextSetparam, &contextParam);
 }
 
 uint32_t Drm::createDrmContext(uint32_t drmVmId, bool isDirectSubmissionRequested, bool isCooperativeContextRequested) {
@@ -461,7 +412,7 @@ uint32_t Drm::createDrmContext(uint32_t drmVmId, bool isDirectSubmissionRequeste
     if (isCooperativeContextRequested) {
         return ioctlHelper->createCooperativeContext(this, gcc);
     }
-    auto ioctlResult = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, &gcc);
+    auto ioctlResult = ioctl(DrmIoctl::GemContextCreateExt, &gcc);
 
     UNRECOVERABLE_IF(ioctlResult != 0);
     return gcc.contextId;
@@ -470,14 +421,14 @@ uint32_t Drm::createDrmContext(uint32_t drmVmId, bool isDirectSubmissionRequeste
 void Drm::destroyDrmContext(uint32_t drmContextId) {
     GemContextDestroy destroy{};
     destroy.contextId = drmContextId;
-    auto retVal = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY, &destroy);
+    auto retVal = ioctl(DrmIoctl::GemContextDestroy, &destroy);
     UNRECOVERABLE_IF(retVal != 0);
 }
 
 void Drm::destroyDrmVirtualMemory(uint32_t drmVmId) {
     GemVmControl ctl = {};
     ctl.vmId = drmVmId;
-    auto ret = SysCalls::ioctl(getFileDescriptor(), DRM_IOCTL_I915_GEM_VM_DESTROY, &ctl);
+    auto ret = SysCalls::ioctl(getFileDescriptor(), ioctlHelper->getIoctlRequestValue(DrmIoctl::GemVmDestroy), &ctl);
     UNRECOVERABLE_IF(ret != 0);
 }
 
@@ -486,7 +437,7 @@ int Drm::queryVmId(uint32_t drmContextId, uint32_t &vmId) {
     param.contextId = drmContextId;
     param.value = 0;
     param.param = I915_CONTEXT_PARAM_VM;
-    auto retVal = this->ioctl(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &param);
+    auto retVal = this->ioctl(DrmIoctl::GemContextGetparam, &param);
 
     vmId = static_cast<uint32_t>(param.value);
 
@@ -682,7 +633,7 @@ std::vector<uint8_t> Drm::query(uint32_t queryId, uint32_t queryItemFlags) {
     query.itemsPtr = reinterpret_cast<uint64_t>(&queryItem);
     query.numItems = 1;
 
-    auto ret = this->ioctl(DRM_IOCTL_I915_QUERY, &query);
+    auto ret = this->ioctl(DrmIoctl::Query, &query);
     if (ret != 0 || queryItem.length <= 0) {
         return {};
     }
@@ -690,7 +641,7 @@ std::vector<uint8_t> Drm::query(uint32_t queryId, uint32_t queryItemFlags) {
     auto data = std::vector<uint8_t>(queryItem.length, 0);
     queryItem.dataPtr = castToUint64(data.data());
 
-    ret = this->ioctl(DRM_IOCTL_I915_QUERY, &query);
+    ret = this->ioctl(DrmIoctl::Query, &query);
     if (ret != 0 || queryItem.length <= 0) {
         return {};
     }
@@ -878,7 +829,7 @@ int Drm::waitHandle(uint32_t waitHandle, int64_t timeout) {
     wait.boHandle = waitHandle;
     wait.timeoutNs = timeout;
 
-    int ret = ioctl(DRM_IOCTL_I915_GEM_WAIT, &wait);
+    int ret = ioctl(DrmIoctl::GemWait, &wait);
     if (ret != 0) {
         int err = errno;
         PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(I915_GEM_WAIT) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@@ -1322,7 +1273,7 @@ unsigned int Drm::bindDrmContext(uint32_t drmContextId, uint32_t deviceIndex, au
     param.param = I915_CONTEXT_PARAM_ENGINES;
     param.value = castToUint64(&contextEngines);
 
-    auto retVal = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &param);
+    auto retVal = ioctl(DrmIoctl::GemContextSetparam, &param);
     UNRECOVERABLE_IF(retVal != 0);
 
     return I915_EXEC_DEFAULT;
@@ -1527,7 +1478,7 @@ int Drm::createDrmVirtualMemory(uint32_t &drmVmId) {
 
     ctl.flags = ioctlHelper->getFlagsForVmCreate(disableScratch, enablePageFault, useVmBind);
 
-    auto ret = SysCalls::ioctl(getFileDescriptor(), DRM_IOCTL_I915_GEM_VM_CREATE, &ctl);
+    auto ret = SysCalls::ioctl(getFileDescriptor(), ioctlHelper->getIoctlRequestValue(DrmIoctl::GemVmCreate), &ctl);
 
     if (ret == 0) {
         drmVmId = ctl.vmId;

shared/source/os_interface/linux/drm_neo.h

@@ -80,7 +80,7 @@ class Drm : public DriverModel {
 
     ~Drm() override;
 
-    virtual int ioctl(unsigned long request, void *arg);
+    virtual int ioctl(DrmIoctl request, void *arg);
 
     int getDeviceID(int &devId);
     unsigned int getDeviceHandle() const override {
@@ -306,7 +306,7 @@ class Drm : public DriverModel {
         long long minTime = std::numeric_limits<long long>::max();
         long long maxTime = 0;
     };
-    std::unordered_map<unsigned long, IoctlStatisticsEntry> ioctlStatistics;
+    std::unordered_map<DrmIoctl, IoctlStatisticsEntry> ioctlStatistics;
 
     std::mutex bindFenceMutex;
     std::array<uint64_t, EngineLimits::maxHandleCount> pagingFence;

shared/source/os_interface/linux/drm_null_device.h

@@ -20,10 +20,10 @@ namespace NEO {
 class DrmNullDevice : public Drm {
 
   public:
-    int ioctl(unsigned long request, void *arg) override {
+    int ioctl(DrmIoctl request, void *arg) override {
-        if (request == DRM_IOCTL_I915_GETPARAM || request == DRM_IOCTL_I915_QUERY) {
+        if (request == DrmIoctl::Getparam || request == DrmIoctl::Query) {
             return Drm::ioctl(request, arg);
-        } else if (request == DRM_IOCTL_I915_REG_READ) {
+        } else if (request == DrmIoctl::RegRead) {
             auto *regArg = static_cast<RegisterRead *>(arg);
             // Handle only 36b timestamp
             if (regArg->offset == (REG_GLOBAL_TIMESTAMP_LDW | 1)) {

shared/source/os_interface/linux/drm_wrappers.cpp

@@ -7,6 +7,8 @@
 
 #include "shared/source/os_interface/linux/drm_wrappers.h"
 
+#include "shared/source/os_interface/linux/ioctl_helper.h"
+
 #include "drm/i915_drm.h"
 
 #include <cstddef>
@@ -170,4 +172,13 @@ static_assert(offsetof(DrmVersion, date) == offsetof(drm_version, date));
 static_assert(offsetof(DrmVersion, descLen) == offsetof(drm_version, desc_len));
 static_assert(offsetof(DrmVersion, desc) == offsetof(drm_version, desc));
 
+unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest, IoctlHelper *ioctlHelper) {
+    switch (ioctlRequest) {
+    case DrmIoctl::Getparam:
+        return DRM_IOCTL_I915_GETPARAM;
+    default:
+        UNRECOVERABLE_IF(!ioctlHelper);
+        return ioctlHelper->getIoctlRequestValue(ioctlRequest);
+    }
+}
 } // namespace NEO

shared/source/os_interface/linux/drm_wrappers.h

@@ -9,6 +9,7 @@
 #include <cstddef>
 #include <cstdint>
 namespace NEO {
+class IoctlHelper;
 
 struct RegisterRead {
     uint64_t offset;
@@ -196,4 +197,44 @@ struct DrmVersion {
     size_t descLen;
     char *desc;
 };
+
+enum class DrmIoctl {
+    GemExecbuffer2,
+    GemWait,
+    GemUserptr,
+    Getparam,
+    GemCreate,
+    GemSetDomain,
+    GemSetTiling,
+    GemGetTiling,
+    GemContextCreateExt,
+    GemContextDestroy,
+    RegRead,
+    GetResetStats,
+    GemContextGetparam,
+    GemContextSetparam,
+    Query,
+    GemMmap,
+    GemMmapOffset,
+    GemVmCreate,
+    GemVmDestroy,
+    GemClose,
+    PrimeFdToHandle,
+    PrimeHandleToFd,
+    GemVmBind,
+    GemVmUnbind,
+    GemWaitUserFence,
+    DG1GemCreateExt,
+    GemCreateExt,
+    GemVmAdvise,
+    GemVmPrefetch,
+    UuidRegister,
+    UuidUnregister,
+    DebuggerOpen,
+    GemClosReserve,
+    GemClosFree,
+    GemCacheReserve,
+};
+
+unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest, IoctlHelper *ioctlHelper);
 } // namespace NEO

shared/source/os_interface/linux/ioctl_helper.cpp

@@ -18,7 +18,7 @@
 
 namespace NEO {
 
-uint32_t IoctlHelper::ioctl(Drm *drm, unsigned long request, void *arg) {
+uint32_t IoctlHelper::ioctl(Drm *drm, DrmIoctl request, void *arg) {
     return drm->ioctl(request, arg);
 }
 

shared/source/os_interface/linux/ioctl_helper.h

@@ -66,7 +66,7 @@ class IoctlHelper {
   public:
     virtual ~IoctlHelper() {}
     static IoctlHelper *get(const PRODUCT_FAMILY productFamily, const std::string &prelimVersion, const std::string &drmVersion);
-    static uint32_t ioctl(Drm *drm, unsigned long request, void *arg);
+    static uint32_t ioctl(Drm *drm, DrmIoctl request, void *arg);
     virtual IoctlHelper *clone() = 0;
 
     virtual bool isVmBindAvailable(Drm *drm) = 0;
@@ -114,6 +114,7 @@ class IoctlHelper {
     virtual bool isContextDebugSupported(Drm *drm) = 0;
     virtual int setContextDebugFlag(Drm *drm, uint32_t drmContextId) = 0;
     virtual bool isDebugAttachAvailable() = 0;
+    virtual unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) = 0;
 
     void fillExecObject(ExecObject &execObject, uint32_t handle, uint64_t gpuAddress, uint32_t drmContextId, bool bindInfo, bool isMarkedForCapture);
     void logExecObject(const ExecObject &execObject, std::stringstream &logger, size_t size);
@@ -171,6 +172,7 @@ class IoctlHelperUpstream : public IoctlHelper {
     bool isContextDebugSupported(Drm *drm) override;
     int setContextDebugFlag(Drm *drm, uint32_t drmContextId) override;
     bool isDebugAttachAvailable() override;
+    unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) override;
 };
 
 template <PRODUCT_FAMILY gfxProduct>
@@ -184,6 +186,7 @@ class IoctlHelperImpl : public IoctlHelperUpstream {
 
     uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) override;
     std::vector<MemoryRegion> translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) override;
+    unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) override;
 };
 
 class IoctlHelperPrelim20 : public IoctlHelper {
@@ -235,6 +238,7 @@ class IoctlHelperPrelim20 : public IoctlHelper {
     bool isContextDebugSupported(Drm *drm) override;
     int setContextDebugFlag(Drm *drm, uint32_t drmContextId) override;
     bool isDebugAttachAvailable() override;
+    unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) override;
 };
 
 } // namespace NEO

shared/source/os_interface/linux/ioctl_helper_prelim.cpp

@@ -33,7 +33,7 @@ bool IoctlHelperPrelim20::isVmBindAvailable(Drm *drm) {
     GetParam getParam{};
     getParam.param = PRELIM_I915_PARAM_HAS_VM_BIND;
     getParam.value = &vmBindSupported;
-    int retVal = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GETPARAM, &getParam);
+    int retVal = IoctlHelper::ioctl(drm, DrmIoctl::Getparam, &getParam);
     if (retVal) {
         return false;
     }
@@ -72,7 +72,7 @@ uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, const MemRegionsVec &memCla
         printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "%s", " }\n");
     }
 
-    auto ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT, &createExt);
+    auto ret = IoctlHelper::ioctl(drm, DrmIoctl::GemCreateExt, &createExt);
 
     printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "GEM_CREATE_EXT has returned: %d BO-%u with size: %lu\n", ret, createExt.handle, createExt.size);
     handle = createExt.handle;
@@ -94,7 +94,7 @@ std::vector<MemoryRegion> IoctlHelperPrelim20::translateToMemoryRegions(const st
 CacheRegion IoctlHelperPrelim20::closAlloc(Drm *drm) {
     struct prelim_drm_i915_gem_clos_reserve clos = {};
 
-    int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE, &clos);
+    int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemClosReserve, &clos);
     if (ret != 0) {
         int err = errno;
         printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(I915_GEM_CLOS_RESERVE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@@ -112,7 +112,7 @@ uint16_t IoctlHelperPrelim20::closAllocWays(Drm *drm, CacheRegion closIndex, uin
     cache.cache_level = cacheLevel;
     cache.num_ways = numWays;
 
-    int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE, &cache);
+    int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemCacheReserve, &cache);
     if (ret != 0) {
         int err = errno;
         PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(I915_GEM_CACHE_RESERVE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@@ -127,7 +127,7 @@ CacheRegion IoctlHelperPrelim20::closFree(Drm *drm, CacheRegion closIndex) {
 
     clos.clos_index = static_cast<uint16_t>(closIndex);
 
-    int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE, &clos);
+    int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemClosFree, &clos);
     if (ret != 0) {
         int err = errno;
         printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(I915_GEM_CLOS_FREE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@@ -165,7 +165,7 @@ int IoctlHelperPrelim20::waitUserFence(Drm *drm, uint32_t ctxId, uint64_t addres
     wait.value = value;
     wait.timeout = timeout;
 
-    return IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE, &wait);
+    return IoctlHelper::ioctl(drm, DrmIoctl::GemWaitUserFence, &wait);
 }
 
 uint32_t IoctlHelperPrelim20::getHwConfigIoctlVal() {
@@ -189,7 +189,7 @@ bool IoctlHelperPrelim20::setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attri
         vmAdvise.region = *reinterpret_cast<prelim_drm_i915_gem_memory_class_instance *>(region);
     }
 
-    int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE, &vmAdvise);
+    int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemVmAdvise, &vmAdvise);
     if (ret != 0) {
         int err = errno;
         PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(PRELIM_DRM_I915_GEM_VM_ADVISE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@@ -206,7 +206,7 @@ bool IoctlHelperPrelim20::setVmPrefetch(Drm *drm, uint64_t start, uint64_t lengt
     vmPrefetch.region = region;
     vmPrefetch.start = start;
 
-    int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH, &vmPrefetch);
+    int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemVmPrefetch, &vmPrefetch);
     if (ret != 0) {
         int err = errno;
         PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(PRELIM_DRM_I915_GEM_VM_PREFETCH) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@@ -249,7 +249,7 @@ int IoctlHelperPrelim20::execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t c
         drmExecBuffer.cliprects_ptr = castToUint64(&fenceObject);
     }
 
-    return IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_EXECBUFFER2, execBuffer);
+    return IoctlHelper::ioctl(drm, DrmIoctl::GemExecbuffer2, execBuffer);
 }
 
 bool IoctlHelperPrelim20::completionFenceExtensionSupported(const bool isVmBindAvailable) {
@@ -324,7 +324,7 @@ uint32_t IoctlHelperPrelim20::queryDistances(Drm *drm, std::vector<QueryItem> &q
     Query query{};
     query.itemsPtr = reinterpret_cast<__u64>(queryItems.data());
     query.numItems = static_cast<uint32_t>(queryItems.size());
-    auto ret = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_QUERY, &query);
+    auto ret = IoctlHelper::ioctl(drm, DrmIoctl::Query, &query);
     for (auto i = 0u; i < i915Distances.size(); i++) {
         distanceInfos[i].distance = i915Distances[i].distance;
     }
@@ -397,7 +397,7 @@ uint32_t gemCreateContextExt(Drm *drm, GemContextCreateExt &gcc, GemContextCreat
     extSetparam.base.nextExtension = gcc.extensions;
     gcc.extensions = reinterpret_cast<uint64_t>(&extSetparam);
 
-    auto ioctlResult = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, &gcc);
+    auto ioctlResult = IoctlHelper::ioctl(drm, DrmIoctl::GemContextCreateExt, &gcc);
     UNRECOVERABLE_IF(ioctlResult != 0);
     return gcc.contextId;
 }
@@ -496,12 +496,12 @@ prelim_drm_i915_gem_vm_bind translateVmBindParamsToPrelimStruct(const VmBindPara
 
 int IoctlHelperPrelim20::vmBind(Drm *drm, const VmBindParams &vmBindParams) {
     auto prelimVmBind = translateVmBindParamsToPrelimStruct(vmBindParams);
-    return IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_VM_BIND, &prelimVmBind);
+    return IoctlHelper::ioctl(drm, DrmIoctl::GemVmBind, &prelimVmBind);
 }
 
 int IoctlHelperPrelim20::vmUnbind(Drm *drm, const VmBindParams &vmBindParams) {
     auto prelimVmBind = translateVmBindParamsToPrelimStruct(vmBindParams);
-    return IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND, &prelimVmBind);
+    return IoctlHelper::ioctl(drm, DrmIoctl::GemVmUnbind, &prelimVmBind);
 }
 
 UuidRegisterResult IoctlHelperPrelim20::registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) {
@@ -511,7 +511,7 @@ UuidRegisterResult IoctlHelperPrelim20::registerUuid(Drm *drm, const std::string
     uuidControl.ptr = ptr;
     uuidControl.size = size;
 
-    const auto retVal = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_UUID_REGISTER, &uuidControl);
+    const auto retVal = IoctlHelper::ioctl(drm, DrmIoctl::UuidRegister, &uuidControl);
 
     return {
         retVal,
@@ -527,7 +527,7 @@ int IoctlHelperPrelim20::unregisterUuid(Drm *drm, uint32_t handle) {
     prelim_drm_i915_uuid_control uuidControl = {};
     uuidControl.handle = handle;
 
-    return IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER, &uuidControl);
+    return IoctlHelper::ioctl(drm, DrmIoctl::UuidUnregister, &uuidControl);
 }
 
 bool IoctlHelperPrelim20::isContextDebugSupported(Drm *drm) {
@@ -537,7 +537,7 @@ bool IoctlHelperPrelim20::isContextDebugSupported(Drm *drm) {
     ctxParam.ctx_id = 0;
     ctxParam.value = 0;
 
-    const auto retVal = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &ctxParam);
+    const auto retVal = IoctlHelper::ioctl(drm, DrmIoctl::GemContextGetparam, &ctxParam);
     return retVal == 0 && ctxParam.value == (PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP << 32);
 }
 
@@ -548,13 +548,87 @@ int IoctlHelperPrelim20::setContextDebugFlag(Drm *drm, uint32_t drmContextId) {
     ctxParam.ctx_id = drmContextId;
     ctxParam.value = PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP << 32 | PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP;
 
-    return IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &ctxParam);
+    return IoctlHelper::ioctl(drm, DrmIoctl::GemContextSetparam, &ctxParam);
 }
 
 bool IoctlHelperPrelim20::isDebugAttachAvailable() {
     return true;
 }
 
+unsigned int IoctlHelperPrelim20::getIoctlRequestValue(DrmIoctl ioctlRequest) {
+    switch (ioctlRequest) {
+    case DrmIoctl::GemExecbuffer2:
+        return DRM_IOCTL_I915_GEM_EXECBUFFER2;
+    case DrmIoctl::GemWait:
+        return DRM_IOCTL_I915_GEM_WAIT;
+    case DrmIoctl::GemClose:
+        return DRM_IOCTL_GEM_CLOSE;
+    case DrmIoctl::GemUserptr:
+        return DRM_IOCTL_I915_GEM_USERPTR;
+    case DrmIoctl::GemCreate:
+        return DRM_IOCTL_I915_GEM_CREATE;
+    case DrmIoctl::GemSetDomain:
+        return DRM_IOCTL_I915_GEM_SET_DOMAIN;
+    case DrmIoctl::GemSetTiling:
+        return DRM_IOCTL_I915_GEM_SET_TILING;
+    case DrmIoctl::GemGetTiling:
+        return DRM_IOCTL_I915_GEM_GET_TILING;
+    case DrmIoctl::GemContextCreateExt:
+        return DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT;
+    case DrmIoctl::GemContextDestroy:
+        return DRM_IOCTL_I915_GEM_CONTEXT_DESTROY;
+    case DrmIoctl::RegRead:
+        return DRM_IOCTL_I915_REG_READ;
+    case DrmIoctl::GetResetStats:
+        return DRM_IOCTL_I915_GET_RESET_STATS;
+    case DrmIoctl::GemContextGetparam:
+        return DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM;
+    case DrmIoctl::GemContextSetparam:
+        return DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM;
+    case DrmIoctl::Query:
+        return DRM_IOCTL_I915_QUERY;
+    case DrmIoctl::GemMmap:
+        return DRM_IOCTL_I915_GEM_MMAP;
+    case DrmIoctl::PrimeFdToHandle:
+        return DRM_IOCTL_PRIME_FD_TO_HANDLE;
+    case DrmIoctl::PrimeHandleToFd:
+        return DRM_IOCTL_PRIME_HANDLE_TO_FD;
+    case DrmIoctl::GemVmBind:
+        return PRELIM_DRM_IOCTL_I915_GEM_VM_BIND;
+    case DrmIoctl::GemVmUnbind:
+        return PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND;
+    case DrmIoctl::GemWaitUserFence:
+        return PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE;
+    case DrmIoctl::GemCreateExt:
+        return PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT;
+    case DrmIoctl::GemVmAdvise:
+        return PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE;
+    case DrmIoctl::GemVmPrefetch:
+        return PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH;
+    case DrmIoctl::UuidRegister:
+        return PRELIM_DRM_IOCTL_I915_UUID_REGISTER;
+    case DrmIoctl::UuidUnregister:
+        return PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER;
+    case DrmIoctl::DebuggerOpen:
+        return PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN;
+    case DrmIoctl::GemClosReserve:
+        return PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE;
+    case DrmIoctl::GemClosFree:
+        return PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE;
+    case DrmIoctl::GemCacheReserve:
+        return PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE;
+    case DrmIoctl::GemMmapOffset:
+        return DRM_IOCTL_I915_GEM_MMAP_OFFSET;
+    case DrmIoctl::GemVmCreate:
+        return DRM_IOCTL_I915_GEM_VM_CREATE;
+    case DrmIoctl::GemVmDestroy:
+        return DRM_IOCTL_I915_GEM_VM_DESTROY;
+    default:
+        UNRECOVERABLE_IF(true);
+        return 0u;
+    }
+}
+
 static_assert(sizeof(MemoryClassInstance) == sizeof(prelim_drm_i915_gem_memory_class_instance));
 static_assert(offsetof(MemoryClassInstance, memoryClass) == offsetof(prelim_drm_i915_gem_memory_class_instance, memory_class));
 static_assert(offsetof(MemoryClassInstance, memoryInstance) == offsetof(prelim_drm_i915_gem_memory_class_instance, memory_instance));

shared/source/os_interface/linux/ioctl_helper_upstream.cpp

@@ -51,7 +51,7 @@ uint32_t IoctlHelperUpstream::createGemExt(Drm *drm, const MemRegionsVec &memCla
         printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "%s", " }\n");
     }
 
-    auto ret = ioctl(drm, DRM_IOCTL_I915_GEM_CREATE_EXT, &createExt);
+    auto ret = ioctl(drm, DrmIoctl::GemCreateExt, &createExt);
 
     printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "GEM_CREATE_EXT with EXT_MEMORY_REGIONS has returned: %d BO-%u with size: %lu\n", ret, createExt.handle, createExt.size);
     handle = createExt.handle;
@@ -161,7 +161,7 @@ uint16_t IoctlHelperUpstream::getWaitUserFenceSoftFlag() {
 }
 
 int IoctlHelperUpstream::execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) {
-    return ioctl(drm, DRM_IOCTL_I915_GEM_EXECBUFFER2, execBuffer);
+    return ioctl(drm, DrmIoctl::GemExecbuffer2, execBuffer);
 }
 
 bool IoctlHelperUpstream::completionFenceExtensionSupported(const bool isVmBindAvailable) {
@@ -244,4 +244,55 @@ bool IoctlHelperUpstream::isDebugAttachAvailable() {
     return false;
 }
 
+unsigned int IoctlHelperUpstream::getIoctlRequestValue(DrmIoctl ioctlRequest) {
+    switch (ioctlRequest) {
+    case DrmIoctl::GemExecbuffer2:
+        return DRM_IOCTL_I915_GEM_EXECBUFFER2;
+    case DrmIoctl::GemWait:
+        return DRM_IOCTL_I915_GEM_WAIT;
+    case DrmIoctl::GemClose:
+        return DRM_IOCTL_GEM_CLOSE;
+    case DrmIoctl::GemUserptr:
+        return DRM_IOCTL_I915_GEM_USERPTR;
+    case DrmIoctl::GemCreate:
+        return DRM_IOCTL_I915_GEM_CREATE;
+    case DrmIoctl::GemCreateExt:
+        return DRM_IOCTL_I915_GEM_CREATE_EXT;
+    case DrmIoctl::GemSetDomain:
+        return DRM_IOCTL_I915_GEM_SET_DOMAIN;
+    case DrmIoctl::GemSetTiling:
+        return DRM_IOCTL_I915_GEM_SET_TILING;
+    case DrmIoctl::GemGetTiling:
+        return DRM_IOCTL_I915_GEM_GET_TILING;
+    case DrmIoctl::GemContextCreateExt:
+        return DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT;
+    case DrmIoctl::GemContextDestroy:
+        return DRM_IOCTL_I915_GEM_CONTEXT_DESTROY;
+    case DrmIoctl::RegRead:
+        return DRM_IOCTL_I915_REG_READ;
+    case DrmIoctl::GetResetStats:
+        return DRM_IOCTL_I915_GET_RESET_STATS;
+    case DrmIoctl::GemContextGetparam:
+        return DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM;
+    case DrmIoctl::GemContextSetparam:
+        return DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM;
+    case DrmIoctl::Query:
+        return DRM_IOCTL_I915_QUERY;
+    case DrmIoctl::GemMmap:
+        return DRM_IOCTL_I915_GEM_MMAP;
+    case DrmIoctl::PrimeFdToHandle:
+        return DRM_IOCTL_PRIME_FD_TO_HANDLE;
+    case DrmIoctl::PrimeHandleToFd:
+        return DRM_IOCTL_PRIME_HANDLE_TO_FD;
+    case DrmIoctl::GemMmapOffset:
+        return DRM_IOCTL_I915_GEM_MMAP_OFFSET;
+    case DrmIoctl::GemVmCreate:
+        return DRM_IOCTL_I915_GEM_VM_CREATE;
+    case DrmIoctl::GemVmDestroy:
+        return DRM_IOCTL_I915_GEM_VM_DESTROY;
+    default:
+        UNRECOVERABLE_IF(true);
+        return 0u;
+    }
+}
 } // namespace NEO

shared/source/os_interface/linux/ioctl_strings.h

@@ -7,13 +7,14 @@
 
 #pragma once
 
+#include "shared/source/os_interface/linux/drm_wrappers.h"
+
 #include <string>
 
 namespace NEO {
 namespace IoctlToStringHelper {
 std::string getIoctlParamString(int param);
 std::string getIoctlParamStringRemaining(int param);
-std::string getIoctlString(unsigned long request);
+std::string getIoctlString(DrmIoctl ioctlRequest);
-std::string getIoctlStringRemaining(unsigned long request);
 } // namespace IoctlToStringHelper
 } // namespace NEO

shared/source/os_interface/linux/ioctl_strings_prelim.cpp

@@ -13,45 +13,6 @@
 namespace NEO {
 
 namespace IoctlToStringHelper {
-std::string getIoctlStringRemaining(unsigned long request) {
-    switch (request) {
-    case PRELIM_DRM_IOCTL_I915_GEM_VM_BIND:
-        return "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND";
-    case PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND:
-        return "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND";
-    case PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE:
-        return "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE";
-    case PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT:
-        return "PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT";
-    case PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE:
-        return "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE";
-    case PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH:
-        return "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH";
-    case PRELIM_DRM_IOCTL_I915_UUID_REGISTER:
-        return "PRELIM_DRM_IOCTL_I915_UUID_REGISTER";
-    case PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER:
-        return "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER";
-    case PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN:
-        return "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN";
-    case PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE:
-        return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE";
-    case PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE:
-        return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE";
-    case PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE:
-        return "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE";
-    case DRM_IOCTL_I915_GEM_MMAP_GTT:
-        return "DRM_IOCTL_I915_GEM_MMAP_GTT";
-    case DRM_IOCTL_I915_GEM_MMAP_OFFSET:
-        return "DRM_IOCTL_I915_GEM_MMAP_OFFSET";
-    case DRM_IOCTL_I915_GEM_VM_CREATE:
-        return "DRM_IOCTL_I915_GEM_VM_CREATE";
-    case DRM_IOCTL_I915_GEM_VM_DESTROY:
-        return "DRM_IOCTL_I915_GEM_VM_DESTROY";
-    default:
-        return std::to_string(request);
-    }
-}
-
 std::string getIoctlParamStringRemaining(int param) {
     switch (param) {
     case PRELIM_I915_PARAM_HAS_VM_BIND:

shared/source/os_interface/linux/ioctl_strings_upstream.cpp

@@ -10,10 +10,6 @@
 namespace NEO {
 
 namespace IoctlToStringHelper {
-std::string getIoctlStringRemaining(unsigned long request) {
-    return std::to_string(request);
-}
-
 std::string getIoctlParamStringRemaining(int param) {
     return std::to_string(param);
 }

shared/source/os_interface/linux/local/dg1/ioctl_helper_dg1.cpp

@@ -50,7 +50,7 @@ uint32_t IoctlHelperImpl<gfxProduct>::createGemExt(Drm *drm, const MemRegionsVec
     createExt.size = allocSize;
     createExt.extensions = reinterpret_cast<uintptr_t>(&setparamRegion);
 
-    ret = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CREATE_EXT, &createExt);
+    ret = IoctlHelper::ioctl(drm, DrmIoctl::DG1GemCreateExt, &createExt);
 
     handle = createExt.handle;
     printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "GEM_CREATE_EXT with EXT_SETPARAM has returned: %d BO-%u with size: %lu\n", ret, createExt.handle, createExt.size);
@@ -66,5 +66,15 @@ std::vector<MemoryRegion> IoctlHelperImpl<gfxProduct>::translateToMemoryRegions(
     return IoctlHelperUpstream::translateToMemoryRegions(regionInfo);
 }
 
+template <>
+unsigned int IoctlHelperImpl<gfxProduct>::getIoctlRequestValue(DrmIoctl ioctlRequest) {
+    switch (ioctlRequest) {
+    case DrmIoctl::DG1GemCreateExt:
+        return DRM_IOCTL_I915_GEM_CREATE_EXT;
+    default:
+        return IoctlHelperUpstream::getIoctlRequestValue(ioctlRequest);
+    }
+}
+
 template class IoctlHelperImpl<gfxProduct>;
 } // namespace NEO

shared/test/common/libult/linux/drm_mock.cpp

@@ -17,11 +17,11 @@
 const int DrmMock::mockFd;
 const uint32_t DrmMockResources::registerResourceReturnHandle = 3;
 
-int DrmMock::ioctl(unsigned long request, void *arg) {
+int DrmMock::ioctl(DrmIoctl request, void *arg) {
     ioctlCallsCount++;
     ioctlCount.total++;
 
-    if ((request == DRM_IOCTL_I915_GETPARAM) && (arg != nullptr)) {
+    if ((request == DrmIoctl::Getparam) && (arg != nullptr)) {
         ioctlCount.contextGetParam++;
         auto gp = static_cast<GetParam *>(arg);
         if (gp->param == I915_PARAM_EU_TOTAL) {
@@ -74,7 +74,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
         }
     }
 
-    if ((request == DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT) && (arg != nullptr)) {
+    if ((request == DrmIoctl::GemContextCreateExt) && (arg != nullptr)) {
         ioctlCount.contextCreate++;
         auto create = static_cast<GemContextCreateExt *>(arg);
         create->contextId = this->storedDrmContextId;
@@ -92,14 +92,14 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
         }
     }
 
-    if ((request == DRM_IOCTL_I915_GEM_CONTEXT_DESTROY) && (arg != nullptr)) {
+    if ((request == DrmIoctl::GemContextDestroy) && (arg != nullptr)) {
         ioctlCount.contextDestroy++;
         auto destroy = static_cast<GemContextDestroy *>(arg);
         this->receivedDestroyContextId = destroy->contextId;
         return this->storedRetVal;
     }
 
-    if ((request == DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM) && (arg != nullptr)) {
+    if ((request == DrmIoctl::GemContextSetparam) && (arg != nullptr)) {
         ioctlCount.contextSetParam++;
         receivedContextParamRequestCount++;
         receivedContextParamRequest = *static_cast<GemContextParam *>(arg);
@@ -127,7 +127,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
         }
     }
 
-    if ((request == DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM) && (arg != nullptr)) {
+    if ((request == DrmIoctl::GemContextGetparam) && (arg != nullptr)) {
         ioctlCount.contextGetParam++;
         receivedContextParamRequestCount++;
         receivedContextParamRequest = *static_cast<GemContextParam *>(arg);
@@ -152,7 +152,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
         }
     }
 
-    if (request == DRM_IOCTL_I915_GEM_EXECBUFFER2) {
+    if (request == DrmIoctl::GemExecbuffer2) {
         ioctlCount.execbuffer2++;
         auto execbuf = static_cast<NEO::MockExecBuffer *>(arg);
         auto execObjects = reinterpret_cast<const MockExecObject *>(execbuf->getBuffersPtr());
@@ -162,14 +162,14 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
         }
         return 0;
     }
-    if (request == DRM_IOCTL_I915_GEM_USERPTR) {
+    if (request == DrmIoctl::GemUserptr) {
         ioctlCount.gemUserptr++;
         auto userPtrParams = static_cast<NEO::GemUserPtr *>(arg);
         userPtrParams->handle = returnHandle;
         returnHandle++;
         return 0;
     }
-    if (request == DRM_IOCTL_I915_GEM_CREATE) {
+    if (request == DrmIoctl::GemCreate) {
         ioctlCount.gemCreate++;
         auto createParams = static_cast<NEO::GemCreate *>(arg);
         this->createParamsSize = createParams->size;
@@ -179,7 +179,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
         }
         return 0;
     }
-    if (request == DRM_IOCTL_I915_GEM_SET_TILING) {
+    if (request == DrmIoctl::GemSetTiling) {
         ioctlCount.gemSetTiling++;
         auto setTilingParams = static_cast<NEO::GemSetTiling *>(arg);
         setTilingMode = setTilingParams->tilingMode;
@@ -187,7 +187,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
         setTilingStride = setTilingParams->stride;
         return 0;
     }
-    if (request == DRM_IOCTL_PRIME_FD_TO_HANDLE) {
+    if (request == DrmIoctl::PrimeFdToHandle) {
         ioctlCount.primeFdToHandle++;
         auto primeToHandleParams = static_cast<PrimeHandle *>(arg);
         //return BO
@@ -195,35 +195,28 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
         inputFd = primeToHandleParams->fileDescriptor;
         return fdToHandleRetVal;
     }
-    if (request == DRM_IOCTL_PRIME_HANDLE_TO_FD) {
+    if (request == DrmIoctl::PrimeHandleToFd) {
         ioctlCount.handleToPrimeFd++;
         auto primeToFdParams = static_cast<PrimeHandle *>(arg);
         primeToFdParams->fileDescriptor = outputFd;
         return 0;
     }
-    if (request == DRM_IOCTL_I915_GEM_GET_APERTURE) {
+    if (request == DrmIoctl::GemMmap) {
-        ioctlCount.gemGetAperture++;
-        auto aperture = static_cast<drm_i915_gem_get_aperture *>(arg);
-        aperture->aper_available_size = gpuMemSize;
-        aperture->aper_size = gpuMemSize;
-        return 0;
-    }
-    if (request == DRM_IOCTL_I915_GEM_MMAP) {
         ioctlCount.gemMmap++;
         auto mmapArg = static_cast<GemMmap *>(arg);
         mmapArg->addrPtr = reinterpret_cast<uint64_t>(lockedPtr);
         return 0;
     }
-    if (request == DRM_IOCTL_I915_GEM_WAIT) {
+    if (request == DrmIoctl::GemWait) {
         ioctlCount.gemWait++;
         receivedGemWait = *static_cast<GemWait *>(arg);
         return 0;
     }
-    if (request == DRM_IOCTL_GEM_CLOSE) {
+    if (request == DrmIoctl::GemClose) {
         ioctlCount.gemClose++;
         return storedRetValForGemClose;
     }
-    if (request == DRM_IOCTL_I915_GET_RESET_STATS && arg != nullptr) {
+    if (request == DrmIoctl::GetResetStats && arg != nullptr) {
         ioctlCount.gemResetStats++;
         auto outResetStats = static_cast<ResetStats *>(arg);
         for (const auto &resetStats : resetStatsToReturn) {
@@ -236,7 +229,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
         return -1;
     }
 
-    if (request == DRM_IOCTL_I915_QUERY && arg != nullptr) {
+    if (request == DrmIoctl::Query && arg != nullptr) {
         ioctlCount.query++;
         auto queryArg = static_cast<Query *>(arg);
         auto queryItemArg = reinterpret_cast<QueryItem *>(queryArg->itemsPtr);
@@ -277,8 +270,8 @@ int DrmMock::waitUserFence(uint32_t ctxIdx, uint64_t address, uint64_t value, Va
     waitUserFenceParams.push_back({ctxIdx, address, value, dataWidth, timeout, flags});
     return Drm::waitUserFence(ctxIdx, address, value, dataWidth, timeout, flags);
 }
-int DrmMockEngine::handleRemainingRequests(unsigned long request, void *arg) {
+int DrmMockEngine::handleRemainingRequests(DrmIoctl request, void *arg) {
-    if ((request == DRM_IOCTL_I915_QUERY) && (arg != nullptr)) {
+    if ((request == DrmIoctl::Query) && (arg != nullptr)) {
         if (i915QuerySuccessCount == 0) {
             return EINVAL;
         }
@@ -295,69 +288,6 @@ int DrmMockEngine::handleRemainingRequests(unsigned long request, void *arg) {
     return -1;
 }
 
-std::map<unsigned long, const char *> ioctlCodeStringMap = {
-    {DRM_IOCTL_I915_INIT, "DRM_IOCTL_I915_INIT"},
-    {DRM_IOCTL_I915_FLUSH, "DRM_IOCTL_I915_FLUSH"},
-    {DRM_IOCTL_I915_FLIP, "DRM_IOCTL_I915_FLIP"},
-    {DRM_IOCTL_GEM_CLOSE, "DRM_IOCTL_GEM_CLOSE"},
-    {DRM_IOCTL_I915_BATCHBUFFER, "DRM_IOCTL_I915_BATCHBUFFER"},
-    {DRM_IOCTL_I915_IRQ_EMIT, "DRM_IOCTL_I915_IRQ_EMIT"},
-    {DRM_IOCTL_I915_IRQ_WAIT, "DRM_IOCTL_I915_IRQ_WAIT"},
-    {DRM_IOCTL_I915_GETPARAM, "DRM_IOCTL_I915_GETPARAM"},
-    {DRM_IOCTL_I915_SETPARAM, "DRM_IOCTL_I915_SETPARAM"},
-    {DRM_IOCTL_I915_ALLOC, "DRM_IOCTL_I915_ALLOC"},
-    {DRM_IOCTL_I915_FREE, "DRM_IOCTL_I915_FREE"},
-    {DRM_IOCTL_I915_INIT_HEAP, "DRM_IOCTL_I915_INIT_HEAP"},
-    {DRM_IOCTL_I915_CMDBUFFER, "DRM_IOCTL_I915_CMDBUFFER"},
-    {DRM_IOCTL_I915_DESTROY_HEAP, "DRM_IOCTL_I915_DESTROY_HEAP"},
-    {DRM_IOCTL_I915_SET_VBLANK_PIPE, "DRM_IOCTL_I915_SET_VBLANK_PIPE"},
-    {DRM_IOCTL_I915_GET_VBLANK_PIPE, "DRM_IOCTL_I915_GET_VBLANK_PIPE"},
-    {DRM_IOCTL_I915_VBLANK_SWAP, "DRM_IOCTL_I915_VBLANK_SWAP"},
-    {DRM_IOCTL_I915_HWS_ADDR, "DRM_IOCTL_I915_HWS_ADDR"},
-    {DRM_IOCTL_I915_GEM_INIT, "DRM_IOCTL_I915_GEM_INIT"},
-    {DRM_IOCTL_I915_GEM_EXECBUFFER, "DRM_IOCTL_I915_GEM_EXECBUFFER"},
-    {DRM_IOCTL_I915_GEM_EXECBUFFER2, "DRM_IOCTL_I915_GEM_EXECBUFFER2"},
-    {DRM_IOCTL_I915_GEM_EXECBUFFER2_WR, "DRM_IOCTL_I915_GEM_EXECBUFFER2_WR"},
-    {DRM_IOCTL_I915_GEM_PIN, "DRM_IOCTL_I915_GEM_PIN"},
-    {DRM_IOCTL_I915_GEM_UNPIN, "DRM_IOCTL_I915_GEM_UNPIN"},
-    {DRM_IOCTL_I915_GEM_BUSY, "DRM_IOCTL_I915_GEM_BUSY"},
-    {DRM_IOCTL_I915_GEM_SET_CACHING, "DRM_IOCTL_I915_GEM_SET_CACHING"},
-    {DRM_IOCTL_I915_GEM_GET_CACHING, "DRM_IOCTL_I915_GEM_GET_CACHING"},
-    {DRM_IOCTL_I915_GEM_THROTTLE, "DRM_IOCTL_I915_GEM_THROTTLE"},
-    {DRM_IOCTL_I915_GEM_ENTERVT, "DRM_IOCTL_I915_GEM_ENTERVT"},
-    {DRM_IOCTL_I915_GEM_LEAVEVT, "DRM_IOCTL_I915_GEM_LEAVEVT"},
-    {DRM_IOCTL_I915_GEM_CREATE, "DRM_IOCTL_I915_GEM_CREATE"},
-    {DRM_IOCTL_I915_GEM_PREAD, "DRM_IOCTL_I915_GEM_PREAD"},
-    {DRM_IOCTL_I915_GEM_PWRITE, "DRM_IOCTL_I915_GEM_PWRITE"},
-    {DRM_IOCTL_I915_GEM_SET_DOMAIN, "DRM_IOCTL_I915_GEM_SET_DOMAIN"},
-    {DRM_IOCTL_I915_GEM_SW_FINISH, "DRM_IOCTL_I915_GEM_SW_FINISH"},
-    {DRM_IOCTL_I915_GEM_SET_TILING, "DRM_IOCTL_I915_GEM_SET_TILING"},
-    {DRM_IOCTL_I915_GEM_GET_TILING, "DRM_IOCTL_I915_GEM_GET_TILING"},
-    {DRM_IOCTL_I915_GEM_GET_APERTURE, "DRM_IOCTL_I915_GEM_GET_APERTURE"},
-    {DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID, "DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID"},
-    {DRM_IOCTL_I915_GEM_MADVISE, "DRM_IOCTL_I915_GEM_MADVISE"},
-    {DRM_IOCTL_I915_OVERLAY_PUT_IMAGE, "DRM_IOCTL_I915_OVERLAY_PUT_IMAGE"},
-    {DRM_IOCTL_I915_OVERLAY_ATTRS, "DRM_IOCTL_I915_OVERLAY_ATTRS"},
-    {DRM_IOCTL_I915_SET_SPRITE_COLORKEY, "DRM_IOCTL_I915_SET_SPRITE_COLORKEY"},
-    {DRM_IOCTL_I915_GET_SPRITE_COLORKEY, "DRM_IOCTL_I915_GET_SPRITE_COLORKEY"},
-    {DRM_IOCTL_I915_GEM_WAIT, "DRM_IOCTL_I915_GEM_WAIT"},
-    {DRM_IOCTL_I915_GEM_CONTEXT_CREATE, "DRM_IOCTL_I915_GEM_CONTEXT_CREATE"},
-    {DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, "DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT"},
-    {DRM_IOCTL_I915_GEM_CONTEXT_DESTROY, "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY"},
-    {DRM_IOCTL_I915_REG_READ, "DRM_IOCTL_I915_REG_READ"},
-    {DRM_IOCTL_I915_GET_RESET_STATS, "DRM_IOCTL_I915_GET_RESET_STATS"},
-    {DRM_IOCTL_I915_GEM_USERPTR, "DRM_IOCTL_I915_GEM_USERPTR"},
-    {DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, "DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM"},
-    {DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, "DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM"},
-    {DRM_IOCTL_I915_PERF_OPEN, "DRM_IOCTL_I915_PERF_OPEN"},
-    {DRM_IOCTL_I915_PERF_ADD_CONFIG, "DRM_IOCTL_I915_PERF_ADD_CONFIG"},
-    {DRM_IOCTL_I915_PERF_REMOVE_CONFIG, "DRM_IOCTL_I915_PERF_REMOVE_CONFIG"},
-    {DRM_IOCTL_I915_QUERY, "DRM_IOCTL_I915_QUERY"},
-    {DRM_IOCTL_I915_GEM_MMAP, "DRM_IOCTL_I915_GEM_MMAP"},
-    {DRM_IOCTL_PRIME_FD_TO_HANDLE, "DRM_IOCTL_PRIME_FD_TO_HANDLE"},
-    {DRM_IOCTL_PRIME_HANDLE_TO_FD, "DRM_IOCTL_PRIME_HANDLE_TO_FD"},
-    {static_cast<unsigned long>(101010101), "101010101"}};
-
 std::map<int, const char *> ioctlParamCodeStringMap = {
     {I915_PARAM_CHIPSET_ID, "I915_PARAM_CHIPSET_ID"},
     {I915_PARAM_REVISION, "I915_PARAM_REVISION"},

shared/test/common/libult/linux/drm_mock.h

@@ -74,7 +74,7 @@ class DrmMock : public Drm {
         }
     }
 
-    int ioctl(unsigned long request, void *arg) override;
+    int ioctl(DrmIoctl request, void *arg) override;
     int getErrno() override {
         if (baseErrno) {
             return Drm::getErrno();
@@ -249,7 +249,7 @@ class DrmMock : public Drm {
     bool expectIoctlCallsOnDestruction = false;
     uint32_t expectedIoctlCallsOnDestruction = 0u;
 
-    virtual int handleRemainingRequests(unsigned long request, void *arg) { return -1; }
+    virtual int handleRemainingRequests(DrmIoctl request, void *arg) { return -1; }
 
     struct WaitUserFenceParams {
         uint32_t ctxId;
@@ -265,14 +265,14 @@ class DrmMock : public Drm {
 class DrmMockNonFailing : public DrmMock {
   public:
     using DrmMock::DrmMock;
-    int handleRemainingRequests(unsigned long request, void *arg) override { return 0; }
+    int handleRemainingRequests(DrmIoctl request, void *arg) override { return 0; }
 };
 
 class DrmMockReturnErrorNotSupported : public DrmMock {
   public:
     using DrmMock::DrmMock;
-    int ioctl(unsigned long request, void *arg) override {
+    int ioctl(DrmIoctl request, void *arg) override {
-        if (request == DRM_IOCTL_I915_GEM_EXECBUFFER2) {
+        if (request == DrmIoctl::GemExecbuffer2) {
             return -1;
         }
         return 0;
@@ -289,7 +289,7 @@ class DrmMockEngine : public DrmMock {
         rootDeviceEnvironment.setHwInfo(defaultHwInfo.get());
     }
 
-    int handleRemainingRequests(unsigned long request, void *arg) override;
+    int handleRemainingRequests(DrmIoctl request, void *arg) override;
 
     void handleQueryItem(QueryItem *queryItem);
     bool failQueryDeviceBlob = false;

shared/test/common/libult/linux/drm_mock_prelim_context.cpp

@@ -37,9 +37,9 @@ constexpr std::array<uint64_t, 9> copyEnginesCapsMap = {{
 
 } // namespace
 
-int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg) {
+int DrmMockPrelimContext::handlePrelimRequest(DrmIoctl request, void *arg) {
     switch (request) {
-    case DRM_IOCTL_I915_GETPARAM: {
+    case DrmIoctl::Getparam: {
         auto gp = static_cast<GetParam *>(arg);
         if (gp->param == PRELIM_I915_PARAM_HAS_PAGE_FAULT) {
             *gp->value = hasPageFaultQueryValue;
@@ -50,14 +50,14 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
             return vmBindQueryReturn;
         }
     } break;
-    case DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM: {
+    case DrmIoctl::GemContextGetparam: {
         auto gp = static_cast<GemContextParam *>(arg);
         if (gp->param == PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAGS) {
             gp->value = contextDebugSupported ? PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP << 32 : 0;
             return 0;
         }
     } break;
-    case DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT: {
+    case DrmIoctl::GemContextCreateExt: {
         auto create = static_cast<GemContextCreateExt *>(arg);
         auto setParam = reinterpret_cast<GemContextCreateExtSetParam *>(create->extensions);
         if (setParam->param.param == PRELIM_I915_CONTEXT_PARAM_ACC) {
@@ -68,12 +68,12 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
         }
         return 0;
     } break;
-    case DRM_IOCTL_I915_GEM_MMAP_OFFSET: {
+    case DrmIoctl::GemMmapOffset: {
         auto mmapArg = static_cast<GemMmapOffset *>(arg);
         mmapArg->offset = 0;
         return mmapOffsetReturn;
     } break;
-    case PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE: {
+    case DrmIoctl::GemClosReserve: {
         auto closReserveArg = static_cast<prelim_drm_i915_gem_clos_reserve *>(arg);
         closIndex++;
         if (closIndex == 0) {
@@ -82,7 +82,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
         closReserveArg->clos_index = closIndex;
         return 0;
     } break;
-    case PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE: {
+    case DrmIoctl::GemClosFree: {
         auto closFreeArg = static_cast<prelim_drm_i915_gem_clos_free *>(arg);
         if (closFreeArg->clos_index > closIndex) {
             return EINVAL;
@@ -90,7 +90,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
         closIndex--;
         return 0;
     } break;
-    case PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE: {
+    case DrmIoctl::GemCacheReserve: {
         auto cacheReserveArg = static_cast<prelim_drm_i915_gem_cache_reserve *>(arg);
         if (cacheReserveArg->clos_index > closIndex) {
             return EINVAL;
@@ -106,7 +106,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
         allocNumWays += cacheReserveArg->num_ways;
         return 0;
     } break;
-    case PRELIM_DRM_IOCTL_I915_GEM_VM_BIND: {
+    case DrmIoctl::GemVmBind: {
         vmBindCalled++;
         const auto vmBind = reinterpret_cast<prelim_drm_i915_gem_vm_bind *>(arg);
         receivedVmBind = VmBindParams{
@@ -121,7 +121,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
         storeVmBindExtensions(vmBind->extensions, true);
         return vmBindReturn;
     } break;
-    case PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND: {
+    case DrmIoctl::GemVmUnbind: {
         vmUnbindCalled++;
         const auto vmBind = reinterpret_cast<prelim_drm_i915_gem_vm_bind *>(arg);
         receivedVmUnbind = VmBindParams{
@@ -136,7 +136,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
         storeVmBindExtensions(vmBind->extensions, false);
         return vmUnbindReturn;
     } break;
-    case PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT: {
+    case DrmIoctl::GemCreateExt: {
         auto createExt = static_cast<prelim_drm_i915_gem_create_ext *>(arg);
         if (createExt->size == 0) {
             return EINVAL;
@@ -178,7 +178,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
 
         return gemCreateExtReturn;
     } break;
-    case PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE: {
+    case DrmIoctl::GemWaitUserFence: {
         waitUserFenceCalled++;
         const auto wait = reinterpret_cast<prelim_drm_i915_gem_wait_user_fence *>(arg);
         receivedWaitUserFence = WaitUserFence{
@@ -193,7 +193,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
         };
         return 0;
     } break;
-    case DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM: {
+    case DrmIoctl::GemContextSetparam: {
         const auto req = reinterpret_cast<GemContextParam *>(arg);
         if (req->param == PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAGS) {
             receivedSetContextParamValue = req->value;
@@ -202,12 +202,12 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
 
         return !contextDebugSupported ? EINVAL : 0;
     } break;
-    case PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE: {
+    case DrmIoctl::GemVmAdvise: {
         const auto req = reinterpret_cast<prelim_drm_i915_gem_vm_advise *>(arg);
         receivedVmAdvise = VmAdvise{req->handle, req->attribute};
         return vmAdviseReturn;
     } break;
-    case PRELIM_DRM_IOCTL_I915_UUID_REGISTER: {
+    case DrmIoctl::UuidRegister: {
         auto uuidControl = reinterpret_cast<prelim_drm_i915_uuid_control *>(arg);
 
         if (uuidControl->uuid_class != uint32_t(PRELIM_I915_UUID_CLASS_STRING) && uuidControl->uuid_class > uuidHandle) {
@@ -228,7 +228,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
         memcpy_s(receivedRegisterUuid->uuid, sizeof(receivedRegisterUuid->uuid), uuidControl->uuid, sizeof(uuidControl->uuid));
         return uuidControlReturn;
     } break;
-    case PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER: {
+    case DrmIoctl::UuidUnregister: {
         auto uuidControl = reinterpret_cast<prelim_drm_i915_uuid_control *>(arg);
         receivedUnregisterUuid = UuidControl{
             {},
@@ -243,7 +243,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
         return uuidControlReturn;
     } break;
 
-    case PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN: {
+    case DrmIoctl::DebuggerOpen: {
         auto debuggerOpen = reinterpret_cast<prelim_drm_i915_debugger_open_param *>(arg);
         if (debuggerOpen->pid != 0 && debuggerOpen->events == 0) {
             return debuggerOpenRetval;

shared/test/common/libult/linux/drm_mock_prelim_context.h

@@ -138,7 +138,7 @@ struct DrmMockPrelimContext {
     // Debugger ioctls
     int debuggerOpenRetval = 10; // debugFd
 
-    int handlePrelimRequest(unsigned long request, void *arg);
+    int handlePrelimRequest(DrmIoctl request, void *arg);
     bool handlePrelimQueryItem(void *arg);
     void storeVmBindExtensions(uint64_t ptr, bool bind);
 };

shared/test/common/libult/linux/drm_query_mock.cpp

@@ -11,8 +11,8 @@
 
 #include "gtest/gtest.h"
 
-int DrmQueryMock::handleRemainingRequests(unsigned long request, void *arg) {
+int DrmQueryMock::handleRemainingRequests(DrmIoctl request, void *arg) {
-    if (request == DRM_IOCTL_I915_QUERY && arg) {
+    if (request == DrmIoctl::Query && arg) {
         if (i915QuerySuccessCount == 0) {
             return EINVAL;
         }
@@ -31,7 +31,7 @@ int DrmQueryMock::handleRemainingRequests(unsigned long request, void *arg) {
         }
 
         return 0;
-    } else if (request == DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM && receivedContextParamRequest.param == I915_CONTEXT_PARAM_ENGINES) {
+    } else if (request == DrmIoctl::GemContextSetparam && receivedContextParamRequest.param == I915_CONTEXT_PARAM_ENGINES) {
         EXPECT_LE(receivedContextParamRequest.size, sizeof(receivedContextParamEngines));
         memcpy(&receivedContextParamEngines, reinterpret_cast<const void *>(receivedContextParamRequest.value), receivedContextParamRequest.size);
         auto srcBalancer = reinterpret_cast<const i915_context_engines_load_balance *>(receivedContextParamEngines.extensions);

shared/test/common/libult/linux/drm_query_mock.h

@@ -55,6 +55,6 @@ class DrmQueryMock : public DrmMock {
     uint32_t i915QuerySuccessCount = std::numeric_limits<uint32_t>::max();
     int storedRetValForSetParamEngines{0};
 
-    int handleRemainingRequests(unsigned long request, void *arg) override;
+    int handleRemainingRequests(DrmIoctl request, void *arg) override;
     virtual bool handleQueryItem(void *queryItem);
 };

shared/test/common/os_interface/linux/device_command_stream_fixture.cpp

@@ -63,12 +63,12 @@ void DrmMockCustom::testIoctls() {
 #undef NEO_IOCTL_EXPECT_EQ
 }
 
-int DrmMockCustom::ioctl(unsigned long request, void *arg) {
+int DrmMockCustom::ioctl(DrmIoctl request, void *arg) {
     auto ext = ioctl_res_ext.load();
 
     //store flags
     switch (request) {
-    case DRM_IOCTL_I915_GEM_EXECBUFFER2: {
+    case DrmIoctl::GemExecbuffer2: {
         auto execbuf = static_cast<NEO::MockExecBuffer *>(arg);
         this->execBuffer = *execbuf;
         this->execBufferBufferObjects =
@@ -77,33 +77,33 @@ int DrmMockCustom::ioctl(unsigned long request, void *arg) {
         execBufferExtensions(execbuf);
     } break;
 
-    case DRM_IOCTL_I915_GEM_USERPTR: {
+    case DrmIoctl::GemUserptr: {
         auto *userPtrParams = static_cast<NEO::GemUserPtr *>(arg);
         userPtrParams->handle = returnHandle;
         returnHandle++;
         ioctl_cnt.gemUserptr++;
     } break;
 
-    case DRM_IOCTL_I915_GEM_CREATE: {
+    case DrmIoctl::GemCreate: {
         auto *createParams = static_cast<NEO::GemCreate *>(arg);
         this->createParamsSize = createParams->size;
         this->createParamsHandle = createParams->handle = 1u;
         ioctl_cnt.gemCreate++;
     } break;
-    case DRM_IOCTL_I915_GEM_SET_TILING: {
+    case DrmIoctl::GemSetTiling: {
         auto *setTilingParams = static_cast<NEO::GemSetTiling *>(arg);
         setTilingMode = setTilingParams->tilingMode;
         setTilingHandle = setTilingParams->handle;
         setTilingStride = setTilingParams->stride;
         ioctl_cnt.gemSetTiling++;
     } break;
-    case DRM_IOCTL_I915_GEM_GET_TILING: {
+    case DrmIoctl::GemGetTiling: {
         auto *getTilingParams = static_cast<NEO::GemGetTiling *>(arg);
         getTilingParams->tilingMode = getTilingModeOut;
         getTilingHandleIn = getTilingParams->handle;
         ioctl_cnt.gemGetTiling++;
     } break;
-    case DRM_IOCTL_PRIME_FD_TO_HANDLE: {
+    case DrmIoctl::PrimeFdToHandle: {
         auto *primeToHandleParams = static_cast<NEO::PrimeHandle *>(arg);
         //return BO
         primeToHandleParams->handle = outputHandle;
@@ -113,7 +113,7 @@ int DrmMockCustom::ioctl(unsigned long request, void *arg) {
             return -1;
         }
     } break;
-    case DRM_IOCTL_PRIME_HANDLE_TO_FD: {
+    case DrmIoctl::PrimeHandleToFd: {
         auto *handleToPrimeParams = static_cast<NEO::PrimeHandle *>(arg);
         //return FD
         inputHandle = handleToPrimeParams->handle;
@@ -121,7 +121,7 @@ int DrmMockCustom::ioctl(unsigned long request, void *arg) {
         handleToPrimeParams->fileDescriptor = outputFd;
         ioctl_cnt.handleToPrimeFd++;
     } break;
-    case DRM_IOCTL_I915_GEM_MMAP: {
+    case DrmIoctl::GemMmap: {
         auto mmapParams = static_cast<NEO::GemMmap *>(arg);
         mmapHandle = mmapParams->handle;
         mmapPad = mmapParams->pad;
@@ -131,7 +131,7 @@ int DrmMockCustom::ioctl(unsigned long request, void *arg) {
         mmapParams->addrPtr = mmapAddrPtr;
         ioctl_cnt.gemMmap++;
     } break;
-    case DRM_IOCTL_I915_GEM_SET_DOMAIN: {
+    case DrmIoctl::GemSetDomain: {
         auto setDomainParams = static_cast<NEO::GemSetDomain *>(arg);
         setDomainHandle = setDomainParams->handle;
         setDomainReadDomains = setDomainParams->readDomains;
@@ -139,45 +139,45 @@ int DrmMockCustom::ioctl(unsigned long request, void *arg) {
         ioctl_cnt.gemSetDomain++;
     } break;
 
-    case DRM_IOCTL_I915_GEM_WAIT: {
+    case DrmIoctl::GemWait: {
         auto gemWaitParams = static_cast<NEO::GemWait *>(arg);
         gemWaitTimeout = gemWaitParams->timeoutNs;
         ioctl_cnt.gemWait++;
     } break;
 
-    case DRM_IOCTL_GEM_CLOSE:
+    case DrmIoctl::GemClose:
         ioctl_cnt.gemClose++;
         break;
 
-    case DRM_IOCTL_I915_REG_READ:
+    case DrmIoctl::RegRead:
         ioctl_cnt.regRead++;
         break;
 
-    case DRM_IOCTL_I915_GETPARAM: {
+    case DrmIoctl::Getparam: {
         ioctl_cnt.contextGetParam++;
         auto getParam = static_cast<NEO::GetParam *>(arg);
         recordedGetParam = *getParam;
         *getParam->value = getParamRetValue;
     } break;
 
-    case DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM: {
+    case DrmIoctl::GemContextSetparam: {
     } break;
 
-    case DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM: {
+    case DrmIoctl::GemContextGetparam: {
         ioctl_cnt.contextGetParam++;
         auto getContextParam = static_cast<NEO::GemContextParam *>(arg);
         recordedGetContextParam = *getContextParam;
         getContextParam->value = getContextParamRetValue;
     } break;
 
-    case DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT: {
+    case DrmIoctl::GemContextCreateExt: {
         auto contextCreateParam = static_cast<NEO::GemContextCreateExt *>(arg);
         contextCreateParam->contextId = ++ioctl_cnt.contextCreate;
     } break;
-    case DRM_IOCTL_I915_GEM_CONTEXT_DESTROY: {
+    case DrmIoctl::GemContextDestroy: {
         ioctl_cnt.contextDestroy++;
     } break;
-    case DRM_IOCTL_I915_GEM_MMAP_OFFSET: {
+    case DrmIoctl::GemMmapOffset: {
         auto mmapOffsetParams = reinterpret_cast<NEO::GemMmapOffset *>(arg);
         mmapOffsetParams->handle = mmapOffsetHandle;
         mmapOffsetParams->offset = mmapOffsetExpected;

shared/test/common/os_interface/linux/device_command_stream_fixture.h

@@ -20,6 +20,7 @@
 #include <cstdint>
 
 using NEO::Drm;
+using NEO::DrmIoctl;
 using NEO::HwDeviceIdDrm;
 using NEO::RootDeviceEnvironment;
 
@@ -61,20 +62,20 @@ class DrmMockSuccess : public Drm {
     using Drm::setupIoctlHelper;
     DrmMockSuccess(int fd, RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(fd, mockPciPath), rootDeviceEnvironment) {}
 
-    int ioctl(unsigned long request, void *arg) override { return 0; };
+    int ioctl(DrmIoctl request, void *arg) override { return 0; };
 };
 
 class DrmMockFail : public Drm {
   public:
     DrmMockFail(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(mockFd, mockPciPath), rootDeviceEnvironment) {}
 
-    int ioctl(unsigned long request, void *arg) override { return -1; };
+    int ioctl(DrmIoctl request, void *arg) override { return -1; };
 };
 
 class DrmMockTime : public DrmMockSuccess {
   public:
     using DrmMockSuccess::DrmMockSuccess;
-    int ioctl(unsigned long request, void *arg) override {
+    int ioctl(DrmIoctl request, void *arg) override {
         auto *reg = reinterpret_cast<NEO::RegisterRead *>(arg);
         reg->value = getVal() << 32;
         return 0;
@@ -130,9 +131,9 @@ class DrmMockCustom : public Drm {
 
     void testIoctls();
 
-    int ioctl(unsigned long request, void *arg) override;
+    int ioctl(DrmIoctl request, void *arg) override;
 
-    virtual int ioctlExtra(unsigned long request, void *arg) {
+    virtual int ioctlExtra(DrmIoctl request, void *arg) {
         return -1;
     }
 

shared/test/common/os_interface/linux/device_command_stream_fixture_context.cpp

@@ -11,21 +11,19 @@
 
 #include "third_party/uapi/prelim/drm/i915_drm.h"
 
-#include <iostream>
+int DrmMockCustomPrelimContext::ioctlExtra(DrmIoctl request, void *arg) {
-
-int DrmMockCustomPrelimContext::ioctlExtra(unsigned long request, void *arg) {
     switch (request) {
-    case PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT: {
+    case DrmIoctl::GemCreateExt: {
         auto createExtParams = reinterpret_cast<prelim_drm_i915_gem_create_ext *>(arg);
         createExtSize = createExtParams->size;
         createExtHandle = createExtParams->handle;
         createExtExtensions = createExtParams->extensions;
     } break;
-    case PRELIM_DRM_IOCTL_I915_GEM_VM_BIND: {
+    case DrmIoctl::GemVmBind: {
     } break;
-    case PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND: {
+    case DrmIoctl::GemVmUnbind: {
     } break;
-    case PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE: {
+    case DrmIoctl::GemWaitUserFence: {
         const auto wait = reinterpret_cast<prelim_drm_i915_gem_wait_user_fence *>(arg);
         receivedGemWaitUserFence = WaitUserFence{
             wait->extensions,
@@ -40,8 +38,6 @@ int DrmMockCustomPrelimContext::ioctlExtra(unsigned long request, void *arg) {
         gemWaitUserFenceCalled++;
     } break;
     default: {
-        std::cout << std::hex << DRM_IOCTL_I915_GEM_WAIT << std::endl;
-        std::cout << "unexpected IOCTL: " << std::hex << request << std::endl;
         UNRECOVERABLE_IF(true);
     } break;
     }

shared/test/common/os_interface/linux/device_command_stream_fixture_context.h

@@ -23,6 +23,6 @@ struct DrmMockCustomPrelimContext {
     uint64_t completionAddress = 0;
     uint64_t completionValue = 0;
 
-    int ioctlExtra(unsigned long request, void *arg);
+    int ioctlExtra(DrmIoctl request, void *arg);
     void execBufferExtensions(void *arg);
 };

shared/test/common/os_interface/linux/device_command_stream_fixture_impl.h

@@ -40,9 +40,9 @@ class DrmMockCustomImpl : public DrmMockCustom {
     __u32 createExtHandle = 0;
     __u64 createExtExtensions = 0;
 
-    int ioctlExtra(unsigned long request, void *arg) override {
+    int ioctlExtra(DrmIoctl request, void *arg) override {
         switch (request) {
-        case DRM_IOCTL_I915_GEM_CREATE_EXT: {
+        case DrmIoctl::GemCreateExt: {
             auto createExtParams = reinterpret_cast<drm_i915_gem_create_ext *>(arg);
             createExtSize = createExtParams->size;
             createExtHandle = createExtParams->handle;
@@ -50,7 +50,6 @@ class DrmMockCustomImpl : public DrmMockCustom {
             ioctlImpl_cnt.gemCreateExt++;
         } break;
         default: {
-            std::cout << "unexpected IOCTL: " << NEO::IoctlToStringHelper::getIoctlString(request) << std::endl;
             UNRECOVERABLE_IF(true);
         } break;
         }

shared/test/common/os_interface/linux/device_command_stream_fixture_prelim.h

@@ -24,7 +24,7 @@ class DrmMockCustomPrelim : public DrmMockCustom {
         prelimVersion = "2.0";
     }
 
-    int ioctlExtra(unsigned long request, void *arg) override {
+    int ioctlExtra(DrmIoctl request, void *arg) override {
         return context.ioctlExtra(request, arg);
     }
 

shared/test/unit_test/os_interface/linux/drm_mock_impl.h

@@ -41,8 +41,8 @@ class DrmTipMock : public DrmMock {
         prelimVersion = "";
     }
 
-    int handleRemainingRequests(unsigned long request, void *arg) override {
+    int handleRemainingRequests(DrmIoctl request, void *arg) override {
-        if ((request == DRM_IOCTL_I915_QUERY) && (arg != nullptr)) {
+        if ((request == DrmIoctl::Query) && (arg != nullptr)) {
             if (i915QuerySuccessCount == 0) {
                 return EINVAL;
             }
@@ -55,7 +55,7 @@ class DrmTipMock : public DrmMock {
                 handleQueryItem(reinterpret_cast<QueryItem *>(query->itemsPtr) + i);
             }
             return 0;
-        } else if (request == DRM_IOCTL_I915_GEM_MMAP_OFFSET) {
+        } else if (request == DrmIoctl::GemMmapOffset) {
             auto mmapArg = static_cast<GemMmapOffset *>(arg);
             mmapOffsetFlagsReceived = mmapArg->flags;
             mmapArg->offset = offset;
@@ -93,8 +93,8 @@ class DrmTipMock : public DrmMock {
         }
     }
 
-    virtual int handleKernelSpecificRequests(unsigned long request, void *arg) {
+    virtual int handleKernelSpecificRequests(DrmIoctl request, void *arg) {
-        if (request == DRM_IOCTL_I915_GEM_CREATE_EXT) {
+        if (request == DrmIoctl::GemCreateExt) {
             auto createExtParams = static_cast<drm_i915_gem_create_ext *>(arg);
             if (createExtParams->size == 0) {
                 return EINVAL;

shared/test/unit_test/os_interface/linux/drm_mock_prod_dg1.h

@@ -53,8 +53,8 @@ class DrmMockProdDg1 : public DrmTipMock {
         }
     }
 
-    int handleKernelSpecificRequests(unsigned long request, void *arg) override {
+    int handleKernelSpecificRequests(DrmIoctl request, void *arg) override {
-        if (request == DRM_IOCTL_I915_GEM_CREATE_EXT) {
+        if (request == DrmIoctl::DG1GemCreateExt) {
             auto createExtParams = static_cast<drm_i915_gem_create_ext *>(arg);
             if (createExtParams->size == 0) {
                 return EINVAL;

shared/test/unit_test/os_interface/linux/drm_tests.cpp

@@ -8,6 +8,7 @@
 #include "shared/source/helpers/file_io.h"
 #include "shared/source/helpers/hw_info.h"
 #include "shared/source/os_interface/device_factory.h"
+#include "shared/source/os_interface/linux/ioctl_strings.h"
 #include "shared/source/os_interface/linux/os_context_linux.h"
 #include "shared/source/os_interface/linux/os_inc.h"
 #include "shared/source/os_interface/os_interface.h"
@@ -1173,3 +1174,50 @@ TEST(DrmTest, givenSetupIoctlHelperThenIoctlHelperNotNull) {
 
     EXPECT_NE(nullptr, drm.ioctlHelper.get());
 }
+
+TEST(DrmWrapperTest, WhenGettingDrmIoctlGetparamValueThenIoctlHelperIsNotNeeded) {
+    EXPECT_EQ(getIoctlRequestValue(DrmIoctl::Getparam, nullptr), static_cast<unsigned int>(DRM_IOCTL_I915_GETPARAM));
+    EXPECT_THROW(getIoctlRequestValue(DrmIoctl::DG1GemCreateExt, nullptr), std::runtime_error);
+}
+
+TEST(DrmWrapperTest, WhenGettingIoctlStringValueThenProperStringIsReturned) {
+    std::map<DrmIoctl, const char *> ioctlCodeStringMap = {
+        {DrmIoctl::GemClose, "DRM_IOCTL_GEM_CLOSE"},
+        {DrmIoctl::Getparam, "DRM_IOCTL_I915_GETPARAM"},
+        {DrmIoctl::GemExecbuffer2, "DRM_IOCTL_I915_GEM_EXECBUFFER2"},
+        {DrmIoctl::GemCreate, "DRM_IOCTL_I915_GEM_CREATE"},
+        {DrmIoctl::GemSetDomain, "DRM_IOCTL_I915_GEM_SET_DOMAIN"},
+        {DrmIoctl::GemSetTiling, "DRM_IOCTL_I915_GEM_SET_TILING"},
+        {DrmIoctl::GemGetTiling, "DRM_IOCTL_I915_GEM_GET_TILING"},
+        {DrmIoctl::GemWait, "DRM_IOCTL_I915_GEM_WAIT"},
+        {DrmIoctl::GemContextCreateExt, "DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT"},
+        {DrmIoctl::GemContextDestroy, "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY"},
+        {DrmIoctl::RegRead, "DRM_IOCTL_I915_REG_READ"},
+        {DrmIoctl::GetResetStats, "DRM_IOCTL_I915_GET_RESET_STATS"},
+        {DrmIoctl::GemUserptr, "DRM_IOCTL_I915_GEM_USERPTR"},
+        {DrmIoctl::GemContextGetparam, "DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM"},
+        {DrmIoctl::GemContextSetparam, "DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM"},
+        {DrmIoctl::Query, "DRM_IOCTL_I915_QUERY"},
+        {DrmIoctl::GemMmap, "DRM_IOCTL_I915_GEM_MMAP"},
+        {DrmIoctl::PrimeFdToHandle, "DRM_IOCTL_PRIME_FD_TO_HANDLE"},
+        {DrmIoctl::GemVmBind, "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND"},
+        {DrmIoctl::GemVmUnbind, "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND"},
+        {DrmIoctl::GemWaitUserFence, "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE"},
+        {DrmIoctl::GemCreateExt, "DRM_IOCTL_I915_GEM_CREATE_EXT"},
+        {DrmIoctl::DG1GemCreateExt, "DG1_DRM_IOCTL_I915_GEM_CREATE_EXT"},
+        {DrmIoctl::GemVmAdvise, "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE"},
+        {DrmIoctl::GemVmPrefetch, "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH"},
+        {DrmIoctl::UuidRegister, "PRELIM_DRM_IOCTL_I915_UUID_REGISTER"},
+        {DrmIoctl::UuidUnregister, "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER"},
+        {DrmIoctl::DebuggerOpen, "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN"},
+        {DrmIoctl::GemClosReserve, "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE"},
+        {DrmIoctl::GemClosFree, "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE"},
+        {DrmIoctl::GemCacheReserve, "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE"},
+        {DrmIoctl::GemMmapOffset, "DRM_IOCTL_I915_GEM_MMAP_OFFSET"},
+        {DrmIoctl::GemVmCreate, "DRM_IOCTL_I915_GEM_VM_CREATE"},
+        {DrmIoctl::GemVmDestroy, "DRM_IOCTL_I915_GEM_VM_DESTROY"},
+        {DrmIoctl::PrimeHandleToFd, "DRM_IOCTL_PRIME_HANDLE_TO_FD"}};
+    for (auto &ioctlCodeString : ioctlCodeStringMap) {
+        EXPECT_STREQ(IoctlToStringHelper::getIoctlString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
+    }
+}

shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp

@@ -18,7 +18,7 @@
 
 using namespace NEO;
 
-extern int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal);
+extern int handlePrelimRequests(DrmIoctl request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal);
 
 class DrmPrelimMock : public DrmMock {
   public:
@@ -35,7 +35,7 @@ class DrmPrelimMock : public DrmMock {
         prelimVersion = "2.0";
     }
 
-    int handleRemainingRequests(unsigned long request, void *arg) override {
+    int handleRemainingRequests(DrmIoctl request, void *arg) override {
         return handlePrelimRequests(request, arg, ioctlRetVal, queryDistanceIoctlRetVal);
     }
 };
@@ -135,7 +135,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtWithDebugFlagThenPr
 
 TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCallIoctlThenProperIoctlRegistered) {
     GemContextCreateExt arg{};
-    auto ret = IoctlHelper::ioctl(drm.get(), DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, &arg);
+    auto ret = IoctlHelper::ioctl(drm.get(), DrmIoctl::GemContextCreateExt, &arg);
     EXPECT_EQ(0u, ret);
     EXPECT_EQ(1u, drm->ioctlCallsCount);
 }

shared/test/unit_test/os_interface/linux/ioctl_helper_tests_dg1.cpp

@@ -9,6 +9,7 @@
 #include "shared/source/os_interface/linux/ioctl_helper.h"
 #include "shared/source/os_interface/linux/memory_info.h"
 #include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/mocks/mock_execution_environment.h"
 #include "shared/test/common/test_macros/test.h"
 #include "shared/test/unit_test/os_interface/linux/drm_mock_prod_dg1.h"
 
@@ -58,8 +59,7 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1WhenCreateGemExtWithDebugFlagThenPrintDeb
     DebugManagerStateRestore stateRestore;
     DebugManager.flags.PrintBOCreateDestroyResult.set(true);
 
-    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
-    executionEnvironment->prepareRootDeviceEnvironments(1);
     auto drm = std::make_unique<DrmMockProdDg1>(*executionEnvironment->rootDeviceEnvironments[0]);
 
     testing::internal::CaptureStdout();
@@ -92,3 +92,35 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1AndMemoryRegionQuerySupportedWhenQuerying
     ASSERT_NE(nullptr, memoryInfo);
     EXPECT_EQ(2u, memoryInfo->getDrmRegionInfos().size());
 }
+
+DG1TEST_F(IoctlHelperTestsDg1, whenGettingIoctlRequestValueThenPropertValueIsReturned) {
+    auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
+    auto drm = std::make_unique<DrmMockProdDg1>(*executionEnvironment->rootDeviceEnvironments[0]);
+    auto &ioctlHelper = *drm->getIoctlHelper();
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemExecbuffer2), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_EXECBUFFER2));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemWait), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_WAIT));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemClose), static_cast<unsigned int>(DRM_IOCTL_GEM_CLOSE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemUserptr), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_USERPTR));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetDomain), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_DOMAIN));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_TILING));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemGetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_GET_TILING));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::RegRead), static_cast<unsigned int>(DRM_IOCTL_I915_REG_READ));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GetResetStats), static_cast<unsigned int>(DRM_IOCTL_I915_GET_RESET_STATS));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextGetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextSetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::Query), static_cast<unsigned int>(DRM_IOCTL_I915_QUERY));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmap), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeFdToHandle), static_cast<unsigned int>(DRM_IOCTL_PRIME_FD_TO_HANDLE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeHandleToFd), static_cast<unsigned int>(DRM_IOCTL_PRIME_HANDLE_TO_FD));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmapOffset), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP_OFFSET));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_CREATE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_DESTROY));
+
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::DG1GemCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE_EXT));
+    EXPECT_NE(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE_EXT));
+
+    EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::Getparam), std::runtime_error);
+}

shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp

@@ -15,7 +15,6 @@
 
 using namespace NEO;
 
-extern std::map<unsigned long, const char *> ioctlCodeStringMap;
 extern std::map<int, const char *> ioctlParamCodeStringMap;
 extern std::vector<uint8_t> getRegionInfo(const std::vector<MemoryRegion> &inputRegions);
 extern std::vector<uint8_t> getEngineInfo(const std::vector<EngineCapabilities> &inputEngines);
@@ -24,27 +23,43 @@ struct IoctlPrelimHelperTests : ::testing::Test {
     IoctlHelperPrelim20 ioctlHelper{};
 };
 
-TEST_F(IoctlPrelimHelperTests, givenIoctlWhenParseToStringThenProperStringIsReturned) {
+TEST_F(IoctlPrelimHelperTests, whenGettingIoctlRequestValueThenPropertValueIsReturned) {
-    for (auto &ioctlCodeString : ioctlCodeStringMap) {
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemExecbuffer2), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_EXECBUFFER2));
-        EXPECT_STREQ(IoctlToStringHelper::getIoctlString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemWait), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_WAIT));
-    }
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemClose), static_cast<unsigned int>(DRM_IOCTL_GEM_CLOSE));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_BIND).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemUserptr), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_USERPTR));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetDomain), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_DOMAIN));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_TILING));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemGetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_GET_TILING));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_UUID_REGISTER).c_str(), "PRELIM_DRM_IOCTL_I915_UUID_REGISTER");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER).c_str(), "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::RegRead), static_cast<unsigned int>(DRM_IOCTL_I915_REG_READ));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN).c_str(), "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GetResetStats), static_cast<unsigned int>(DRM_IOCTL_I915_GET_RESET_STATS));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextGetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextSetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::Query), static_cast<unsigned int>(DRM_IOCTL_I915_QUERY));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(DRM_IOCTL_I915_GEM_MMAP_GTT).c_str(), "DRM_IOCTL_I915_GEM_MMAP_GTT");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmap), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(DRM_IOCTL_I915_GEM_MMAP_OFFSET).c_str(), "DRM_IOCTL_I915_GEM_MMAP_OFFSET");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeFdToHandle), static_cast<unsigned int>(DRM_IOCTL_PRIME_FD_TO_HANDLE));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(DRM_IOCTL_I915_GEM_VM_CREATE).c_str(), "DRM_IOCTL_I915_GEM_VM_CREATE");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeHandleToFd), static_cast<unsigned int>(DRM_IOCTL_PRIME_HANDLE_TO_FD));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(DRM_IOCTL_I915_GEM_VM_DESTROY).c_str(), "DRM_IOCTL_I915_GEM_VM_DESTROY");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmBind), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_VM_BIND));
-    EXPECT_STREQ(IoctlToStringHelper::getIoctlString(DRM_IOCTL_I915_GEM_VM_DESTROY).c_str(), "DRM_IOCTL_I915_GEM_VM_DESTROY");
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmUnbind), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemWaitUserFence), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreateExt), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmAdvise), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmPrefetch), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::UuidRegister), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_UUID_REGISTER));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::UuidUnregister), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::DebuggerOpen), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemClosReserve), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemClosFree), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCacheReserve), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmapOffset), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP_OFFSET));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_CREATE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_DESTROY));
+
+    EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::Getparam), std::runtime_error);
+    EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::DG1GemCreateExt), std::runtime_error);
 }
 
 TEST_F(IoctlPrelimHelperTests, givenIoctlParamWhenParseToStringThenProperStringIsReturned) {

shared/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp

@@ -14,7 +14,6 @@
 #include "shared/test/unit_test/os_interface/linux/drm_mock_impl.h"
 
 using namespace NEO;
-extern std::map<unsigned long, const char *> ioctlCodeStringMap;
 extern std::map<int, const char *> ioctlParamCodeStringMap;
 
 TEST(IoctlHelperUpstreamTest, whenGettingVmBindAvailabilityThenFalseIsReturned) {
@@ -24,18 +23,41 @@ TEST(IoctlHelperUpstreamTest, whenGettingVmBindAvailabilityThenFalseIsReturned)
     EXPECT_FALSE(ioctlHelper.isVmBindAvailable(drm.get()));
 }
 
-TEST(IoctlHelperUpstreamTest, givenIoctlWhenParseToStringThenProperStringIsReturned) {
-    for (auto ioctlCodeString : ioctlCodeStringMap) {
-        EXPECT_STREQ(IoctlToStringHelper::getIoctlString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
-    }
-}
-
 TEST(IoctlHelperUpstreamTest, givenIoctlParamWhenParseToStringThenProperStringIsReturned) {
     for (auto ioctlParamCodeString : ioctlParamCodeStringMap) {
         EXPECT_STREQ(IoctlToStringHelper::getIoctlParamString(ioctlParamCodeString.first).c_str(), ioctlParamCodeString.second);
     }
 }
 
+TEST(IoctlHelperUpstreamTest, whenGettingIoctlRequestValueThenPropertValueIsReturned) {
+    IoctlHelperUpstream ioctlHelper{};
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemExecbuffer2), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_EXECBUFFER2));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemWait), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_WAIT));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemClose), static_cast<unsigned int>(DRM_IOCTL_GEM_CLOSE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemUserptr), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_USERPTR));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetDomain), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_DOMAIN));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_TILING));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemGetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_GET_TILING));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::RegRead), static_cast<unsigned int>(DRM_IOCTL_I915_REG_READ));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GetResetStats), static_cast<unsigned int>(DRM_IOCTL_I915_GET_RESET_STATS));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextGetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextSetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::Query), static_cast<unsigned int>(DRM_IOCTL_I915_QUERY));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmap), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeFdToHandle), static_cast<unsigned int>(DRM_IOCTL_PRIME_FD_TO_HANDLE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeHandleToFd), static_cast<unsigned int>(DRM_IOCTL_PRIME_HANDLE_TO_FD));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE_EXT));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmapOffset), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP_OFFSET));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_CREATE));
+    EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_DESTROY));
+
+    EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::Getparam), std::runtime_error);
+    EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::DG1GemCreateExt), std::runtime_error);
+}
+
 TEST(IoctlHelperUpstreamTest, whenCreatingVmControlRegionExtThenNullptrIsReturned) {
     IoctlHelperUpstream ioctlHelper{};
     std::optional<MemoryClassInstance> regionInstanceClass = MemoryClassInstance{};

shared/test/unit_test/os_interface/linux/prelim_helper_func.cpp

@@ -16,8 +16,8 @@
 
 using namespace NEO;
 
-int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal) {
+int handlePrelimRequests(DrmIoctl request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal) {
-    if (request == PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT) {
+    if (request == DrmIoctl::GemCreateExt) {
         auto createExtParams = static_cast<prelim_drm_i915_gem_create_ext *>(arg);
         if (createExtParams->size == 0) {
             return EINVAL;
@@ -43,10 +43,10 @@ int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int
         if ((data->memoryClass != PRELIM_I915_MEMORY_CLASS_SYSTEM) && (data->memoryClass != PRELIM_I915_MEMORY_CLASS_DEVICE)) {
             return EINVAL;
         }
-    } else if (request == PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE) {
+    } else if (request == DrmIoctl::GemClosReserve) {
         auto closReserveArg = static_cast<prelim_drm_i915_gem_clos_reserve *>(arg);
         closReserveArg->clos_index = 1u;
-    } else if (request == DRM_IOCTL_I915_QUERY) {
+    } else if (request == DrmIoctl::Query) {
         auto query = static_cast<Query *>(arg);
         if (query->itemsPtr == 0) {
             return EINVAL;