diff --git a/opencl/source/cl_device/cl_device_caps.cpp b/opencl/source/cl_device/cl_device_caps.cpp
index ff10f5ea7b..cf13b6da2c 100644
--- a/opencl/source/cl_device/cl_device_caps.cpp
+++ b/opencl/source/cl_device/cl_device_caps.cpp
@@ -8,6 +8,7 @@
 #include "shared/source/device/device_info.h"
 #include "shared/source/helpers/basic_math.h"
 #include "shared/source/helpers/hw_helper.h"
+#include "shared/source/helpers/string.h"
 #include "shared/source/os_interface/driver_info.h"
 #include "shared/source/os_interface/hw_info_config.h"
 
@@ -122,6 +123,8 @@ void ClDevice::initializeCaps() {
     auto supportsAdvancedVme = hwInfo.capabilityTable.supportsVme;
 
     deviceInfo.independentForwardProgress = false;
+    deviceInfo.ilsWithVersion[0].name[0] = 0;
+    deviceInfo.ilsWithVersion[0].version = 0;
 
     if (ocl21FeaturesEnabled) {
         if (hwHelper.isIndependentForwardProgressSupported()) {
@@ -130,6 +133,9 @@ void ClDevice::initializeCaps() {
         }
 
         deviceExtensions += "cl_khr_il_program ";
+        deviceInfo.ilsWithVersion[0].version = CL_MAKE_VERSION(1, 2, 0);
+        strcpy_s(deviceInfo.ilsWithVersion[0].name, CL_NAME_VERSION_MAX_NAME_SIZE, sharedDeviceInfo.ilVersion);
+
         if (supportsVme) {
             deviceExtensions += "cl_intel_spirv_device_side_avc_motion_estimation ";
         }
@@ -246,6 +252,7 @@ void ClDevice::initializeCaps() {
     deviceInfo.memBaseAddressAlign = 1024;
     deviceInfo.minDataTypeAlignSize = 128;
 
+    deviceInfo.deviceEnqueueSupport = isDeviceEnqueueSupported();
     if (isDeviceEnqueueSupported() || (enabledClVersion == 21)) {
         deviceInfo.maxOnDeviceQueues = 1;
         deviceInfo.maxOnDeviceEvents = 1024;
@@ -299,6 +306,7 @@ void ClDevice::initializeCaps() {
     deviceInfo.imageBaseAddressAlignment = 4;
     deviceInfo.queueOnHostProperties = CL_QUEUE_PROFILING_ENABLE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
 
+    deviceInfo.pipeSupport = arePipesSupported();
     if (arePipesSupported()) {
         deviceInfo.maxPipeArgs = 16;
         deviceInfo.pipeMaxPacketSize = 1024;
@@ -309,6 +317,23 @@ void ClDevice::initializeCaps() {
         deviceInfo.pipeMaxActiveReservations = 0;
     }
 
+    deviceInfo.atomicMemoryCapabilities = CL_DEVICE_ATOMIC_ORDER_RELAXED | CL_DEVICE_ATOMIC_SCOPE_WORK_GROUP;
+    if (ocl21FeaturesEnabled) {
+        deviceInfo.atomicMemoryCapabilities |= CL_DEVICE_ATOMIC_ORDER_ACQ_REL | CL_DEVICE_ATOMIC_ORDER_SEQ_CST |
+                                               CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES | CL_DEVICE_ATOMIC_SCOPE_DEVICE;
+    }
+
+    deviceInfo.atomicFenceCapabilities = CL_DEVICE_ATOMIC_ORDER_RELAXED | CL_DEVICE_ATOMIC_ORDER_ACQ_REL |
+                                         CL_DEVICE_ATOMIC_SCOPE_WORK_GROUP;
+    if (ocl21FeaturesEnabled) {
+        deviceInfo.atomicFenceCapabilities |= CL_DEVICE_ATOMIC_ORDER_SEQ_CST | CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES |
+                                              CL_DEVICE_ATOMIC_SCOPE_DEVICE | CL_DEVICE_ATOMIC_SCOPE_WORK_ITEM;
+    }
+
+    deviceInfo.nonUniformWorkGroupSupport = ocl21FeaturesEnabled;
+    deviceInfo.workGroupCollectiveFunctionsSupport = ocl21FeaturesEnabled;
+    deviceInfo.genericAddressSpaceSupport = ocl21FeaturesEnabled;
+
     deviceInfo.linkerAvailable = true;
     deviceInfo.svmCapabilities = hwInfo.capabilityTable.ftrSvm * CL_DEVICE_SVM_COARSE_GRAIN_BUFFER;
     if (hwInfo.capabilityTable.ftrSvm) {
diff --git a/opencl/source/cl_device/cl_device_info.cpp b/opencl/source/cl_device/cl_device_info.cpp
index 650db21a73..693151cb9c 100644
--- a/opencl/source/cl_device/cl_device_info.cpp
+++ b/opencl/source/cl_device/cl_device_info.cpp
@@ -71,6 +71,8 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
     // please keep alphabetical order
     switch (paramName) {
     case CL_DEVICE_ADDRESS_BITS:                                getCap<CL_DEVICE_ADDRESS_BITS                                >(src, srcSize, retSize); break;
+    case CL_DEVICE_ATOMIC_FENCE_CAPABILITIES:                   getCap<CL_DEVICE_ATOMIC_FENCE_CAPABILITIES                   >(src, srcSize, retSize); break;
+    case CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES:                  getCap<CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES                  >(src, srcSize, retSize); break;
     case CL_DEVICE_AVAILABLE:                                   getCap<CL_DEVICE_AVAILABLE                                   >(src, srcSize, retSize); break;
     case CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL:            getCap<CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL            >(src, srcSize, retSize); break;
     case CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL:   getCap<CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL   >(src, srcSize, retSize); break;
@@ -78,6 +80,7 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
     case CL_DEVICE_BUILT_IN_KERNELS:                            getStr<CL_DEVICE_BUILT_IN_KERNELS                            >(src, srcSize, retSize); break;
     case CL_DEVICE_COMPILER_AVAILABLE:                          getCap<CL_DEVICE_COMPILER_AVAILABLE                          >(src, srcSize, retSize); break;
     case CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL:  getCap<CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL  >(src, srcSize, retSize); break;
+    case CL_DEVICE_DEVICE_ENQUEUE_SUPPORT:                      getCap<CL_DEVICE_DEVICE_ENQUEUE_SUPPORT                      >(src, srcSize, retSize); break;
     case CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL:               getCap<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL               >(src, srcSize, retSize); break;
     case CL_DEVICE_DOUBLE_FP_CONFIG:                            getCap<CL_DEVICE_DOUBLE_FP_CONFIG                            >(src, srcSize, retSize); break;
     case CL_DEVICE_DRIVER_VERSION_INTEL:                        getCap<CL_DEVICE_DRIVER_VERSION_INTEL                        >(src, srcSize, retSize); break;
@@ -85,6 +88,7 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
     case CL_DEVICE_ERROR_CORRECTION_SUPPORT:                    getCap<CL_DEVICE_ERROR_CORRECTION_SUPPORT                    >(src, srcSize, retSize); break;
     case CL_DEVICE_EXECUTION_CAPABILITIES:                      getCap<CL_DEVICE_EXECUTION_CAPABILITIES                      >(src, srcSize, retSize); break;
     case CL_DEVICE_EXTENSIONS:                                  getStr<CL_DEVICE_EXTENSIONS                                  >(src, srcSize, retSize); break;
+    case CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT:               getCap<CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT               >(src, srcSize, retSize); break;
     case CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE:                   getCap<CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE                   >(src, srcSize, retSize); break;
     case CL_DEVICE_GLOBAL_MEM_CACHE_SIZE:                       getCap<CL_DEVICE_GLOBAL_MEM_CACHE_SIZE                       >(src, srcSize, retSize); break;
     case CL_DEVICE_GLOBAL_MEM_CACHE_TYPE:                       getCap<CL_DEVICE_GLOBAL_MEM_CACHE_TYPE                       >(src, srcSize, retSize); break;
@@ -124,12 +128,14 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
     case CL_DEVICE_NATIVE_VECTOR_WIDTH_INT:                     getCap<CL_DEVICE_NATIVE_VECTOR_WIDTH_INT                     >(src, srcSize, retSize); break;
     case CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG:                    getCap<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG                    >(src, srcSize, retSize); break;
     case CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT:                   getCap<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT                   >(src, srcSize, retSize); break;
+    case CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT:              getCap<CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT              >(src, srcSize, retSize); break;
     case CL_DEVICE_OPENCL_C_VERSION:                            getStr<CL_DEVICE_OPENCL_C_VERSION                            >(src, srcSize, retSize); break;
     case CL_DEVICE_PARENT_DEVICE:                               getCap<CL_DEVICE_PARENT_DEVICE                               >(src, srcSize, retSize); break;
     case CL_DEVICE_PARTITION_AFFINITY_DOMAIN:                   getCap<CL_DEVICE_PARTITION_AFFINITY_DOMAIN                   >(src, srcSize, retSize); break;
     case CL_DEVICE_PARTITION_MAX_SUB_DEVICES:                   getCap<CL_DEVICE_PARTITION_MAX_SUB_DEVICES                   >(src, srcSize, retSize); break;
     case CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS:                getCap<CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS                >(src, srcSize, retSize); break;
     case CL_DEVICE_PIPE_MAX_PACKET_SIZE:                        getCap<CL_DEVICE_PIPE_MAX_PACKET_SIZE                        >(src, srcSize, retSize); break;
+    case CL_DEVICE_PIPE_SUPPORT:                                getCap<CL_DEVICE_PIPE_SUPPORT                                >(src, srcSize, retSize); break;
     case CL_DEVICE_PLATFORM:                                    getCap<CL_DEVICE_PLATFORM                                    >(src, srcSize, retSize); break;
     case CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT:           getCap<CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT           >(src, srcSize, retSize); break;
     case CL_DEVICE_PREFERRED_INTEROP_USER_SYNC:                 getCap<CL_DEVICE_PREFERRED_INTEROP_USER_SYNC                 >(src, srcSize, retSize); break;
@@ -161,6 +167,7 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
     case CL_DEVICE_VENDOR:                                      getStr<CL_DEVICE_VENDOR                                      >(src, srcSize, retSize); break;
     case CL_DEVICE_VENDOR_ID:                                   getCap<CL_DEVICE_VENDOR_ID                                   >(src, srcSize, retSize); break;
     case CL_DEVICE_VERSION:                                     getStr<CL_DEVICE_VERSION                                     >(src, srcSize, retSize); break;
+    case CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT:     getCap<CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT     >(src, srcSize, retSize); break;
     case CL_DRIVER_VERSION:                                     getStr<CL_DRIVER_VERSION                                     >(src, srcSize, retSize); break; // clang-format on
     case CL_DEVICE_NUM_SIMULTANEOUS_INTEROPS_INTEL:
         if (simultaneousInterops.size() > 1u) {
@@ -195,6 +202,14 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
             retSize = srcSize = sizeof(deviceInfo.partitionType[0]);
         }
         break;
+    case CL_DEVICE_ILS_WITH_VERSION:
+        src = &deviceInfo.ilsWithVersion[0];
+        if (ocl21FeaturesEnabled) {
+            retSize = srcSize = sizeof(deviceInfo.ilsWithVersion[0]);
+        } else {
+            retSize = srcSize = 0;
+        }
+        break;
     default:
         if (getDeviceInfoForImage(paramName, src, srcSize, retSize) && !getSharedDeviceInfo().imageSupport) {
             src = &value;
diff --git a/opencl/source/cl_device/cl_device_info.h b/opencl/source/cl_device/cl_device_info.h
index 5345de773b..0656c59b45 100644
--- a/opencl/source/cl_device/cl_device_info.h
+++ b/opencl/source/cl_device/cl_device_info.h
@@ -13,95 +13,103 @@ namespace NEO {
 
 // clang-format off
 struct ClDeviceInfo {
-    cl_device_type               deviceType;
-    size_t                       maxSliceCount;
-    size_t                       image3DMaxWidth;
-    size_t                       image3DMaxHeight;
-    size_t                       maxBufferSize;
-    size_t                       maxArraySize;
-    cl_device_fp_config          singleFpConfig;
-    cl_device_fp_config          halfFpConfig;
-    cl_device_fp_config          doubleFpConfig;
-    cl_ulong                     globalMemCacheSize;
-    cl_ulong                     maxConstantBufferSize;
-    size_t                       maxGlobalVariableSize;
-    size_t                       globalVariablePreferredTotalSize;
-    cl_device_exec_capabilities  executionCapabilities;
-    cl_command_queue_properties  queueOnHostProperties;
-    cl_command_queue_properties  queueOnDeviceProperties;
-    const char                   *builtInKernels;
-    cl_platform_id               platform;
-    const char                   *name;
-    const char                   *vendor;
-    const char                   *driverVersion;
-    const char                   *profile;
-    const char                   *clVersion;
-    const char                   *clCVersion;
-    const char                   *spirVersions;
-    const char                   *deviceExtensions;
-    cl_device_id                 parentDevice;
-    cl_device_affinity_domain    partitionAffinityDomain;
-    cl_uint                      partitionMaxSubDevices;
-    cl_device_partition_property partitionProperties[2];
-    cl_device_partition_property partitionType[3];
-    cl_device_svm_capabilities   svmCapabilities;
-    double                       platformHostTimerResolution;
-    size_t                       planarYuvMaxWidth;
-    size_t                       planarYuvMaxHeight;
-    cl_uint                      maxComputUnits;
-    cl_uint                      maxWorkItemDimensions;
-    cl_uint                      maxNumOfSubGroups;
-    cl_bool                      independentForwardProgress;
-    cl_uint                      preferredVectorWidthChar;
-    cl_uint                      preferredVectorWidthShort;
-    cl_uint                      preferredVectorWidthInt;
-    cl_uint                      preferredVectorWidthLong;
-    cl_uint                      preferredVectorWidthFloat;
-    cl_uint                      preferredVectorWidthDouble;
-    cl_uint                      preferredVectorWidthHalf;
-    cl_uint                      nativeVectorWidthChar;
-    cl_uint                      nativeVectorWidthShort;
-    cl_uint                      nativeVectorWidthInt;
-    cl_uint                      nativeVectorWidthLong;
-    cl_uint                      nativeVectorWidthFloat;
-    cl_uint                      nativeVectorWidthDouble;
-    cl_uint                      nativeVectorWidthHalf;
-    cl_uint                      maxReadWriteImageArgs;
-    cl_uint                      imagePitchAlignment;
-    cl_uint                      imageBaseAddressAlignment;
-    cl_uint                      maxPipeArgs;
-    cl_uint                      pipeMaxActiveReservations;
-    cl_uint                      pipeMaxPacketSize;
-    cl_uint                      memBaseAddressAlign;
-    cl_uint                      minDataTypeAlignSize;
-    cl_device_mem_cache_type     globalMemCacheType;
-    cl_uint                      maxConstantArgs;
-    cl_device_local_mem_type     localMemType;
-    cl_bool                      endianLittle;
-    cl_bool                      deviceAvailable;
-    cl_bool                      compilerAvailable;
-    cl_bool                      linkerAvailable;
-    cl_uint                      queueOnDevicePreferredSize;
-    cl_uint                      queueOnDeviceMaxSize;
-    cl_uint                      maxOnDeviceQueues;
-    cl_uint                      maxOnDeviceEvents;
-    cl_bool                      preferredInteropUserSync;
-    cl_uint                      referenceCount;
-    cl_uint                      preferredPlatformAtomicAlignment;
-    cl_uint                      preferredGlobalAtomicAlignment;
-    cl_uint                      preferredLocalAtomicAlignment;
-    cl_bool                      hostUnifiedMemory;
-    cl_bool                      vmeAvcSupportsTextureSampler;
-    cl_uint                      vmeAvcVersion;
-    cl_uint                      vmeVersion;
-    cl_uint                      internalDriverVersion;
-    cl_uint                      grfSize;
-    bool                         preemptionSupported;
+    cl_name_version               ilsWithVersion[1];
+    cl_device_type                deviceType;
+    size_t                        maxSliceCount;
+    size_t                        image3DMaxWidth;
+    size_t                        image3DMaxHeight;
+    size_t                        maxBufferSize;
+    size_t                        maxArraySize;
+    cl_device_fp_config           singleFpConfig;
+    cl_device_fp_config           halfFpConfig;
+    cl_device_fp_config           doubleFpConfig;
+    cl_ulong                      globalMemCacheSize;
+    cl_ulong                      maxConstantBufferSize;
+    size_t                        maxGlobalVariableSize;
+    size_t                        globalVariablePreferredTotalSize;
+    cl_device_exec_capabilities   executionCapabilities;
+    cl_command_queue_properties   queueOnHostProperties;
+    cl_command_queue_properties   queueOnDeviceProperties;
+    const char                    *builtInKernels;
+    cl_platform_id                platform;
+    const char                    *name;
+    const char                    *vendor;
+    const char                    *driverVersion;
+    const char                    *profile;
+    const char                    *clVersion;
+    const char                    *clCVersion;
+    const char                    *spirVersions;
+    const char                    *deviceExtensions;
+    cl_device_id                  parentDevice;
+    cl_device_affinity_domain     partitionAffinityDomain;
+    cl_uint                       partitionMaxSubDevices;
+    cl_device_partition_property  partitionProperties[2];
+    cl_device_partition_property  partitionType[3];
+    cl_device_svm_capabilities    svmCapabilities;
+    double                        platformHostTimerResolution;
+    size_t                        planarYuvMaxWidth;
+    size_t                        planarYuvMaxHeight;
+    cl_uint                       maxComputUnits;
+    cl_uint                       maxWorkItemDimensions;
+    cl_uint                       maxNumOfSubGroups;
+    cl_bool                       independentForwardProgress;
+    cl_device_atomic_capabilities atomicMemoryCapabilities;
+    cl_device_atomic_capabilities atomicFenceCapabilities;
+    cl_bool                       nonUniformWorkGroupSupport;
+    cl_bool                       workGroupCollectiveFunctionsSupport;
+    cl_bool                       genericAddressSpaceSupport;
+    cl_bool                       deviceEnqueueSupport;
+    cl_bool                       pipeSupport;
+    cl_uint                       preferredVectorWidthChar;
+    cl_uint                       preferredVectorWidthShort;
+    cl_uint                       preferredVectorWidthInt;
+    cl_uint                       preferredVectorWidthLong;
+    cl_uint                       preferredVectorWidthFloat;
+    cl_uint                       preferredVectorWidthDouble;
+    cl_uint                       preferredVectorWidthHalf;
+    cl_uint                       nativeVectorWidthChar;
+    cl_uint                       nativeVectorWidthShort;
+    cl_uint                       nativeVectorWidthInt;
+    cl_uint                       nativeVectorWidthLong;
+    cl_uint                       nativeVectorWidthFloat;
+    cl_uint                       nativeVectorWidthDouble;
+    cl_uint                       nativeVectorWidthHalf;
+    cl_uint                       maxReadWriteImageArgs;
+    cl_uint                       imagePitchAlignment;
+    cl_uint                       imageBaseAddressAlignment;
+    cl_uint                       maxPipeArgs;
+    cl_uint                       pipeMaxActiveReservations;
+    cl_uint                       pipeMaxPacketSize;
+    cl_uint                       memBaseAddressAlign;
+    cl_uint                       minDataTypeAlignSize;
+    cl_device_mem_cache_type      globalMemCacheType;
+    cl_uint                       maxConstantArgs;
+    cl_device_local_mem_type      localMemType;
+    cl_bool                       endianLittle;
+    cl_bool                       deviceAvailable;
+    cl_bool                       compilerAvailable;
+    cl_bool                       linkerAvailable;
+    cl_uint                       queueOnDevicePreferredSize;
+    cl_uint                       queueOnDeviceMaxSize;
+    cl_uint                       maxOnDeviceQueues;
+    cl_uint                       maxOnDeviceEvents;
+    cl_bool                       preferredInteropUserSync;
+    cl_uint                       referenceCount;
+    cl_uint                       preferredPlatformAtomicAlignment;
+    cl_uint                       preferredGlobalAtomicAlignment;
+    cl_uint                       preferredLocalAtomicAlignment;
+    cl_bool                       hostUnifiedMemory;
+    cl_bool                       vmeAvcSupportsTextureSampler;
+    cl_uint                       vmeAvcVersion;
+    cl_uint                       vmeVersion;
+    cl_uint                       internalDriverVersion;
+    cl_uint                       grfSize;
+    bool                          preemptionSupported;
     /* Extensions supported */
-    bool                         nv12Extension;
-    bool                         vmeExtension;
-    bool                         platformLP;
-    bool                         packedYuvExtension;
+    bool                          nv12Extension;
+    bool                          vmeExtension;
+    bool                          platformLP;
+    bool                          packedYuvExtension;
     /*Unified Shared Memory Capabilites*/
     cl_unified_shared_memory_capabilities_intel hostMemCapabilities;
     cl_unified_shared_memory_capabilities_intel deviceMemCapabilities;
diff --git a/opencl/source/cl_device/cl_device_info_map.h b/opencl/source/cl_device/cl_device_info_map.h
index 6eeff2c982..b26aae9e55 100644
--- a/opencl/source/cl_device/cl_device_info_map.h
+++ b/opencl/source/cl_device/cl_device_info_map.h
@@ -79,24 +79,29 @@ template<> struct Map<CL_DEVICE_PRINTF_BUFFER_SIZE              > : public MapBa
 template<> struct Map<CL_DEVICE_PROFILING_TIMER_RESOLUTION      > : public MapBase<CL_DEVICE_PROFILING_TIMER_RESOLUTION,       size_t,       &DeviceInfo::outProfilingTimerResolution> {};
 template<> struct Map<CL_DEVICE_VENDOR_ID                       > : public MapBase<CL_DEVICE_VENDOR_ID,                        uint32_t,     &DeviceInfo::vendorId> {};
 
+template<> struct Map<CL_DEVICE_ATOMIC_FENCE_CAPABILITIES                   > : public ClMapBase<CL_DEVICE_ATOMIC_FENCE_CAPABILITIES,                   uint64_t,                        &ClDeviceInfo::atomicFenceCapabilities> {};
+template<> struct Map<CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES                  > : public ClMapBase<CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES,                  uint64_t,                        &ClDeviceInfo::atomicMemoryCapabilities> {};
 template<> struct Map<CL_DEVICE_AVAILABLE                                   > : public ClMapBase<CL_DEVICE_AVAILABLE,                                   uint32_t,                        &ClDeviceInfo::deviceAvailable> {};
 template<> struct Map<CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL   > : public ClMapBase<CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL,   uint32_t,                        &ClDeviceInfo::vmeAvcSupportsTextureSampler> {};
 template<> struct Map<CL_DEVICE_AVC_ME_VERSION_INTEL                        > : public ClMapBase<CL_DEVICE_AVC_ME_VERSION_INTEL,                        uint32_t,                        &ClDeviceInfo::vmeAvcVersion> {};
 template<> struct Map<CL_DEVICE_BUILT_IN_KERNELS                            > : public ClMapBase<CL_DEVICE_BUILT_IN_KERNELS,                            const char *,                    &ClDeviceInfo::builtInKernels> {};
 template<> struct Map<CL_DEVICE_COMPILER_AVAILABLE                          > : public ClMapBase<CL_DEVICE_COMPILER_AVAILABLE,                          uint32_t,                        &ClDeviceInfo::compilerAvailable> {};
 template<> struct Map<CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL  > : public ClMapBase<CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL,  uint64_t,                        &ClDeviceInfo::crossDeviceSharedMemCapabilities> {};
+template<> struct Map<CL_DEVICE_DEVICE_ENQUEUE_SUPPORT                      > : public ClMapBase<CL_DEVICE_DEVICE_ENQUEUE_SUPPORT,                      uint32_t,                        &ClDeviceInfo::deviceEnqueueSupport> {};
 template<> struct Map<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL               > : public ClMapBase<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL,               uint64_t,                        &ClDeviceInfo::deviceMemCapabilities> {};
 template<> struct Map<CL_DEVICE_DOUBLE_FP_CONFIG                            > : public ClMapBase<CL_DEVICE_DOUBLE_FP_CONFIG,                            uint64_t,                        &ClDeviceInfo::doubleFpConfig> {};
 template<> struct Map<CL_DEVICE_DRIVER_VERSION_INTEL                        > : public ClMapBase<CL_DEVICE_DRIVER_VERSION_INTEL,                        uint32_t,                        &ClDeviceInfo::internalDriverVersion> {};
 template<> struct Map<CL_DEVICE_ENDIAN_LITTLE                               > : public ClMapBase<CL_DEVICE_ENDIAN_LITTLE,                               uint32_t,                        &ClDeviceInfo::endianLittle> {};
 template<> struct Map<CL_DEVICE_EXECUTION_CAPABILITIES                      > : public ClMapBase<CL_DEVICE_EXECUTION_CAPABILITIES,                      uint64_t,                        &ClDeviceInfo::executionCapabilities> {};
 template<> struct Map<CL_DEVICE_EXTENSIONS                                  > : public ClMapBase<CL_DEVICE_EXTENSIONS,                                  const char *,                    &ClDeviceInfo::deviceExtensions> {};
+template<> struct Map<CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT               > : public ClMapBase<CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT,               uint32_t,                        &ClDeviceInfo::genericAddressSpaceSupport> {};
 template<> struct Map<CL_DEVICE_GLOBAL_MEM_CACHE_SIZE                       > : public ClMapBase<CL_DEVICE_GLOBAL_MEM_CACHE_SIZE,                       uint64_t,                        &ClDeviceInfo::globalMemCacheSize> {};
 template<> struct Map<CL_DEVICE_GLOBAL_MEM_CACHE_TYPE                       > : public ClMapBase<CL_DEVICE_GLOBAL_MEM_CACHE_TYPE,                       uint32_t,                        &ClDeviceInfo::globalMemCacheType> {};
 template<> struct Map<CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE        > : public ClMapBase<CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE,        size_t,                          &ClDeviceInfo::globalVariablePreferredTotalSize> {};
 template<> struct Map<CL_DEVICE_HALF_FP_CONFIG                              > : public ClMapBase<CL_DEVICE_HALF_FP_CONFIG,                              uint64_t,                        &ClDeviceInfo::halfFpConfig> {};
 template<> struct Map<CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL                 > : public ClMapBase<CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL,                 uint64_t,                        &ClDeviceInfo::hostMemCapabilities> {};
 template<> struct Map<CL_DEVICE_HOST_UNIFIED_MEMORY                         > : public ClMapBase<CL_DEVICE_HOST_UNIFIED_MEMORY,                         uint32_t,                        &ClDeviceInfo::hostUnifiedMemory> {};
+template<> struct Map<CL_DEVICE_ILS_WITH_VERSION                            > : public ClMapBase<CL_DEVICE_ILS_WITH_VERSION,                            cl_name_version[1],              &ClDeviceInfo::ilsWithVersion> {};
 template<> struct Map<CL_DEVICE_IMAGE3D_MAX_HEIGHT                          > : public ClMapBase<CL_DEVICE_IMAGE3D_MAX_HEIGHT,                          size_t,                          &ClDeviceInfo::image3DMaxHeight> {};
 template<> struct Map<CL_DEVICE_IMAGE3D_MAX_WIDTH                           > : public ClMapBase<CL_DEVICE_IMAGE3D_MAX_WIDTH,                           size_t,                          &ClDeviceInfo::image3DMaxWidth> {};
 template<> struct Map<CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT                > : public ClMapBase<CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT,                uint32_t,                        &ClDeviceInfo::imageBaseAddressAlignment> {};
@@ -123,6 +128,7 @@ template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF                    > :
 template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_INT                     > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_INT,                     uint32_t,                        &ClDeviceInfo::nativeVectorWidthInt> {};
 template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG                    > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG,                    uint32_t,                        &ClDeviceInfo::nativeVectorWidthLong> {};
 template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT                   > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT,                   uint32_t,                        &ClDeviceInfo::nativeVectorWidthShort> {};
+template<> struct Map<CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT              > : public ClMapBase<CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT,              uint32_t,                        &ClDeviceInfo::nonUniformWorkGroupSupport> {};
 template<> struct Map<CL_DEVICE_OPENCL_C_VERSION                            > : public ClMapBase<CL_DEVICE_OPENCL_C_VERSION,                            const char *,                    &ClDeviceInfo::clCVersion> {};
 template<> struct Map<CL_DEVICE_PARENT_DEVICE                               > : public ClMapBase<CL_DEVICE_PARENT_DEVICE,                               cl_device_id,                    &ClDeviceInfo::parentDevice> {};
 template<> struct Map<CL_DEVICE_PARTITION_AFFINITY_DOMAIN                   > : public ClMapBase<CL_DEVICE_PARTITION_AFFINITY_DOMAIN,                   uint64_t,                        &ClDeviceInfo::partitionAffinityDomain> {};
@@ -131,6 +137,7 @@ template<> struct Map<CL_DEVICE_PARTITION_PROPERTIES                        > :
 template<> struct Map<CL_DEVICE_PARTITION_TYPE                              > : public ClMapBase<CL_DEVICE_PARTITION_TYPE,                              cl_device_partition_property[3], &ClDeviceInfo::partitionType> {};
 template<> struct Map<CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS                > : public ClMapBase<CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS,                uint32_t,                        &ClDeviceInfo::pipeMaxActiveReservations> {};
 template<> struct Map<CL_DEVICE_PIPE_MAX_PACKET_SIZE                        > : public ClMapBase<CL_DEVICE_PIPE_MAX_PACKET_SIZE,                        uint32_t,                        &ClDeviceInfo::pipeMaxPacketSize> {};
+template<> struct Map<CL_DEVICE_PIPE_SUPPORT                                > : public ClMapBase<CL_DEVICE_PIPE_SUPPORT,                                uint32_t,                        &ClDeviceInfo::pipeSupport> {};
 template<> struct Map<CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL                 > : public ClMapBase<CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL,                 size_t,                          &ClDeviceInfo::planarYuvMaxHeight> {};
 template<> struct Map<CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL                  > : public ClMapBase<CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL,                  size_t,                          &ClDeviceInfo::planarYuvMaxWidth> {};
 template<> struct Map<CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT           > : public ClMapBase<CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT,           uint32_t,                        &ClDeviceInfo::preferredGlobalAtomicAlignment> {};
@@ -161,6 +168,7 @@ template<> struct Map<CL_DEVICE_TYPE                                        > :
 template<> struct Map<CL_DEVICE_VENDOR                                      > : public ClMapBase<CL_DEVICE_VENDOR,                                      const char *,                    &ClDeviceInfo::vendor> {};
 template<> struct Map<CL_DEVICE_VERSION                                     > : public ClMapBase<CL_DEVICE_VERSION,                                     const char *,                    &ClDeviceInfo::clVersion> {};
 template<> struct Map<CL_DRIVER_VERSION                                     > : public ClMapBase<CL_DRIVER_VERSION,                                     const char *,                    &ClDeviceInfo::driverVersion> {};
+template<> struct Map<CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT     > : public ClMapBase<CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT,     uint32_t,                        &ClDeviceInfo::workGroupCollectiveFunctionsSupport> {};
 // clang-format on
 
 } // namespace ClDeviceInfoTable
diff --git a/opencl/source/context/context.cpp b/opencl/source/context/context.cpp
index b8c3d8645a..2f68993c79 100644
--- a/opencl/source/context/context.cpp
+++ b/opencl/source/context/context.cpp
@@ -285,7 +285,7 @@ cl_int Context::getSupportedImageFormats(
     cl_uint *numImageFormatsReturned) {
     size_t numImageFormats = 0;
 
-    if (flags & CL_MEM_KERNEL_READ_AND_WRITE && device->getSpecializedDevice<ClDevice>()->areOcl21FeaturesEnabled() == false) {
+    if (isValueSet(CL_MEM_KERNEL_READ_AND_WRITE, flags) && device->getSpecializedDevice<ClDevice>()->areOcl21FeaturesEnabled() == false) {
         if (numImageFormatsReturned) {
             *numImageFormatsReturned = static_cast<cl_uint>(numImageFormats);
         }
diff --git a/opencl/test/unit_test/device/get_device_info_tests.cpp b/opencl/test/unit_test/device/get_device_info_tests.cpp
index 5f18c05388..59fbb0cf99 100644
--- a/opencl/test/unit_test/device/get_device_info_tests.cpp
+++ b/opencl/test/unit_test/device/get_device_info_tests.cpp
@@ -535,6 +535,132 @@ TEST(GetDeviceInfo, GivenPreferredInteropsWhenGettingDeviceInfoThenCorrectValueI
     EXPECT_EQ(sizeof(cl_bool), size);
     EXPECT_TRUE(value == 1u);
 }
+TEST(GetDeviceInfo, WhenQueryingIlsWithVersionThenProperValueIsReturned) {
+    auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    cl_name_version ilsWithVersion[1];
+    size_t paramRetSize;
+    const auto retVal = device->getDeviceInfo(CL_DEVICE_ILS_WITH_VERSION, sizeof(ilsWithVersion), &ilsWithVersion,
+                                              &paramRetSize);
+
+    if (device->areOcl21FeaturesSupported()) {
+        EXPECT_EQ(CL_SUCCESS, retVal);
+        EXPECT_EQ(sizeof(cl_name_version), paramRetSize);
+        EXPECT_EQ(CL_MAKE_VERSION(1u, 2u, 0u), ilsWithVersion->version);
+        EXPECT_STREQ("SPIR-V_1.2 ", ilsWithVersion->name);
+    } else {
+        EXPECT_EQ(CL_SUCCESS, retVal);
+        EXPECT_EQ(0u, paramRetSize);
+    }
+}
+
+TEST(GetDeviceInfo, WhenQueryingAtomicMemoryCapabilitiesThenProperValueIsReturned) {
+    auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    cl_device_atomic_capabilities atomicMemoryCapabilities;
+    size_t paramRetSize;
+    const auto retVal = device->getDeviceInfo(CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES, sizeof(cl_device_atomic_capabilities),
+                                              &atomicMemoryCapabilities, &paramRetSize);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ(sizeof(cl_device_atomic_capabilities), paramRetSize);
+
+    cl_device_atomic_capabilities expectedCapabilities = CL_DEVICE_ATOMIC_ORDER_RELAXED | CL_DEVICE_ATOMIC_SCOPE_WORK_GROUP;
+    if (device->areOcl21FeaturesSupported()) {
+        expectedCapabilities |= CL_DEVICE_ATOMIC_ORDER_ACQ_REL | CL_DEVICE_ATOMIC_ORDER_SEQ_CST |
+                                CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES | CL_DEVICE_ATOMIC_SCOPE_DEVICE;
+    }
+    EXPECT_EQ(expectedCapabilities, atomicMemoryCapabilities);
+}
+
+TEST(GetDeviceInfo, WhenQueryingAtomicFenceCapabilitiesThenProperValueIsReturned) {
+    auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    cl_device_atomic_capabilities atomicFenceCapabilities;
+    size_t paramRetSize;
+    const auto retVal = device->getDeviceInfo(CL_DEVICE_ATOMIC_FENCE_CAPABILITIES, sizeof(cl_device_atomic_capabilities),
+                                              &atomicFenceCapabilities, &paramRetSize);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ(sizeof(cl_device_atomic_capabilities), paramRetSize);
+
+    cl_device_atomic_capabilities expectedCapabilities = CL_DEVICE_ATOMIC_ORDER_RELAXED | CL_DEVICE_ATOMIC_ORDER_ACQ_REL |
+                                                         CL_DEVICE_ATOMIC_SCOPE_WORK_GROUP;
+    if (device->areOcl21FeaturesSupported()) {
+        expectedCapabilities |= CL_DEVICE_ATOMIC_ORDER_SEQ_CST | CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES |
+                                CL_DEVICE_ATOMIC_SCOPE_DEVICE | CL_DEVICE_ATOMIC_SCOPE_WORK_ITEM;
+    }
+    EXPECT_EQ(expectedCapabilities, atomicFenceCapabilities);
+}
+
+TEST(GetDeviceInfo, WhenQueryingDeviceEnqueueSupportThenProperValueIsReturned) {
+    UltClDeviceFactory deviceFactory{1, 0};
+
+    cl_bool deviceEnqueueSupport;
+    size_t paramRetSize;
+    const auto retVal = deviceFactory.rootDevices[0]->getDeviceInfo(CL_DEVICE_DEVICE_ENQUEUE_SUPPORT, sizeof(cl_bool),
+                                                                    &deviceEnqueueSupport, &paramRetSize);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ(sizeof(cl_bool), paramRetSize);
+
+    cl_bool expectedDeviceEnqueueSupport = deviceFactory.rootDevices[0]->isDeviceEnqueueSupported() ? CL_TRUE : CL_FALSE;
+    EXPECT_EQ(expectedDeviceEnqueueSupport, deviceEnqueueSupport);
+}
+
+TEST(GetDeviceInfo, WhenQueryingPipesSupportThenProperValueIsReturned) {
+    UltClDeviceFactory deviceFactory{1, 0};
+
+    cl_bool pipesSupport;
+    size_t paramRetSize;
+    const auto retVal = deviceFactory.rootDevices[0]->getDeviceInfo(CL_DEVICE_PIPE_SUPPORT, sizeof(cl_bool),
+                                                                    &pipesSupport, &paramRetSize);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ(sizeof(cl_bool), paramRetSize);
+
+    cl_bool expectedPipesSupport = deviceFactory.rootDevices[0]->arePipesSupported() ? CL_TRUE : CL_FALSE;
+    EXPECT_EQ(expectedPipesSupport, pipesSupport);
+}
+
+TEST(GetDeviceInfo, WhenQueryingNonUniformWorkGroupSupportThenProperValueIsReturned) {
+    UltClDeviceFactory deviceFactory{1, 0};
+
+    cl_bool nonUniformGroupSupport;
+    size_t paramRetSize;
+    const auto retVal = deviceFactory.rootDevices[0]->getDeviceInfo(CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT, sizeof(cl_bool),
+                                                                    &nonUniformGroupSupport, &paramRetSize);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ(sizeof(cl_bool), paramRetSize);
+
+    cl_bool expectedNonUniformGroupSupport = deviceFactory.rootDevices[0]->areOcl21FeaturesSupported() ? CL_TRUE : CL_FALSE;
+    EXPECT_EQ(expectedNonUniformGroupSupport, nonUniformGroupSupport);
+}
+
+TEST(GetDeviceInfo, WhenQueryingWorkGroupCollectiveFunctionsSupportThenProperValueIsReturned) {
+    UltClDeviceFactory deviceFactory{1, 0};
+
+    cl_bool workGroupCollectiveFunctionsSupport;
+    size_t paramRetSize;
+    const auto retVal = deviceFactory.rootDevices[0]->getDeviceInfo(CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT, sizeof(cl_bool),
+                                                                    &workGroupCollectiveFunctionsSupport, &paramRetSize);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ(sizeof(cl_bool), paramRetSize);
+
+    cl_bool expectedWorkGroupCollectiveFunctionsSupport =
+        deviceFactory.rootDevices[0]->areOcl21FeaturesSupported() ? CL_TRUE : CL_FALSE;
+    EXPECT_EQ(expectedWorkGroupCollectiveFunctionsSupport, workGroupCollectiveFunctionsSupport);
+}
+
+TEST(GetDeviceInfo, WhenQueryingGenericAddressSpaceSupportThenProperValueIsReturned) {
+    UltClDeviceFactory deviceFactory{1, 0};
+
+    cl_bool genericAddressSpaceSupport;
+    size_t paramRetSize;
+    const auto retVal = deviceFactory.rootDevices[0]->getDeviceInfo(CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT, sizeof(cl_bool),
+                                                                    &genericAddressSpaceSupport, &paramRetSize);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ(sizeof(cl_bool), paramRetSize);
+
+    cl_bool expectedGenericAddressSpaceSupport = deviceFactory.rootDevices[0]->areOcl21FeaturesSupported() ? CL_TRUE : CL_FALSE;
+    EXPECT_EQ(expectedGenericAddressSpaceSupport, genericAddressSpaceSupport);
+}
 
 struct GetDeviceInfo : public ::testing::TestWithParam<uint32_t /*cl_device_info*/> {
     void SetUp() override {