Index: openmp/libomptarget/include/interop.h
===================================================================
--- openmp/libomptarget/include/interop.h
+++ openmp/libomptarget/include/interop.h
@@ -143,6 +143,8 @@
 typedef enum omp_interop_backend_type_t {
   // reserve 0
   omp_interop_backend_type_cuda_1 = 1,
+
+  omp_interop_backend_type_hip_1 = 5
 } omp_interop_backend_type_t;
 
 typedef enum kmp_interop_type_t {
@@ -152,27 +154,21 @@
   kmp_interop_type_tasksync,
 } kmp_interop_type_t;
 
-typedef enum omp_foreign_runtime_ids {
-  cuda = 1,
-  cuda_driver = 2,
-  opencl = 3,
-  sycl = 4,
-  hip = 5,
-  level_zero = 6,
-} omp_foreign_runtime_ids_t;
-
 /// The interop value type, aka. the interop object.
 typedef struct omp_interop_val_t {
   /// Device and interop-type are determined at construction time and fix.
-  omp_interop_val_t(intptr_t device_id, kmp_interop_type_t interop_type)
-      : interop_type(interop_type), device_id(device_id) {}
+  omp_interop_val_t(intptr_t device_id, kmp_interop_type_t interop_type,
+                    omp_foreign_runtime_ids_t vendor_id,
+                    intptr_t backend_type_id)
+      : interop_type(interop_type), device_id(device_id), vendor_id(vendor_id),
+        backend_type_id(backend_type_id) {}
   const char *err_str = nullptr;
   __tgt_async_info *async_info = nullptr;
   __tgt_device_info device_info;
   const kmp_interop_type_t interop_type;
   const intptr_t device_id;
-  const omp_foreign_runtime_ids_t vendor_id = cuda;
-  const intptr_t backend_type_id = omp_interop_backend_type_cuda_1;
+  const omp_foreign_runtime_ids_t vendor_id;
+  const intptr_t backend_type_id;
 } omp_interop_val_t;
 
 #ifdef __cplusplus
Index: openmp/libomptarget/include/omptarget.h
===================================================================
--- openmp/libomptarget/include/omptarget.h
+++ openmp/libomptarget/include/omptarget.h
@@ -350,6 +350,17 @@
 void __tgt_set_info_flag(uint32_t);
 
 int __tgt_print_device_info(int64_t DeviceId);
+
+typedef enum omp_foreign_runtime_ids {
+  invalid = 0,
+  cuda = 1,
+  cuda_driver = 2,
+  opencl = 3,
+  sycl = 4,
+  hip = 5,
+  level_zero = 6,
+} omp_foreign_runtime_ids_t;
+
 #ifdef __cplusplus
 }
 #endif
Index: openmp/libomptarget/include/omptargetplugin.h
===================================================================
--- openmp/libomptarget/include/omptargetplugin.h
+++ openmp/libomptarget/include/omptargetplugin.h
@@ -162,6 +162,9 @@
 // Print the device information
 void __tgt_rtl_print_device_info(int32_t ID);
 
+// Retrieve backend driver information
+void __tgt_rtl_get_driver_info(int32_t *DriverInfo);
+
 // Event related interfaces. It is expected to use the interfaces in the
 // following way:
 // 1) Create an event on the target device (__tgt_rtl_create_event).
Index: openmp/libomptarget/include/rtl.h
===================================================================
--- openmp/libomptarget/include/rtl.h
+++ openmp/libomptarget/include/rtl.h
@@ -65,6 +65,7 @@
   typedef int32_t (*register_lib_ty)(__tgt_bin_desc *);
   typedef int32_t(supports_empty_images_ty)();
   typedef void(print_device_info_ty)(int32_t);
+  typedef void(get_driver_info_ty)(int32_t *);
   typedef void(set_info_flag_ty)(uint32_t);
   typedef int32_t(create_event_ty)(int32_t, void **);
   typedef int32_t(record_event_ty)(int32_t, void *, __tgt_async_info *);
@@ -117,6 +118,7 @@
   supports_empty_images_ty *supports_empty_images = nullptr;
   set_info_flag_ty *set_info_flag = nullptr;
   print_device_info_ty *print_device_info = nullptr;
+  get_driver_info_ty *get_driver_info = nullptr;
   create_event_ty *create_event = nullptr;
   record_event_ty *record_event = nullptr;
   wait_event_ty *wait_event = nullptr;
Index: openmp/libomptarget/plugins/amdgpu/src/rtl.cpp
===================================================================
--- openmp/libomptarget/plugins/amdgpu/src/rtl.cpp
+++ openmp/libomptarget/plugins/amdgpu/src/rtl.cpp
@@ -2681,4 +2681,62 @@
   DeviceInfo().printDeviceInfo(DeviceId, DeviceInfo().HSAAgents[DeviceId]);
 }
 
+int32_t __tgt_rtl_init_async_info(int32_t DeviceId,
+                                  __tgt_async_info **AsyncInfo) {
+  assert(DeviceInfo().isValidDeviceId(DeviceId) && "device_id is invalid");
+  assert(AsyncInfo && "async_info is nullptr");
+
+  if ((int)(DeviceInfo().HSAQueueSchedulers.size()) < DeviceId) {
+    // If the cooresponding device is not available, then set the error code to
+    // Queue field
+    (*AsyncInfo)->Queue = nullptr;
+
+    return OFFLOAD_FAIL;
+  } else {
+    // Retrieve the queue from per−device based HSA queue scheduler
+    hsa_queue_t *Queue = DeviceInfo().HSAQueueSchedulers[DeviceId].next();
+    *AsyncInfo = new __tgt_async_info();
+    if (!Queue) {
+      // If the queue object is not available , then set the error code to Queue
+      // field
+      (*AsyncInfo)->Queue = nullptr;
+
+      return OFFLOAD_FAIL;
+    } else {
+      (*AsyncInfo)->Queue = Queue;
+    }
+  }
+
+  return OFFLOAD_SUCCESS;
+}
+
+int32_t __tgt_rtl_init_device_info(int32_t DeviceId,
+                                   __tgt_device_info *DeviceInfoPtr,
+                                   const char **ErrStr) {
+  assert(DeviceInfo().isValidDeviceId(DeviceId) && "device_id is invalid");
+  assert(DeviceInfoPtr && "device_info_ptr is nullptr");
+
+  DeviceInfoPtr->Context = nullptr;
+  if ((int)(DeviceInfo().HSAAgents.size()) < DeviceId) {
+    // If the cooresponding device is not available, then set device as null
+    DeviceInfoPtr->Device = nullptr;
+
+    return OFFLOAD_FAIL;
+  } else {
+    // Retrieve the HSA agent from per−device based HSA agent list
+    hsa_agent_t &Agent = DeviceInfo().HSAAgents[DeviceId];
+    if (!DeviceInfoPtr->Device) {
+      DeviceInfoPtr->Device = &Agent;
+    }
+  }
+
+  return OFFLOAD_SUCCESS;
+}
+
+EXTERN void __tgt_rtl_get_driver_info(int32_t *driverTy) {
+  // Specify the driver type as HIP related
+  *driverTy = hip;
+
+  return;
+}
 } // extern "C"
Index: openmp/libomptarget/plugins/cuda/src/rtl.cpp
===================================================================
--- openmp/libomptarget/plugins/cuda/src/rtl.cpp
+++ openmp/libomptarget/plugins/cuda/src/rtl.cpp
@@ -1869,6 +1869,13 @@
   return DeviceRTL.initDeviceInfo(DeviceId, DeviceInfoPtr, ErrStr);
 }
 
+EXTERN void __tgt_rtl_get_driver_info(int32_t *driverTy) {
+  // Specify the driver type as CUDA related
+  *driverTy = cuda;
+
+  return;
+}
+
 #ifdef __cplusplus
 }
 #endif
Index: openmp/libomptarget/src/interop.cpp
===================================================================
--- openmp/libomptarget/src/interop.cpp
+++ openmp/libomptarget/src/interop.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "interop.h"
+#include "omptargetplugin.h"
 #include "private.h"
 
 namespace {
@@ -87,6 +88,7 @@
                ? "tasksync"
                : "device+context";
   case omp_ipr_vendor_name:
+  case omp_ipr_fr_name:
     return getVendorIdToStr(InteropVal.vendor_id);
   default:
     getTypeMismatch(Property, Err);
@@ -107,6 +109,10 @@
     return InteropVal.device_info.Context;
   case omp_ipr_targetsync:
     return InteropVal.async_info->Queue;
+
+  case omp_ipr_fr_id:
+  case omp_ipr_fr_name:
+
   default:;
   }
   getTypeMismatch(Property, Err);
@@ -199,19 +205,45 @@
                          NoaliasDepList);
   }
 
-  InteropPtr = new omp_interop_val_t(DeviceId, InteropType);
   if (!deviceIsReady(DeviceId)) {
+    InteropPtr = new omp_interop_val_t(DeviceId, InteropType, invalid, 0);
     InteropPtr->err_str = "Device not ready!";
     return;
   }
 
   DeviceTy &Device = *PM->Devices[DeviceId];
   if (!Device.RTL || !Device.RTL->init_device_info ||
-      Device.RTL->init_device_info(DeviceId, &(InteropPtr)->device_info,
+      !Device.RTL->get_driver_info) {
+    delete InteropPtr;
+    InteropPtr = omp_interop_none;
+
+    return;
+  }
+
+  int RTTy = 0;
+  Device.RTL->get_driver_info(&RTTy);
+
+  if (RTTy == hip) {
+    InteropPtr = new omp_interop_val_t(DeviceId, InteropType, hip,
+                                       omp_interop_backend_type_hip_1);
+  } else {
+    InteropPtr = new omp_interop_val_t(DeviceId, InteropType, cuda,
+                                       omp_interop_backend_type_cuda_1);
+  }
+  // InteropPtr = new omp_interop_val_t(DeviceId, InteropType);
+  if (Device.RTL->init_device_info(DeviceId, &(InteropPtr)->device_info,
                                    &(InteropPtr)->err_str)) {
     delete InteropPtr;
     InteropPtr = omp_interop_none;
+
+    return;
+  }
+
+  if (!deviceIsReady(DeviceId)) {
+    InteropPtr->err_str = "Device not ready!";
+    return;
   }
+
   if (InteropType == kmp_interop_type_tasksync) {
     if (!Device.RTL || !Device.RTL->init_async_info ||
         Device.RTL->init_async_info(DeviceId, &(InteropPtr)->async_info)) {
Index: openmp/libomptarget/src/rtl.cpp
===================================================================
--- openmp/libomptarget/src/rtl.cpp
+++ openmp/libomptarget/src/rtl.cpp
@@ -228,6 +228,8 @@
       DynLibrary->getAddressOfSymbol("__tgt_rtl_set_info_flag");
   *((void **)&RTL.print_device_info) =
       DynLibrary->getAddressOfSymbol("__tgt_rtl_print_device_info");
+  *((void **)&RTL.get_driver_info) =
+      DynLibrary->getAddressOfSymbol("__tgt_rtl_get_driver_info");
   *((void **)&RTL.create_event) =
       DynLibrary->getAddressOfSymbol("__tgt_rtl_create_event");
   *((void **)&RTL.record_event) =