completed thesisHEADmaster

12 files changed, 2363 insertions, 0 deletions

diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/.gitignore b/python/openvino/runtime/coredla_device/mmd/hps_platform/.gitignore
new file mode 100644
index 0000000..0948b39
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/.gitignore
@@ -0,0 +1,20 @@
+*~
+*#
+*.marks
+release_build/
+build/
+example_designs/mem_bandwidth/bin/
+example_designs/mem_bandwidth/simulation.tar.gz
+example_designs/mem_bandwidth/temp_simulation/
+linux64/lib/
+linux64/libexec/diagnose
+linux64/libexec/program
+ase/mpf_src
+*.pyc
+*.swp
+*.kwlp
+*.kwps
+temp_simulation/
+simulation.tar.gz
+
+backup
diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/CMakeLists.txt b/python/openvino/runtime/coredla_device/mmd/hps_platform/CMakeLists.txt
new file mode 100644
index 0000000..d8bf50d
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/CMakeLists.txt
@@ -0,0 +1,59 @@
+# (C) 2017 Intel Corporation. All rights reserved.
+# Your use of Intel Corporation's design tools, logic functions and other
+# software and tools, and its AMPP partner logic functions, and any output
+# files any of the foregoing (including device programming or simulation
+# files), and any associated documentation or information are expressly subject
+# to the terms and conditions of the Intel Program License Subscription
+# Agreement, Intel MegaCore Function License Agreement, or other applicable
+# license agreement, including, without limitation, that your use is for the
+# sole purpose of programming logic devices manufactured by Intel and sold by
+# Intel or its authorized distributors.  Please refer to the applicable
+# agreement for further details.
+
+cmake_minimum_required(VERSION 2.8.12)
+project(mmd)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
+
+# DLA specific modifications made to the MMD
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDLA_MMD")
+
+# Select PCIE Gen3 x8
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGEN3_x8")
+
+# from the opencl makefile
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DKERNEL_64BIT -DOPTION3=1 -DACL_USE_DMA=1 -DACL_COMPILER_IS_MSVC=0 -Wall -Wno-unknown-pragmas -DACL_HAS_STDLIB_STDIO")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector -Wformat -Wformat-security -D_GLIBCXX_USE_CXX11_ABI=0 -fPIC -DACL_HOST_RUNTIME_IS_STATIC=0")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DACL_OPENCL_HOST_SYS=linux -DACL_OPENCL_HOST_BIT=64 -DACL_TARGET_SYS=linux -DACL_TARGET_BIT=64 -DLINUX -DACL_MAX_DEVICE=128")
+
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2 -O3")
+enable_language(C ASM)
+
+set(ASM_OPTIONS "-x assembler-with-cpp")
+if(${CMAKE_C_COMPILER_ID} STREQUAL "Clang")
+  set(ASM_OPTIONS "${ASM_OPTIONS} -no-integrated-as")
+endif()
+
+set(CMAKE_ASM_FLAGS "${CFLAGS} ${ASM_OPTIONS}")
+
+if(RUNTIME_POLLING)
+  add_definitions(-DRUNTIME_POLLING)
+endif(RUNTIME_POLLING)
+
+set(MMD_SRC
+   ./host/acl_hps.cpp
+   ./host/mmd_device.cpp
+   ./host/dma_device.cpp
+   ./host/uio_device.cpp
+)
+
+add_library(hps_platform_mmd SHARED ${MMD_SRC})
+
+target_include_directories(hps_platform_mmd PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+target_link_libraries(hps_platform_mmd)
+
+install(TARGETS hps_platform_mmd
+   LIBRARY DESTINATION lib
+   COMPONENT hps_platform_mmd
+)
diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/host/acl_hps.cpp b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/acl_hps.cpp
new file mode 100644
index 0000000..53055ef
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/acl_hps.cpp
@@ -0,0 +1,473 @@
+// (c) 1992-2021 Intel Corporation.
+// Intel, the Intel logo, Intel, MegaCore, NIOS II, Quartus and TalkBack words
+// and logos are trademarks of Intel Corporation or its subsidiaries in the U.S.
+// and/or other countries. Other marks and brands may be claimed as the property
+// of others. See Trademarks on intel.com for full list of Intel trademarks or
+// the Trademarks & Brands Names Database (if Intel) or See www.Intel.com/legal (if Altera)
+// Your use of Intel Corporation's design tools, logic functions and other
+// software and tools, and its AMPP partner logic functions, and any output
+// files any of the foregoing (including device programming or simulation
+// files), and any associated documentation or information are expressly subject
+// to the terms and conditions of the Altera Program License Subscription
+// Agreement, Intel MegaCore Function License Agreement, or other applicable
+// license agreement, including, without limitation, that your use is for the
+// sole purpose of programming logic devices manufactured by Intel and sold by
+// Intel or its authorized distributors.  Please refer to the applicable
+// agreement for further details.
+
+/* ===- HPS.cpp  ------------------------------------------------- C++ -*-=== */
+/*                                                                                 */
+/*                         Intel(R) HPS MMD Driver                                */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+/*                                                                                 */
+/* This file implements the functions that are defined in aocl_mmd.h               */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+
+// common and its own header files
+#include "acl_hps.h"
+
+// other standard header files
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <memory>
+#include <map>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "mmd_device.h"
+
+#ifdef DLA_MMD
+#include <chrono>
+#include <thread>
+#endif
+
+#if defined(LINUX)
+#include <fcntl.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <unistd.h>
+#endif  // LINUX
+
+#define MAX_HPS_FPGA_DEVICES (1)
+
+// MAX size of line read from pipe-ing the output of system call to MMD
+#define BUF_SIZE 1024
+// MAX size of command passed to system for invoking system call from MMD
+#define SYSTEM_CMD_SIZE 4 * 1024
+
+#ifndef DLA_MMD
+// static helper functions
+static bool blob_has_elf_signature(void *data, size_t data_size);
+#endif
+
+
+// Function to return the number of boards installed in the system
+unsigned int get_offline_num_boards() {
+  board_names names = mmd_get_devices(MAX_HPS_FPGA_DEVICES);
+  return (unsigned int)names.size();
+}
+
+// Get information about the board using the enum aocl_mmd_offline_info_t for
+// offline info (called without a handle), and the enum aocl_mmd_info_t for
+// info specific to a certain board.
+#define RESULT_INT(X)                                  \
+  {                                                    \
+    *((int *)param_value) = X;                         \
+    if (param_size_ret) *param_size_ret = sizeof(int); \
+  }
+#define RESULT_UNSIGNED(X)                                  \
+  {                                                         \
+    *((unsigned *)param_value) = X;                         \
+    if (param_size_ret) *param_size_ret = sizeof(unsigned); \
+  }
+#define RESULT_SIZE_T(X)                                  \
+  {                                                       \
+    *((size_t *)param_value) = X;                         \
+    if (param_size_ret) *param_size_ret = sizeof(size_t); \
+  }
+#if defined(WINDOWS)
+#define RESULT_STR(X)                                                                                         \
+  do {                                                                                                        \
+    size_t Xlen = strnlen(X, MAX_NAME_SIZE) + 1;                                                              \
+    memcpy_s((void *)param_value, param_value_size, X, (param_value_size <= Xlen) ? param_value_size : Xlen); \
+    if (param_size_ret) *param_size_ret = Xlen;                                                               \
+  } while (0)
+#else
+#define RESULT_STR(X)                                                                     \
+  do {                                                                                    \
+    size_t Xlen = strnlen(X, MAX_NAME_SIZE) + 1;                                          \
+    memcpy((void *)param_value, X, (param_value_size <= Xlen) ? param_value_size : Xlen); \
+    if (param_size_ret) *param_size_ret = Xlen;                                           \
+  } while (0)
+#endif
+#define ACL_VENDOR_NAME "Intel"
+int aocl_mmd_get_offline_info(aocl_mmd_offline_info_t requested_info_id,
+                              size_t param_value_size,
+                              void *param_value,
+                              size_t *param_size_ret) {
+  unsigned int num_boards;
+  switch (requested_info_id) {
+    case AOCL_MMD_VERSION:
+      RESULT_STR(MMD_VERSION);
+      break;
+    case AOCL_MMD_NUM_BOARDS: {
+      num_boards = MAX_HPS_FPGA_DEVICES;
+      RESULT_INT((int)num_boards);
+      break;
+    }
+    case AOCL_MMD_BOARD_NAMES: {
+      // Retrieve all the CoreDLA cores in the system
+      board_names names = mmd_get_devices(MAX_HPS_FPGA_DEVICES);
+      // Construct a list of all possible devices supported by this MMD layer
+      std::ostringstream board;
+      auto name = names.begin();
+      while(name != names.end() )
+      {
+        board << *name;
+        name++;
+        if( name != names.end() )
+        {
+          board << ";";
+        }
+      }
+
+      RESULT_STR(board.str().c_str());
+      break;
+    }
+    case AOCL_MMD_VENDOR_NAME: {
+      RESULT_STR(ACL_VENDOR_NAME);
+      break;
+    }
+    case AOCL_MMD_VENDOR_ID:
+      RESULT_INT(0);
+      break;
+    case AOCL_MMD_USES_YIELD:
+      RESULT_INT(0); /* TODO: Can we yield? */
+      break;
+    case AOCL_MMD_MEM_TYPES_SUPPORTED:
+      RESULT_INT(AOCL_MMD_PHYSICAL_MEMORY); /* TODO: Confirm this is the right memory type */
+      break;
+  }
+  return 0;
+}
+
+// If the MMD is loaded dynamically, destructors in the MMD will execute before the destructors in the runtime
+// upon program termination. The DeviceMapManager guards accesses to the device/handle maps to make sure
+// the runtime doesn't get to reference them after MMD destructors have been called.
+// Destructor makes sure that all devices are closed at program termination regardless of what the runtime does.
+// Implemented as a singleton.
+class DeviceMapManager final {
+public:
+  typedef std::map<int, mmd_device_ptr> map_handle_to_dev_t;
+  ~DeviceMapManager()
+  {
+  }
+
+  int add_device(const char *name)
+  {
+    int handle = idx++;
+
+    mmd_device_ptr spDevice = std::make_shared<mmd_device>(name, handle);
+    if( spDevice->bValid() )
+    {
+      auto it = handle_to_dev.find(handle);
+      HPS_ERROR_IF( it != handle_to_dev.end(), return FAILURE, "Error: Handle already used.\n" );
+      handle_to_dev.insert({handle, spDevice});
+      return handle;
+    }
+    return FAILURE;
+  }
+
+  mmd_device_ptr get_device(const int handle)
+  {
+    auto it = handle_to_dev.find(handle);
+    HPS_ERROR_IF( it == handle_to_dev.end(), return nullptr, "Error: Invalid handle.\n" );
+    return it->second;
+  }
+
+  bool remove_device(const int handle)
+  {
+    auto it = handle_to_dev.find(handle);
+    HPS_ERROR_IF( it == handle_to_dev.end(), return false, "Error: Handle does not exist.\n" );
+    handle_to_dev.erase(it);
+    return true;
+  }
+
+  DeviceMapManager()
+  {
+  }
+private:
+  map_handle_to_dev_t handle_to_dev = {};
+  int                 idx = {0};
+};
+static DeviceMapManager _gDeviceMapManager;
+
+int aocl_mmd_get_info(
+  int handle, aocl_mmd_info_t requested_info_id, size_t param_value_size, void *param_value, size_t *param_size_ret) {
+  HPS_ERROR_IF(true,
+                    return FAILURE,
+                    "aocl_mmd_get_info not supported on platform. \n");
+}
+
+#undef RESULT_INT
+#undef RESULT_STR
+
+
+// Open and initialize the named device.
+int AOCL_MMD_CALL aocl_mmd_open(const char *name) {
+  return _gDeviceMapManager.add_device(name);
+}
+
+// Close an opened device, by its handle.
+int AOCL_MMD_CALL aocl_mmd_close(int handle) {
+  if ( _gDeviceMapManager.remove_device(handle) )
+    return SUCCESS;
+  return FAILURE;
+}
+
+// Set the interrupt handler for the opened device.
+int AOCL_MMD_CALL aocl_mmd_set_interrupt_handler(int handle, aocl_mmd_interrupt_handler_fn fn, void *user_data) {
+  mmd_device_ptr spDevice = _gDeviceMapManager.get_device(handle);
+  if( nullptr == spDevice ) {
+    return FAILURE;
+  }
+  return spDevice->set_interrupt_handler(fn, user_data);
+}
+
+// Set the device interrupt handler for the opened device.
+int AOCL_MMD_CALL aocl_mmd_set_device_interrupt_handler(int handle,
+                                                        aocl_mmd_device_interrupt_handler_fn fn,
+                                                        void *user_data) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  return -1;
+}
+
+// Set the operation status handler for the opened device.
+int AOCL_MMD_CALL aocl_mmd_set_status_handler(int handle, aocl_mmd_status_handler_fn fn, void *user_data) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+ return -1;
+}
+
+// Called when the host is idle and hence possibly waiting for events to be
+// processed by the device
+int AOCL_MMD_CALL aocl_mmd_yield(int handle)
+{
+      printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  return -1;
+}
+
+// Read, write and copy operations on a single interface.
+int AOCL_MMD_CALL aocl_mmd_read(int handle, aocl_mmd_op_t op, size_t len, void *dst, int mmd_interface, size_t offset) {
+  mmd_device_ptr spDevice = _gDeviceMapManager.get_device(handle);
+  if( nullptr == spDevice ) {
+    return FAILURE;
+  }
+  return spDevice->read_block(op, mmd_interface, dst, offset, len);
+}
+
+int AOCL_MMD_CALL
+aocl_mmd_write(int handle, aocl_mmd_op_t op, size_t len, const void *src, int mmd_interface, size_t offset) {
+  mmd_device_ptr spDevice = _gDeviceMapManager.get_device(handle);
+  if( nullptr == spDevice ) {
+    return FAILURE;
+  }
+  return spDevice->write_block(op, mmd_interface, src, offset, len);
+}
+
+int AOCL_MMD_CALL
+aocl_mmd_copy(int handle, aocl_mmd_op_t op, size_t len, int mmd_interface, size_t src_offset, size_t dst_offset) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  /* Not called by CoreDLA, so not implementing */
+  return -1;
+}
+
+// Initialize host channel specified in channel_name
+int AOCL_MMD_CALL aocl_mmd_hostchannel_create(int handle, char *channel_name, size_t queue_depth, int direction) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  /* Not called by CoreDLA, so not implementing */
+  return -1;
+}
+
+// reset the host channel specified with channel handle
+int AOCL_MMD_CALL aocl_mmd_hostchannel_destroy(int handle, int channel) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  /* Not called by CoreDLA, so not implementing */
+  return -1;
+}
+
+// Get the pointer to buffer the user can write/read from the kernel with
+AOCL_MMD_CALL void *aocl_mmd_hostchannel_get_buffer(int handle, int channel, size_t *buffer_size, int *status) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  /* Not called by CoreDLA, so not implementing */
+  return NULL;
+}
+
+// Acknolwedge from the user that they have written/read send_size amount of buffer obtained from get_buffer
+size_t AOCL_MMD_CALL aocl_mmd_hostchannel_ack_buffer(int handle, int channel, size_t send_size, int *status) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  /* Not called by CoreDLA, so not implementing */
+  return -1;
+}
+
+#ifdef DLA_MMD
+// Reprogram the device given the sof file name
+int AOCL_MMD_CALL aocl_mmd_program_sof(int handle, const char *sof_filename) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  /* We don't support reprogramming the SOF on a HPS device */
+  return -1;
+}
+#else
+// Reprogram the device based on the program mode
+int AOCL_MMD_CALL aocl_mmd_program(int handle, void *data, size_t data_size, aocl_mmd_program_mode_t program_mode) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  /* We don't support reprogramming the SOF on a HPS device */
+  return -1;
+}
+#endif
+// Shared memory allocator
+AOCL_MMD_CALL void *aocl_mmd_shared_mem_alloc(int handle, size_t size, unsigned long long *device_ptr_out) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  /* Not called by CoreDLA, so not implementing */
+  return NULL;
+}
+
+// Shared memory de-allocator
+AOCL_MMD_CALL void aocl_mmd_shared_mem_free(int handle, void *host_ptr, size_t size) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  /* Not called by CoreDLA, so not implementing */
+  return;
+}
+
+#ifndef DLA_MMD
+// This function checks if the input data has an ELF-formatted blob.
+// Return true when it does.
+static bool blob_has_elf_signature(void *data, size_t data_size) {
+  bool result = false;
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  if (data && data_size > 4) {
+    unsigned char *cdata = (unsigned char *)data;
+    const unsigned char elf_signature[4] = {0177, 'E', 'L', 'F'};  // Little endian
+    result = (cdata[0] == elf_signature[0]) && (cdata[1] == elf_signature[1]) && (cdata[2] == elf_signature[2]) &&
+             (cdata[3] == elf_signature[3]);
+  }
+  return result;
+}
+#endif
+
+// Return a positive number when single device open. Otherwise, return -1
+AOCL_MMD_CALL int get_open_handle() {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  return -1;
+}
+
+AOCL_MMD_CALL void *aocl_mmd_host_alloc(int *handles,
+                                        size_t num_devices,
+                                        size_t size,
+                                        size_t alignment,
+                                        aocl_mmd_mem_properties_t *properties,
+                                        int *error) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  // Not supported on this BSP
+  return NULL;
+}
+
+AOCL_MMD_CALL int aocl_mmd_free(void *mem) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  // Not supported on this BSP
+  return 0;
+}
+
+AOCL_MMD_CALL void *aocl_mmd_device_alloc(
+    int handle, size_t size, size_t alignment, aocl_mmd_mem_properties_t *properties, int *error) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  // Not supported on this BSP
+  return NULL;
+}
+
+AOCL_MMD_CALL void *aocl_mmd_shared_alloc(
+    int handle, size_t size, size_t alignment, aocl_mmd_mem_properties_t *properties, int *error) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  // Not supported on this BSP
+  return NULL;
+}
+
+AOCL_MMD_CALL int aocl_mmd_shared_migrate(int handle, void *shared_ptr, size_t size, aocl_mmd_migrate_t destination) {
+    printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__);
+  // Not supported on this BSP
+  return 0;
+}
+
+#ifdef DLA_MMD
+// Query functions to get board-specific values
+AOCL_MMD_CALL int dla_mmd_get_max_num_instances()
+{
+  return 1;
+}
+
+AOCL_MMD_CALL uint64_t dla_mmd_get_ddr_size_per_instance() {
+  return 1ULL << 29;
+}
+
+// AGX7 HPS board uses 333.3325 MHz (1333.33/4) for the DLA DDR Clock
+// All other boards use 266.666666 MHz (1066.66666/4)
+AOCL_MMD_CALL double dla_mmd_get_ddr_clock_freq() {
+#ifdef HPS_AGX7
+  return 333.332500;
+#else
+  return 266.666666;
+#endif
+}  // MHz
+
+// Helper functions for the wrapper functions around CSR and DDR
+uint64_t dla_get_raw_csr_address(int instance, uint64_t addr) {
+  return (0x1000 * instance) + addr;
+}
+uint64_t dla_get_raw_ddr_address(int instance, uint64_t addr) {
+  return addr;
+}
+
+// Wrappers around CSR and DDR reads and writes to abstract away board-specific offsets
+AOCL_MMD_CALL int dla_mmd_csr_write(int handle, int instance, uint64_t addr, const uint32_t *data) {
+  return aocl_mmd_write(
+      handle, NULL, sizeof(uint32_t), data, HPS_MMD_COREDLA_CSR_HANDLE, dla_get_raw_csr_address(instance, addr));
+}
+AOCL_MMD_CALL int dla_mmd_csr_read(int handle, int instance, uint64_t addr, uint32_t *data) {
+  return aocl_mmd_read(
+      handle, NULL, sizeof(uint32_t), data, HPS_MMD_COREDLA_CSR_HANDLE, dla_get_raw_csr_address(instance, addr));
+}
+AOCL_MMD_CALL int dla_mmd_ddr_write(int handle, int instance, uint64_t addr, uint64_t length, const void *data) {
+  return aocl_mmd_write(handle, NULL, length, data, HPS_MMD_MEMORY_HANDLE, dla_get_raw_ddr_address(instance, addr));
+}
+AOCL_MMD_CALL int dla_mmd_ddr_read(int handle, int instance, uint64_t addr, uint64_t length, void *data) {
+  return aocl_mmd_read(handle, NULL, length, data, HPS_MMD_MEMORY_HANDLE, dla_get_raw_ddr_address(instance, addr));
+}
+
+#ifdef STREAM_CONTROLLER_ACCESS
+AOCL_MMD_CALL bool dla_is_stream_controller_valid(int handle, int instance) {
+  mmd_device_ptr spDevice = _gDeviceMapManager.get_device(handle);
+  if( nullptr == spDevice ) {
+    return FAILURE;
+  }
+  return spDevice->bStreamControllerValid();
+}
+
+AOCL_MMD_CALL int dla_mmd_stream_controller_write(int handle, int instance, uint64_t addr, uint64_t length, const void *data) {
+  return aocl_mmd_write(handle, NULL, length, data, HPS_MMD_STREAM_CONTROLLER_HANDLE, addr);
+}
+
+AOCL_MMD_CALL int dla_mmd_stream_controller_read(int handle, int instance, uint64_t addr, uint64_t length, void* data) {
+  return aocl_mmd_read(
+      handle, NULL, length, data, HPS_MMD_STREAM_CONTROLLER_HANDLE, addr);
+}
+#endif
+
+AOCL_MMD_CALL double dla_mmd_get_coredla_clock_freq(int handle) {
+  return 200;
+}
+
+#endif
diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/host/acl_hps.h b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/acl_hps.h
new file mode 100644
index 0000000..7c85a24
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/acl_hps.h
@@ -0,0 +1,111 @@
+#ifndef ACL_HPS_H
+#define ACL_HPS_H
+
+/* (c) 1992-2021 Intel Corporation.                             */
+/* Intel, the Intel logo, Intel, MegaCore, NIOS II, Quartus and TalkBack words     */
+/* and logos are trademarks of Intel Corporation or its subsidiaries in the U.S.   */
+/* and/or other countries. Other marks and brands may be claimed as the property   */
+/* of others. See Trademarks on intel.com for full list of Intel trademarks or     */
+/* the Trademarks & Brands Names Database (if Intel) or See www.Intel.com/legal (if Altera)  */
+/* Your use of Intel Corporation's design tools, logic functions and other         */
+/* software and tools, and its AMPP partner logic functions, and any output        */
+/* files any of the foregoing (including device programming or simulation          */
+/* files), and any associated documentation or information are expressly subject   */
+/* to the terms and conditions of the Altera Program License Subscription          */
+/* Agreement, Intel MegaCore Function License Agreement, or other applicable       */
+/* license agreement, including, without limitation, that your use is for the      */
+/* sole purpose of programming logic devices manufactured by Intel and sold by     */
+/* Intel or its authorized distributors.  Please refer to the applicable           */
+/* agreement for further details.                                                  */
+
+/* ===- acl_hps.h  --------------------------------------------------- C++ -*-=== */
+/*                                                                                 */
+/*                         Intel(R) HPS MMD Driver                                */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+/*                                                                                 */
+/* This file defines macros and types that are used inside the MMD driver          */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+
+#ifndef ACL_HPS_EXPORT
+#define ACL_HPS_EXPORT __declspec(dllimport)
+#endif
+
+#define MMD_VERSION AOCL_MMD_VERSION_STRING
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdio.h>
+#ifdef DLA_MMD
+#include <cstdint>
+#endif
+#include "aocl_mmd.h"
+
+#include "hps_types.h"
+
+#if defined(WINDOWS)
+#error Currently not available for windows
+#endif
+
+#if defined(LINUX)
+typedef uintptr_t KPTR;
+typedef int fpga_handle;
+typedef unsigned int fpga_result;
+#define FPGA_OK 0
+
+typedef unsigned int DWORD;
+typedef unsigned long long QWORD;
+typedef char INT8;
+typedef unsigned char UINT8;
+typedef int16_t INT16;
+typedef uint16_t UINT16;
+typedef int INT32;
+typedef unsigned int UINT32;
+typedef long long INT64;
+typedef unsigned long long UINT64;
+
+#define INVALID_HANDLE_VALUE ((int)(-1))
+
+#define INVALID_DEVICE (-1)
+#define WD_STATUS_SUCCESS 0
+
+// define for the format string for DWORD type
+#define DWORD_FMT_U "%u"
+#define DWORD_FMT_X "%x"
+#define DWORD_FMT_4X "%04X"
+
+// define for the format string for size_t type
+#define SIZE_FMT_U "%zu"
+#define SIZE_FMT_X "%zx"
+
+#endif  // LINUX
+
+#define MAX_NAME_SIZE (1204)
+
+#define HPS_ASSERT(COND, ...)                        \
+  do {                                                    \
+    if (!(COND)) {                                        \
+      printf("\nMMD FATAL: %s:%d: ", __FILE__, __LINE__); \
+      printf(__VA_ARGS__);                                \
+      fflush(stdout);                                     \
+      assert(0);                                          \
+    }                                                     \
+  } while (0)
+
+#define HPS_ERROR_IF(COND, NEXT, ...) \
+  do {                                     \
+    if (COND) {                            \
+      printf("\nMMD ERROR: " __VA_ARGS__); \
+      fflush(stdout);                      \
+      NEXT;                                \
+    }                                      \
+  } while (0)
+
+#define HPS_INFO(...)             \
+  do {                                 \
+    printf("MMD INFO : " __VA_ARGS__); \
+    fflush(stdout);                    \
+  } while (0)
+
+#endif  // ACL_HPS_H
diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/host/dma_device.cpp b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/dma_device.cpp
new file mode 100644
index 0000000..e403823
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/dma_device.cpp
@@ -0,0 +1,120 @@
+/* (c) 1992-2021 Intel Corporation.                                                */
+/* Intel, the Intel logo, Intel, MegaCore, NIOS II, Quartus and TalkBack words     */
+/* and logos are trademarks of Intel Corporation or its subsidiaries in the U.S.   */
+/* and/or other countries. Other marks and brands may be claimed as the property   */
+/* of others. See Trademarks on intel.com for full list of Intel trademarks or     */
+/* the Trademarks & Brands Names Database (if Intel) or See www.Intel.com/legal (if Altera)  */
+/* Your use of Intel Corporation's design tools, logic functions and other         */
+/* software and tools, and its AMPP partner logic functions, and any output        */
+/* files any of the foregoing (including device programming or simulation          */
+/* files), and any associated documentation or information are expressly subject   */
+/* to the terms and conditions of the Altera Program License Subscription          */
+/* Agreement, Intel MegaCore Function License Agreement, or other applicable       */
+/* license agreement, including, without limitation, that your use is for the      */
+/* sole purpose of programming logic devices manufactured by Intel and sold by     */
+/* Intel or its authorized distributors.  Please refer to the applicable           */
+/* agreement for further details.                                                  */
+
+/* ===- dma_device.h  ------------------------------------------------- C++ -*-=== */
+/*                                                                                 */
+/*                         dma device access functions                             */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+/*                                                                                 */
+/* This file implements the functions used access the dma device objects           */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+
+// common and its own header files
+#include "dma_device.h"
+#include <unistd.h>
+#include <glob.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+#include <memory.h>
+
+// Copied from Linux driver: /drivers/dma/altera-msgdma.c
+#define MSGDMA_DESC_NUM 1024
+
+// Same page size as used in /meta-intel-fpga-coredla/recipes-drivers/msgdma-userio/files/msgdma_userio_chr.c
+#define PAGE_SIZE 4096
+
+//////////////////////////////////////////////////////
+
+#define ERR(format, ...) \
+printf("%s:%u() **ERROR** : " format, \
+    __func__, __LINE__,  ##__VA_ARGS__)
+
+//////////////////////////////////////////////////////
+dma_device::dma_device(std::string &name)
+{
+    _pFile = fopen(name.c_str(), "r+");
+    if( _pFile == nullptr )
+    {
+        ERR("dma_device::dma_device failed to open %s\n", name.c_str());
+        return;
+    }
+
+    // Turn off buffering
+    setvbuf(_pFile, NULL, _IONBF, 0);
+}
+
+dma_device::~dma_device()
+{
+    if( _pFile )
+    {
+        fclose(_pFile);
+        _pFile = NULL;
+    }
+}
+
+int  dma_device::read_block(void *host_addr, size_t offset, size_t size)
+{
+    // Use 32bit seek as DDR memory current < 32bits
+    if( fseek(_pFile, (uint32_t)offset, SEEK_SET) != 0 ) {
+        return FAILURE;
+    }
+
+    size_t read_size = fread(host_addr, 1, size, _pFile);
+    return (read_size == size) ? SUCCESS : FAILURE;
+}
+
+int  dma_device::write_block(const void *host_addr, size_t offset, size_t size)
+{
+    // The MSGDMA driver only supports a maximum of 1024 x 4096 = 4MBytes in the worst case scenario,
+    // in the event that the virtual buffer is fully fragmented. As the buffer gets more fragmented it's
+    // possible to run out of DMA descriptors. To prevent this, slice the data into 4MB chunks.
+
+    // chunk_size is chosen based on the size of a page (12 bits) and default number of descriptors (1024).
+    // The descriptor count is reduced by 1 since if the host_addr is not aligned to a page then an extra page
+    // will be added at the end. This would then increase the descriptor count by 1.
+    size_t chunk_size = PAGE_SIZE * (MSGDMA_DESC_NUM - 1);
+    size_t write_size = 0;
+
+    // Use 32bit seek as DDR memory current < 32bits
+    if( fseek(_pFile, (uint32_t)offset, SEEK_SET) != 0 ) {
+        return FAILURE;
+    }
+
+    for (size_t host_addr_offset = 0; host_addr_offset < size; host_addr_offset += chunk_size) {
+        size_t current_size = chunk_size;
+
+        // If the current address is within one chunk_size from the end of the data, set current_size
+        // to the bytes left to send
+        if (size - host_addr_offset < chunk_size) {
+            current_size = size - host_addr_offset;
+        }
+
+        size_t current_write_size = fwrite((uint8_t *)host_addr + host_addr_offset, 1, current_size, _pFile);
+
+        if (current_write_size != current_size) {
+            return FAILURE;
+        }
+
+        write_size += current_write_size;
+    }
+
+    return (write_size == size) ? SUCCESS : FAILURE;
+}
diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/host/dma_device.h b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/dma_device.h
new file mode 100644
index 0000000..24f89e4
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/dma_device.h
@@ -0,0 +1,56 @@
+#ifndef DMA_DEVICE_H_
+#define DMA_DEVICE_H_
+
+/* (c) 1992-2021 Intel Corporation.                                                */
+/* Intel, the Intel logo, Intel, MegaCore, NIOS II, Quartus and TalkBack words     */
+/* and logos are trademarks of Intel Corporation or its subsidiaries in the U.S.   */
+/* and/or other countries. Other marks and brands may be claimed as the property   */
+/* of others. See Trademarks on intel.com for full list of Intel trademarks or     */
+/* the Trademarks & Brands Names Database (if Intel) or See www.Intel.com/legal (if Altera)  */
+/* Your use of Intel Corporation's design tools, logic functions and other         */
+/* software and tools, and its AMPP partner logic functions, and any output        */
+/* files any of the foregoing (including device programming or simulation          */
+/* files), and any associated documentation or information are expressly subject   */
+/* to the terms and conditions of the Altera Program License Subscription          */
+/* Agreement, Intel MegaCore Function License Agreement, or other applicable       */
+/* license agreement, including, without limitation, that your use is for the      */
+/* sole purpose of programming logic devices manufactured by Intel and sold by     */
+/* Intel or its authorized distributors.  Please refer to the applicable           */
+/* agreement for further details.                                                  */
+
+/* ===- dma_device.h  ------------------------------------------------- C++ -*-=== */
+/*                                                                                 */
+/*                         dma device access functions                             */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+/*                                                                                 */
+/* This file implements the functions used access the dma device objects           */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+#include <vector>
+#include <string>
+#include <memory>
+
+#include "hps_types.h"
+
+class dma_device
+{
+public:
+  dma_device(std::string &name);
+  ~dma_device();
+
+  int read_block(void *host_addr, size_t offset, size_t size);
+  int write_block(const void *host_addr, size_t offset, size_t size);
+
+  bool bValid() { return _pFile != nullptr; };
+private:
+
+  dma_device() = delete;
+  dma_device(dma_device const&) = delete;
+  void operator=(dma_device const &) = delete;
+
+  FILE *_pFile = {nullptr}; // File pointer to UIO - Used to indicate the the uio_device is valid
+};
+typedef std::shared_ptr<dma_device> dma_device_ptr;
+
+#endif // DMA_DEVICE_H_
diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/host/hps_types.h b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/hps_types.h
new file mode 100644
index 0000000..3f11c4a
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/hps_types.h
@@ -0,0 +1,44 @@
+#ifndef HPS_TYPES_H_
+#define HPS_TYPES_H_
+
+/* (c) 1992-2021 Intel Corporation.                                                */
+/* Intel, the Intel logo, Intel, MegaCore, NIOS II, Quartus and TalkBack words     */
+/* and logos are trademarks of Intel Corporation or its subsidiaries in the U.S.   */
+/* and/or other countries. Other marks and brands may be claimed as the property   */
+/* of others. See Trademarks on intel.com for full list of Intel trademarks or     */
+/* the Trademarks & Brands Names Database (if Intel) or See www.Intel.com/legal (if Altera)  */
+/* Your use of Intel Corporation's design tools, logic functions and other         */
+/* software and tools, and its AMPP partner logic functions, and any output        */
+/* files any of the foregoing (including device programming or simulation          */
+/* files), and any associated documentation or information are expressly subject   */
+/* to the terms and conditions of the Altera Program License Subscription          */
+/* Agreement, Intel MegaCore Function License Agreement, or other applicable       */
+/* license agreement, including, without limitation, that your use is for the      */
+/* sole purpose of programming logic devices manufactured by Intel and sold by     */
+/* Intel or its authorized distributors.  Please refer to the applicable           */
+/* agreement for further details.                                                  */
+
+/* ===- hps_types.h  -------------------------------------------------- C++ -*-=== */
+/*                                                                                 */
+/*                         Useful HPS Types                                        */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+/*                                                                                 */
+/* This file contains useful type definition                                       */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+#include <vector>
+#include <string>
+
+#define SUCCESS (0)
+#define FAILURE (1)
+
+typedef std::vector<std::string> board_names;
+
+typedef enum {
+  HPS_MMD_COREDLA_CSR_HANDLE = 1, // COREDLA CSR Interface
+  HPS_MMD_MEMORY_HANDLE = 2,      // Device Memory transfers
+  HPS_MMD_STREAM_CONTROLLER_HANDLE = 3   // Stream Controller Interface
+} hps_mmd_interface_t;
+
+#endif // HPS_TYPES_H_
diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/host/mmd_device.cpp b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/mmd_device.cpp
new file mode 100644
index 0000000..b52c1d8
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/mmd_device.cpp
@@ -0,0 +1,129 @@
+/* (c) 1992-2021 Intel Corporation.                                                */
+/* Intel, the Intel logo, Intel, MegaCore, NIOS II, Quartus and TalkBack words     */
+/* and logos are trademarks of Intel Corporation or its subsidiaries in the U.S.   */
+/* and/or other countries. Other marks and brands may be claimed as the property   */
+/* of others. See Trademarks on intel.com for full list of Intel trademarks or     */
+/* the Trademarks & Brands Names Database (if Intel) or See www.Intel.com/legal (if Altera)  */
+/* Your use of Intel Corporation's design tools, logic functions and other         */
+/* software and tools, and its AMPP partner logic functions, and any output        */
+/* files any of the foregoing (including device programming or simulation          */
+/* files), and any associated documentation or information are expressly subject   */
+/* to the terms and conditions of the Altera Program License Subscription          */
+/* Agreement, Intel MegaCore Function License Agreement, or other applicable       */
+/* license agreement, including, without limitation, that your use is for the      */
+/* sole purpose of programming logic devices manufactured by Intel and sold by     */
+/* Intel or its authorized distributors.  Please refer to the applicable           */
+/* agreement for further details.                                                  */
+
+/* ===- mmd_device.h  ------------------------------------------------- C++ -*-=== */
+/*                                                                                 */
+/*                         mmd device access functions                             */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+/*                                                                                 */
+/* This file implements the functions used access the mmd device object            */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+
+#include "mmd_device.h"
+
+// Defined names of the UIO Nodes
+#define UIO_COREDLA_PREFIX "coredla"
+#define STREAM_CONTROLLER_PREFIX "stream_controller"
+
+// Defined name of the msgdma device
+#define DMA_DEVICE_PREFIX "/dev/msgdma_coredla"
+#define UIO_DEVICE_PREFIX "uio"
+
+board_names mmd_get_devices(const int max_fpga_devices)
+{
+    return uio_get_devices(UIO_COREDLA_PREFIX, max_fpga_devices);
+}
+
+
+/////////////////////////////////////////////////////////
+mmd_device::mmd_device(std::string name, const int mmd_handle)
+: _name(name), _mmd_handle(mmd_handle) {
+    _spCoredlaDevice = std::make_shared<uio_device>(name, _mmd_handle, true);
+    int32_t index = extract_index(_name);
+    if( (index >= 0) && _spCoredlaDevice && _spCoredlaDevice->bValid() )
+    {
+        std::string dma_name(DMA_DEVICE_PREFIX);
+        dma_name += std::to_string(index);
+        _spDmaDevice = std::make_shared<dma_device>(dma_name);
+
+        if( (_spDmaDevice==nullptr) || (!_spDmaDevice->bValid()) ) {
+            _spDmaDevice = nullptr;
+            return;
+        }
+        std::string stream_controller_name = uio_get_device(STREAM_CONTROLLER_PREFIX, index);
+        if( !stream_controller_name.empty() ) {
+            // Create a uio_device but don't attach any interrupt support as the stream controller
+            // does not require interrupts
+            _spStreamControllerDevice = std::make_shared<uio_device>(stream_controller_name, _mmd_handle, false);
+            if( _spStreamControllerDevice && !_spStreamControllerDevice->bValid() ) {
+                // The stream controller does not exist
+                _spStreamControllerDevice = nullptr;
+            }
+        }
+    }
+}
+
+int mmd_device::read_block(aocl_mmd_op_t op, int mmd_interface, void *host_addr, size_t offset, size_t size)
+{
+    if( op ) {
+        LOG_ERR("op not support : %s\n", __func__ );
+        return FAILURE;
+    }
+    if( mmd_interface == HPS_MMD_MEMORY_HANDLE ) {
+        return _spDmaDevice->read_block(host_addr, offset, size);
+    } else if( mmd_interface == HPS_MMD_COREDLA_CSR_HANDLE ) {
+        return _spCoredlaDevice->read_block(host_addr, offset, size);
+    } else if( mmd_interface == HPS_MMD_STREAM_CONTROLLER_HANDLE ) {
+        if ( _spStreamControllerDevice ) {
+            return _spStreamControllerDevice->read_block(host_addr, offset, size);
+        }
+    }
+
+    return FAILURE;
+}
+
+int mmd_device::write_block(aocl_mmd_op_t op, int mmd_interface, const void *host_addr, size_t offset, size_t size)
+{
+     if( op ) {
+        LOG_ERR("op not support : %s\n", __func__ );
+        return FAILURE;
+    }
+    if( mmd_interface == HPS_MMD_MEMORY_HANDLE ) {
+        return _spDmaDevice->write_block(host_addr, offset, size);
+    } else if ( mmd_interface == HPS_MMD_COREDLA_CSR_HANDLE ) {
+        return _spCoredlaDevice->write_block(host_addr, offset, size);
+    } else if ( mmd_interface == HPS_MMD_STREAM_CONTROLLER_HANDLE ) {
+        if( _spStreamControllerDevice ) {
+            return _spStreamControllerDevice->write_block(host_addr, offset, size);
+        }
+    }
+    return FAILURE;
+}
+
+int mmd_device::set_interrupt_handler(aocl_mmd_interrupt_handler_fn fn, void *user_data) {
+    if( _spCoredlaDevice ) {
+        return _spCoredlaDevice->set_interrupt_handler(fn, user_data);
+    }
+    return FAILURE;
+}
+
+// Returns the index of a uio device
+// If index cannot be found then returns -1
+int mmd_device::extract_index(const std::string name) {
+    std::string prefix(UIO_DEVICE_PREFIX);
+
+  if (name.length() <= prefix.length() && name.compare(0, prefix.length(), prefix)) {
+    LOG_ERR("Error parsing device name '%s'\n", name.c_str());
+    return -1;
+  }
+
+  std::string device_num_str = name.substr(prefix.length());
+  int32_t index = std::stoi(device_num_str, 0, 10);
+  return index;
+}
diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/host/mmd_device.h b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/mmd_device.h
new file mode 100644
index 0000000..9cb0c71
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/mmd_device.h
@@ -0,0 +1,75 @@
+#ifndef MMD_DEVICE_H_
+#define MMD_DEVICE_H_
+
+/* (c) 1992-2021 Intel Corporation.                                                */
+/* Intel, the Intel logo, Intel, MegaCore, NIOS II, Quartus and TalkBack words     */
+/* and logos are trademarks of Intel Corporation or its subsidiaries in the U.S.   */
+/* and/or other countries. Other marks and brands may be claimed as the property   */
+/* of others. See Trademarks on intel.com for full list of Intel trademarks or     */
+/* the Trademarks & Brands Names Database (if Intel) or See www.Intel.com/legal (if Altera)  */
+/* Your use of Intel Corporation's design tools, logic functions and other         */
+/* software and tools, and its AMPP partner logic functions, and any output        */
+/* files any of the foregoing (including device programming or simulation          */
+/* files), and any associated documentation or information are expressly subject   */
+/* to the terms and conditions of the Altera Program License Subscription          */
+/* Agreement, Intel MegaCore Function License Agreement, or other applicable       */
+/* license agreement, including, without limitation, that your use is for the      */
+/* sole purpose of programming logic devices manufactured by Intel and sold by     */
+/* Intel or its authorized distributors.  Please refer to the applicable           */
+/* agreement for further details.                                                  */
+
+/* ===- mmd_device.h  ------------------------------------------------- C++ -*-=== */
+/*                                                                                 */
+/*                         mmd device access functions                             */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+/*                                                                                 */
+/* This file implements the functions used access the mmd device object            */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+#include <memory>
+#include <string>
+
+#include "hps_types.h"
+#include "dma_device.h"
+#include "uio_device.h"
+
+#include "aocl_mmd.h"
+
+// LOG ERRORS
+#define MMD_ERR_LOGGING 1
+#ifdef MMD_ERR_LOGGING
+#define LOG_ERR(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define LOG_ERR(...)
+#endif
+
+class mmd_device {
+public:
+  mmd_device(std::string name, const int mmd_handle);
+
+  bool bValid() { return _spCoredlaDevice && _spCoredlaDevice->bValid() && _spDmaDevice && _spDmaDevice->bValid(); };
+  bool bStreamControllerValid() { return _spCoredlaDevice && _spStreamControllerDevice && _spStreamControllerDevice->bValid(); };
+  int write_block(aocl_mmd_op_t op, int mmd_interface, const void *host_addr, size_t offset, size_t size);
+  int read_block(aocl_mmd_op_t op, int mmd_interface, void *host_addr, size_t offset, size_t size);
+
+  int set_interrupt_handler(aocl_mmd_interrupt_handler_fn fn, void *user_data);
+private:
+  int32_t extract_index(const std::string name);
+
+  mmd_device() = delete;
+  mmd_device(mmd_device const&) = delete;
+  void operator=(mmd_device const &) = delete;
+  std::string _name;
+
+  uio_device_ptr _spCoredlaDevice;
+  uio_device_ptr _spStreamControllerDevice;
+  dma_device_ptr _spDmaDevice;
+  int            _mmd_handle;
+};
+
+typedef std::shared_ptr<mmd_device> mmd_device_ptr;
+
+extern board_names mmd_get_devices(const int max_fpga_devices);
+
+#endif // MMD_DEVICE_H_
diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/host/uio_device.cpp b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/uio_device.cpp
new file mode 100644
index 0000000..95a9567
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/uio_device.cpp
@@ -0,0 +1,469 @@
+// (c) 1992-2021 Intel Corporation.
+// Intel, the Intel logo, Intel, MegaCore, NIOS II, Quartus and TalkBack words
+// and logos are trademarks of Intel Corporation or its subsidiaries in the U.S.
+// and/or other countries. Other marks and brands may be claimed as the property
+// of others. See Trademarks on intel.com for full list of Intel trademarks or
+// the Trademarks & Brands Names Database (if Intel) or See www.Intel.com/legal (if Altera)
+// Your use of Intel Corporation's design tools, logic functions and other
+// software and tools, and its AMPP partner logic functions, and any output
+// files any of the foregoing (including device programming or simulation
+// files), and any associated documentation or information are expressly subject
+// to the terms and conditions of the Altera Program License Subscription
+// Agreement, Intel MegaCore Function License Agreement, or other applicable
+// license agreement, including, without limitation, that your use is for the
+// sole purpose of programming logic devices manufactured by Intel and sold by
+// Intel or its authorized distributors.  Please refer to the applicable
+// agreement for further details.
+
+/* ===- uio_device.cpp  ----------------------------------------------- C++ -*-=== */
+/*                                                                                 */
+/*                         uio device access functions                             */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+/*                                                                                 */
+/* This file implements the functions used access the uio device objects           */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+
+// common and its own header files
+#include "uio_device.h"
+#include <unistd.h>
+#include <glob.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <poll.h>
+
+#include <cinttypes>
+#include <memory.h>
+
+//////////////////////////////////////////////////////
+#define UIO_BASE_NAME "uio*"
+#define UIO_BASE_PATH "/sys/class/uio/"
+#define UIO_BASE_SEARCH UIO_BASE_PATH UIO_BASE_NAME
+#define UIO_MAX_PATH (256)
+
+#define ERR(format, ...) \
+fprintf(stderr, "%s:%u **ERROR** : " format, \
+    __FILE__, __LINE__,  ##__VA_ARGS__)
+
+//////////////////////////////////////////////////////
+#define MAX_NAME (20)
+bool uio_read_sysfs_uint64(const char *device_name, const char *sysfs_name, uint64_t &value)
+{
+       FILE *fp;
+    char param_path[UIO_MAX_PATH];
+
+    if( snprintf(param_path, sizeof(param_path), "%s/%s", device_name, sysfs_name) < 0 )
+    {
+        ERR("Path too long. %s, %s\n", device_name, sysfs_name);
+        return false;
+    }
+
+    fp = fopen(param_path, "r");
+    if( !fp )
+    {
+        ERR("Failed to fopen - %s\n", param_path);
+        return false;
+    }
+
+    if( fscanf(fp, "%" PRIx64, &value) != 1 )
+    {
+        ERR("Failed fscanf - %s\n", param_path);
+        fclose(fp);
+        return false;
+    }
+
+    fclose(fp);
+    return true;
+}
+
+bool uio_read_sysfs_string(const char *uio_path, const char *sysfs_name, std::string &result)
+{
+    char uio_name[MAX_NAME];
+    FILE *fp;
+    char param_path[UIO_MAX_PATH];
+
+    if( snprintf(param_path, sizeof(param_path), "%s/%s", uio_path, sysfs_name) < 0 )
+    {
+        ERR("Path too long. %s, %s\n", uio_path, sysfs_name);
+        return false;
+    }
+
+    fp = fopen(param_path, "r");
+    if( !fp )
+    {
+        ERR("Failed to fopen - %s\n", param_path);
+        return false;
+    }
+
+    int num_read = fread(uio_name, 1, MAX_NAME, fp);
+    if( num_read <= 0 )
+    {
+        ERR("Failed to read name - %s\n", param_path);
+        fclose(fp);
+        return false;
+    }
+
+    uio_name[num_read-1] = '\0'; // Terminate
+    result = std::string(uio_name);
+    fclose(fp);
+
+    return true;
+}
+
+std::string uio_get_device(const std::string prefix, const int32_t index)
+{
+  glob_t globbuf = {0};
+  std::string uio_name;
+
+  int glob_res = glob(UIO_BASE_SEARCH, GLOB_NOSORT, NULL, &globbuf);
+  if( (glob_res == 0) && (globbuf.gl_pathc) )
+  {
+    std::string device_name;
+    device_name = prefix + std::to_string(index);
+
+    for( size_t i=0; i<globbuf.gl_pathc; i++ )
+    {
+      std::string name;
+      uio_read_sysfs_string(globbuf.gl_pathv[i], "name", name);
+
+      if( name.find(device_name) != std::string::npos )
+      {
+        // We will return just the device name without the UIO_BASE_PATH
+        std::string name = std::string(globbuf.gl_pathv[i]);
+        uio_name = name.substr(sizeof(UIO_BASE_PATH)-1);
+      }
+    }
+   }
+   return uio_name;
+}
+
+board_names uio_get_devices(const std::string device_name, const int max_devices)
+{
+  board_names names;
+  int device = 0;
+
+  glob_t globbuf = {0};
+
+  int glob_res = glob(UIO_BASE_SEARCH, GLOB_NOSORT, NULL, &globbuf);
+  if( (glob_res == 0) && (globbuf.gl_pathc) )
+  {
+    for( size_t i=0; (i<globbuf.gl_pathc) && (device < max_devices); i++ )
+    {
+      std::string name;
+      uio_read_sysfs_string(globbuf.gl_pathv[i], "name", name);
+
+      if( name.find(device_name) != std::string::npos )
+      {
+        // We will return just the device name without the UIO_BASE_PATH
+        std::string name = std::string(globbuf.gl_pathv[i]);
+        name = name.substr(sizeof(UIO_BASE_PATH)-1);
+        names.push_back(name);
+        device++;
+      }
+    }
+   }
+   return names;
+}
+
+//////////////////////////////////////////////////////////////
+uio_device::uio_device(std::string &name, const int mmd_handle, const bool bEnableIRQ)
+: _mmd_handle(mmd_handle)
+{
+    // Map the first address space
+    if ( !map_region(name, 0) ) {
+        ERR("Failed to map region 0 on %s\n", name.c_str());
+        return;
+    }
+#ifndef RUNTIME_POLLING
+    if( bEnableIRQ ) {
+        _spInterrupt = std::make_shared<uio_interrupt>(_fd, _mmd_handle);
+        if( !_spInterrupt->initialized() ) {
+            _spInterrupt = nullptr; // If the uio_interrupt failed to initialize then delete
+        }
+        _bIrqEnabled = bEnableIRQ;
+    }
+#endif
+}
+
+bool uio_device::bValid() {
+    bool bValid = (_fd >=0);
+#ifndef RUNTIME_POLLING // If we're not polling check that the interrupt handling is working
+    if( _bIrqEnabled ) {
+        bValid |= (_spInterrupt != nullptr);
+    }
+#endif
+    return bValid;
+};
+
+uio_device::~uio_device()
+{
+#ifndef RUNTIME_POLLING
+    _spInterrupt = nullptr; // Shutdown the interrupt handler
+#endif
+    unmap_region();
+}
+
+uint32_t uio_device::read(const uint32_t reg)
+{
+    // NOT YET IMPLEMENTED
+    return 0;
+}
+
+void uio_device::write(const uint32_t reg, const uint32_t value)
+{
+    // NOT YET IMPLEMENTED
+    return;
+}
+
+// Copies the block of data from the FPGA to the host
+// memcpy is not used as this can cause multiple transfers of the AXI bus depending
+// on the implementation of memcpy
+int  uio_device::read_block(void *host_addr, size_t offset, size_t size)
+{
+    // Support for only 32bit aligned transfers
+    if( (offset % sizeof(uint32_t)) || (size % sizeof(uint32_t)) ){
+        return FAILURE;
+    }
+
+    // Transfer the data in 32bit chunks
+    volatile const uint32_t *pDeviceMem32 = reinterpret_cast<volatile const uint32_t*>(reinterpret_cast<uint8_t*>(_pPtr) + offset);
+    uint32_t *host_addr32 = reinterpret_cast<uint32_t *>(host_addr);
+    while (size >= sizeof(uint32_t)) {
+        *host_addr32++ = *pDeviceMem32++;
+        size -= sizeof(uint32_t);
+    }
+
+    return SUCCESS;
+}
+
+// Copies the block of data from the host to the FPGA
+// memcpy is not used as this can cause multiple transfers of the AXI bus depending
+// on the implementation of memcpy
+int  uio_device::write_block(const void *host_addr, size_t offset, size_t size)
+{
+    // Support for only 32bit aligned transfers
+    if( (offset % sizeof(uint32_t)) || (size % sizeof(uint32_t)) ){
+        return FAILURE;
+    }
+
+    // Transfer the remaining 32bits of data
+    volatile uint32_t *pDeviceMem32 = reinterpret_cast<volatile uint32_t*>(reinterpret_cast<uint8_t*>(_pPtr) + offset);
+    const uint32_t *host_addr32 = reinterpret_cast<const uint32_t*>(host_addr);
+    while( size >= sizeof(uint32_t) ) {
+        *pDeviceMem32++ = *host_addr32++;
+        size -= sizeof(uint32_t);
+    }
+    return SUCCESS;
+}
+
+int uio_device::set_interrupt_handler(aocl_mmd_interrupt_handler_fn fn, void* user_data) {
+#ifndef RUNTIME_POLLING
+    if( _spInterrupt ) {
+        return _spInterrupt->set_interrupt_handler(fn, user_data);
+    }
+#endif
+    return FAILURE;
+}
+
+/////////////////////////////////////////////////////////////////
+void uio_device::unmap_region()
+{
+    if( _pBase )
+    {
+        munmap(_pBase, _size);
+        _pBase = nullptr;
+    }
+
+    if( _fd >= 0 )
+    {
+        close(_fd);
+        _fd = -1;
+    }
+}
+
+bool uio_device::map_region( std::string &name, const uint32_t index)
+{
+    char map_path[UIO_MAX_PATH];
+
+    std::string uio_params_path(UIO_BASE_PATH);
+    uio_params_path += name;
+
+    // char device_path[UIO_MAX_PATH];
+    // const char *p;
+
+    if( snprintf(map_path, sizeof(map_path), "maps/map%d/size", index ) < 0 )
+    {
+        ERR("Failed to make map addr name.\n");
+        return false;
+    }
+    if( !uio_read_sysfs_uint64(uio_params_path.c_str(), map_path, _size) )
+    {
+        ERR("Failed to read size\n");
+        return false;
+    }
+    // Make sure that the size doesn't exceed 32bits, as this will fail the mapping
+    // call on 32bit systems
+    if( _size > UINT32_MAX ) {
+        ERR("Invalid size value\n");
+        return false;
+    }
+
+    if( snprintf(map_path, sizeof(map_path), "maps/map%d/offset", index ) < 0 )
+    {
+        ERR("Failed to make map offset name.\n");
+        return false;
+    }
+    if( !uio_read_sysfs_uint64(uio_params_path.c_str(), map_path, _offset) )
+    {
+        ERR("Failed to read offset\n");
+        return false;
+    }
+
+    std::string uio_dev_path("/dev/");
+    uio_dev_path += name;
+
+    _fd = open(uio_dev_path.c_str(), O_RDWR );
+    if( _fd < 0 )
+    {
+        ERR("Failed to open - %s\n", uio_dev_path.c_str());
+        return false;
+    }
+    // Map the region into userspace
+    // The base of the region is the page_size offset of the index
+    uint32_t page_size = (uint32_t)sysconf(_SC_PAGESIZE);
+
+    _pBase = (uint8_t*)mmap(NULL, (size_t)_size, PROT_READ|PROT_WRITE, MAP_SHARED, _fd, (off_t) (index * page_size));
+    if( _pBase == MAP_FAILED )
+    {
+        ERR("Failed to map uio region.\n");
+        close(_fd);
+        _fd = -1;
+        return false;
+    }
+    // CST base address is at _pBase + _offset
+    _pPtr = (uint32_t*)(_pBase + _offset);
+
+    return true;
+};
+
+#ifndef RUNTIME_POLLING
+///////////////////////////////////////////////////////////////////////////////////
+uio_interrupt::uio_interrupt(const int fd, const int mmd_handle)
+: _device_fd(fd), _mmd_handle(mmd_handle) {
+    if( is_irq_available() ) {
+        // Create a eventfd_object to be used for shutting down the work_thread
+        _spShutdown_event = std::make_shared<eventfd_object>();
+        if( _spShutdown_event->initialized() ) {
+            _pThread = new std::thread(work_thread, std::ref(*this));
+        } else {
+            _spShutdown_event = nullptr;
+        }
+    } else {
+        ERR("No device interrupt found.\n");
+    }
+}
+
+uio_interrupt::~uio_interrupt() {
+    // kill the thread
+    if (_pThread && _spShutdown_event) {
+        // send message to thread to end it
+        _spShutdown_event->notify(1);
+
+        // join with thread until it ends
+        _pThread->join();
+
+        delete _pThread;
+        _pThread = NULL;
+
+        _spShutdown_event = nullptr;
+    }
+}
+
+bool uio_interrupt::is_irq_available() {
+    // Disable the interrupt handling, this will fail if the IRQ has not been setup correctly.
+    // For example devicetree is incorrect.
+    return disable_irq();
+}
+
+bool uio_interrupt::enable_irq() {
+    // Enable interrupts from the device
+    uint32_t info = 1;
+    ssize_t nb = write(_device_fd, &info, sizeof(info));
+    if( nb != (ssize_t)sizeof(info) ) {
+        ERR( "Failed in enable CoreDLA Interrupt = %s\n", strerror(errno));
+        return false;
+    }
+    return true;
+}
+
+bool uio_interrupt::disable_irq() {
+    // Enable interrupts from the device
+    uint32_t info = 0;
+    ssize_t nb = write(_device_fd, &info, sizeof(info));
+    if( nb != (ssize_t)sizeof(info) ) {
+        ERR( "Failed in disable CoreDLA Interrupt = %s\n", strerror(errno));
+        return false;
+    }
+    return true;
+}
+
+void uio_interrupt::work_thread(uio_interrupt& obj) {
+    obj.run_thread();
+}
+
+#define UIO_INTERRUPT_TIMEOUT (-1)
+void uio_interrupt::run_thread() {
+    while( true ) {
+        // Need to re-enable the UIO interrupt handling as UIO disables the IRQ each time it is fired
+        if ( !enable_irq() ) {
+            exit(-1);
+        }
+        // Poll for the shutdown_event and uio interrupt
+        struct pollfd pollfd_arr[2];
+        pollfd_arr[0].fd = _spShutdown_event->get_fd();
+        pollfd_arr[0].events = POLLIN;
+        pollfd_arr[0].revents = 0;
+        pollfd_arr[1].fd = _device_fd;
+        pollfd_arr[1].events = POLLIN;
+        pollfd_arr[1].revents = 0;
+
+        int res = poll(pollfd_arr, 2, UIO_INTERRUPT_TIMEOUT);
+        if (res < 0) {
+            ERR( "Poll error errno = %s\n", strerror(errno));
+            exit(-1);
+        } else if (res > 0 && pollfd_arr[0].revents == POLLIN) {
+            uint64_t count;
+            ssize_t bytes_read = read(pollfd_arr[0].fd, &count, sizeof(count));
+            if (bytes_read > 0) {
+                break; // We've been asked to shutdown
+            } else {
+                ERR( "Error: poll failed: %s\n", bytes_read < 0 ? strerror(errno) : "zero bytes read");
+                exit(-1);
+            }
+        } else if (res > 0 && pollfd_arr[1].revents == POLLIN) {
+            uint32_t count;
+            ssize_t bytes_read = read(pollfd_arr[1].fd, &count, sizeof(count));
+            if (bytes_read > 0) {
+                if( _interrupt_fn ) { // Run the callback to the application
+                    _interrupt_fn(get_mmd_handle(), _interrupt_fn_user_data );
+                }
+            } else {
+                ERR( "Error: poll failed: %s\n", bytes_read < 0 ? strerror(errno) : "zero bytes read");
+                exit(-1);
+            }
+        }
+    }
+    // Disable interrupt handling in UIO
+    if( !disable_irq() ){
+        exit(-1);
+    }
+}
+
+int uio_interrupt::set_interrupt_handler(aocl_mmd_interrupt_handler_fn fn, void* user_data) {
+  _interrupt_fn = fn;
+  _interrupt_fn_user_data = user_data;
+  return SUCCESS;
+}
+#endif
diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/host/uio_device.h b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/uio_device.h
new file mode 100644
index 0000000..c5f3ed5
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/host/uio_device.h
@@ -0,0 +1,162 @@
+#ifndef UIO_DEVICE_H_
+#define UIO_DEVICE_H_
+
+/* (c) 1992-2021 Intel Corporation.                                                */
+/* Intel, the Intel logo, Intel, MegaCore, NIOS II, Quartus and TalkBack words     */
+/* and logos are trademarks of Intel Corporation or its subsidiaries in the U.S.   */
+/* and/or other countries. Other marks and brands may be claimed as the property   */
+/* of others. See Trademarks on intel.com for full list of Intel trademarks or     */
+/* the Trademarks & Brands Names Database (if Intel) or See www.Intel.com/legal (if Altera)  */
+/* Your use of Intel Corporation's design tools, logic functions and other         */
+/* software and tools, and its AMPP partner logic functions, and any output        */
+/* files any of the foregoing (including device programming or simulation          */
+/* files), and any associated documentation or information are expressly subject   */
+/* to the terms and conditions of the Altera Program License Subscription          */
+/* Agreement, Intel MegaCore Function License Agreement, or other applicable       */
+/* license agreement, including, without limitation, that your use is for the      */
+/* sole purpose of programming logic devices manufactured by Intel and sold by     */
+/* Intel or its authorized distributors.  Please refer to the applicable           */
+/* agreement for further details.                                                  */
+
+/* ===- uio_device.h  ------------------------------------------------- C++ -*-=== */
+/*                                                                                 */
+/*                         uio device access functions                             */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+/*                                                                                 */
+/* This file implements the functions used access the uio device objects           */
+/*                                                                                 */
+/* ===-------------------------------------------------------------------------=== */
+#include <vector>
+#include <string>
+#include <string.h>
+#include <memory>
+#include <thread>
+#include <mutex>
+#include <sys/eventfd.h>
+#include <unistd.h>
+
+#include "aocl_mmd.h"
+#include "hps_types.h"
+
+// simple wrapper class for managing eventfd objects
+class eventfd_object final {
+ public:
+  eventfd_object() {
+    m_initialized = false;
+    // Note: EFD_SEMAPHORE and EFD_NONBLOCK are not set
+    // The implementation of functions using eventfd assumes that
+    m_fd = eventfd(0, 0);
+    if (m_fd < 0) {
+      fprintf(stderr, "eventfd : %s", strerror(errno));
+      return;
+    }
+
+    m_initialized = true;
+  }
+
+  ~eventfd_object() {
+    if (m_initialized) {
+      if (close(m_fd) < 0) {
+        fprintf(stderr, "eventfd : %s", strerror(errno));
+      }
+    }
+  }
+
+  bool notify(uint64_t count) {
+    ssize_t res = write(m_fd, &count, sizeof(count));
+    if (res < 0) {
+      fprintf(stderr, "eventfd : %s", strerror(errno));
+      return false;
+    }
+    return true;
+  }
+
+  int get_fd() { return m_fd; }
+  bool initialized() { return m_initialized; }
+
+ private:
+  // not used and not implemented
+  eventfd_object(eventfd_object& other);
+  eventfd_object& operator=(const eventfd_object& other);
+
+  // member varaibles
+  int m_fd;
+  int m_initialized;
+};  // class eventfd_object
+typedef std::shared_ptr<eventfd_object> eventfd_object_ptr;
+
+#ifndef RUNTIME_POLLING
+class uio_interrupt final {
+  public:
+    uio_interrupt(const int fd, const int mmd_handle);
+    ~uio_interrupt();
+    bool initialized() { return _pThread != nullptr; }; // If the thread is not created then must be invalid
+    int set_interrupt_handler(aocl_mmd_interrupt_handler_fn fn, void* user_data);
+
+  private:
+    bool is_irq_available(); // Checks that the interrupt has been mapped into userspace
+    bool enable_irq();  // Enables UIO Irq handling
+    bool disable_irq(); // Disabled UIO Irq handling
+
+    static void work_thread(uio_interrupt &obj);
+    void run_thread(); // Function which handles waiting for interrupts
+
+    uio_interrupt() = delete;
+    uio_interrupt(uio_interrupt const&) = delete;
+    void operator=(uio_interrupt const&) = delete;
+
+    int get_mmd_handle() {return _mmd_handle; };
+
+    std::thread *_pThread = {nullptr}; // Pointer to a thread object for waiting for interrupts
+    int _device_fd = {-1}; // /dev/uio* device pointer
+    int _mmd_handle = {-1}; // handle to the parent mmd_device
+    eventfd_object_ptr _spShutdown_event = {nullptr}; // Shutdown thread event object
+
+    aocl_mmd_interrupt_handler_fn _interrupt_fn = {nullptr};
+    void                          *_interrupt_fn_user_data = {nullptr};
+};
+typedef std::shared_ptr<uio_interrupt> uio_interrupt_ptr;
+#endif
+
+class uio_device
+{
+public:
+  uio_device(std::string &name, const int mmd_handle, const bool bEnableIrq=false);
+  ~uio_device();
+
+  uint32_t read(const uint32_t reg);
+  void write(const uint32_t reg, const uint32_t value);
+
+  int read_block(void *host_addr, size_t offset, size_t size);
+  int write_block(const void *host_addr, size_t offset, size_t size);
+  int set_interrupt_handler(aocl_mmd_interrupt_handler_fn fn, void* user_data);
+
+  bool bValid();
+
+private:
+  bool map_region( std::string &name, const uint32_t index );
+  void unmap_region();
+
+  uio_device() = delete;
+  uio_device(uio_device const&) = delete;
+  void operator=(uio_device const &) = delete;
+
+  int _mmd_handle; // Handle to the parent mmd device
+  int _fd = {-1}; // File pointer to UIO - Used to indicate the the uio_device is valid
+  uint64_t _size;   // Size of the mmapped region
+  uint64_t _offset; // Offset of the first register
+  uint8_t *_pBase; // Base of the mmapped region
+
+  uint32_t *_pPtr; // The first register
+#ifndef RUNTIME_POLLING
+  bool _bIrqEnabled; // Indicates that we tried to create with IRQ
+  uio_interrupt_ptr _spInterrupt; // Object to handle UIO Interrupts
+#endif
+};
+typedef std::shared_ptr<uio_device> uio_device_ptr;
+
+extern board_names uio_get_devices(const std::string name, const int max_devices);
+extern std::string uio_get_device(const std::string prefix, const int32_t index);
+
+#endif // UIO_DEVICE_H_
diff --git a/python/openvino/runtime/coredla_device/mmd/hps_platform/include/aocl_mmd.h b/python/openvino/runtime/coredla_device/mmd/hps_platform/include/aocl_mmd.h
new file mode 100644
index 0000000..7c1c73d
--- /dev/null
+++ b/python/openvino/runtime/coredla_device/mmd/hps_platform/include/aocl_mmd.h
@@ -0,0 +1,645 @@
+#ifndef AOCL_MMD_H
+#define AOCL_MMD_H
+
+/* (c) 1992-2021 Intel Corporation.                             */
+/* Intel, the Intel logo, Intel, MegaCore, NIOS II, Quartus and TalkBack words     */
+/* and logos are trademarks of Intel Corporation or its subsidiaries in the U.S.   */
+/* and/or other countries. Other marks and brands may be claimed as the property   */
+/* of others. See Trademarks on intel.com for full list of Intel trademarks or     */
+/* the Trademarks & Brands Names Database (if Intel) or See www.Intel.com/legal (if Altera)  */
+/* Your use of Intel Corporation's design tools, logic functions and other         */
+/* software and tools, and its AMPP partner logic functions, and any output        */
+/* files any of the foregoing (including device programming or simulation          */
+/* files), and any associated documentation or information are expressly subject   */
+/* to the terms and conditions of the Altera Program License Subscription          */
+/* Agreement, Intel MegaCore Function License Agreement, or other applicable       */
+/* license agreement, including, without limitation, that your use is for the      */
+/* sole purpose of programming logic devices manufactured by Intel and sold by     */
+/* Intel or its authorized distributors.  Please refer to the applicable           */
+/* agreement for further details.                                                  */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Support for memory mapped ACL devices.
+ *
+ * Typical API lifecycle, from the perspective of the caller.
+ *
+ *    1. aocl_mmd_open must be called first, to provide a handle for further
+ *    operations.
+ *
+ *    2. The interrupt and status handlers must be set.
+ *
+ *    3. Read and write operations are performed.
+ *
+ *    4. aocl_mmd_close may be called to shut down the device. No further
+ *    operations are permitted until a subsequent aocl_mmd_open call.
+ *
+ * aocl_mmd_get_offline_info can be called anytime including before
+ * open. aocl_mmd_get_info can be called anytime between open and close.
+ */
+
+#ifndef AOCL_MMD_CALL
+#if defined(_WIN32)
+#define AOCL_MMD_CALL __declspec(dllimport)
+#else
+#define AOCL_MMD_CALL __attribute__((visibility ("default")))
+#endif
+#endif
+
+#ifndef WEAK
+#if defined(_WIN32)
+#define WEAK
+#else
+/* This normally comes with "__attribute__((weak))" but for reasons not presently
+ * understood, the shared library is not properly loaded on Ubuntu18 when the functions
+ * are weak.
+ */
+#define WEAK
+#endif
+#endif
+
+#ifdef DLA_MMD
+#include <cstddef>  //size_t
+#include <cstdint>  //uint32_t
+#endif
+
+/* The MMD API's version - the runtime expects this string when
+ * AOCL_MMD_VERSION is queried. This changes only if the API has changed */
+#define AOCL_MMD_VERSION_STRING "20.3"
+
+/* Memory types that can be supported - bitfield. Other than physical memory
+ * these types closely align with the OpenCL SVM types.
+ *
+ * AOCL_MMD_PHYSICAL_MEMORY - The vendor interface includes IP to communicate
+ * directly with physical memory such as DDR, QDR, etc.
+ *
+ * AOCL_MMD_SVM_COARSE_GRAIN_BUFFER - The vendor interface includes support for
+ * caching SVM pointer data and requires explicit function calls from the user
+ * to synchronize the cache between the host processor and the FPGA. This level
+ * of SVM is not currently supported by Altera except as a subset of
+ * SVM_FINE_GAIN_SYSTEM support.
+ *
+ * AOCL_MMD_SVM_FINE_GRAIN_BUFFER - The vendor interface includes support for
+ * caching SVM pointer data and requires additional information from the user
+ * and/or host runtime that can be collected during pointer allocation in order
+ * to synchronize the cache between the host processor and the FPGA. Once this
+ * additional data is provided for an SVM pointer, the vendor interface handles
+ * cache synchronization between the host processor & the FPGA automatically.
+ * This level of SVM is not currently supported by Altera except as a subset
+ * of SVM_FINE_GRAIN_SYSTEM support.
+ *
+ * AOCL_MMD_SVM_FINE_GRAIN_SYSTEM - The vendor interface includes support for
+ * caching SVM pointer data and does not require any additional information to
+ * synchronize the cache between the host processor and the FPGA. The vendor
+ * interface handles cache synchronization between the host processor & the
+ * FPGA automatically for all SVM pointers. This level of SVM support is
+ * currently under development by Altera and some features may not be fully
+ * supported.
+ */
+#define AOCL_MMD_PHYSICAL_MEMORY (1 << 0)
+#define AOCL_MMD_SVM_COARSE_GRAIN_BUFFER (1 << 1)
+#define AOCL_MMD_SVM_FINE_GRAIN_BUFFER (1 << 2)
+#define AOCL_MMD_SVM_FINE_GRAIN_SYSTEM (1 << 3)
+
+/* program modes - bitfield
+ *
+ * AOCL_MMD_PROGRAM_PRESERVE_GLOBAL_MEM - preserve contents of global memory
+ * when this bit is set to 1. If programming can't occur without preserving
+ * global memory contents, the program function must fail, in which case the
+ * runtime may re-invoke program with this bit set to 0, allowing programming
+ * to occur even if doing so destroys global memory contents.
+ *
+ * more modes are reserved for stacking on in the future
+ */
+#define AOCL_MMD_PROGRAM_PRESERVE_GLOBAL_MEM (1 << 0)
+typedef int aocl_mmd_program_mode_t;
+
+typedef void* aocl_mmd_op_t;
+
+typedef struct {
+  unsigned lo; /* 32 least significant bits of time value. */
+  unsigned hi; /* 32 most significant bits of time value. */
+} aocl_mmd_timestamp_t;
+
+/* Defines the set of characteristics that can be probed about the board before
+ * opening a device. The type of data returned by each is specified in
+ * parentheses in the adjacent comment.
+ *
+ * AOCL_MMD_NUM_BOARDS and AOCL_MMD_BOARD_NAMES
+ *   These two fields can be used to implement multi-device support. The MMD
+ *   layer may have a list of devices it is capable of interacting with, each
+ *   identified with a unique name. The length of the list should be returned
+ *   in AOCL_MMD_NUM_BOARDS, and the names of these devices returned in
+ *   AOCL_MMD_BOARD_NAMES. The OpenCL runtime will try to call aocl_mmd_open
+ *   for each board name returned in AOCL_MMD_BOARD_NAMES.
+ */
+typedef enum {
+  AOCL_MMD_VERSION = 0,     /* Version of MMD (char*)*/
+  AOCL_MMD_NUM_BOARDS = 1,  /* Number of candidate boards (int)*/
+  AOCL_MMD_BOARD_NAMES = 2, /* Names of boards available delimiter=; (char*)*/
+  AOCL_MMD_VENDOR_NAME = 3, /* Name of vendor (char*) */
+  AOCL_MMD_VENDOR_ID = 4,   /* An integer ID for the vendor (int) */
+  AOCL_MMD_USES_YIELD = 5,  /* 1 if yield must be called to poll hw (int) */
+  /* The following can be combined in a bit field:
+   * AOCL_MMD_PHYSICAL_MEMORY, AOCL_MMD_SVM_COARSE_GRAIN_BUFFER, AOCL_MMD_SVM_FINE_GRAIN_BUFFER,
+   * AOCL_MMD_SVM_FINE_GRAIN_SYSTEM. Prior to 14.1, all existing devices supported physical memory and no types of SVM
+   * memory, so this is the default when this operation returns '0' for board MMDs with a version prior to 14.1
+   */
+  AOCL_MMD_MEM_TYPES_SUPPORTED = 6,
+} aocl_mmd_offline_info_t;
+
+/** Possible capabilities to return from AOCL_MMD_*_MEM_CAPABILITIES query */
+/**
+ * If not set allocation function is not supported, even if other capabilities are set.
+ */
+#define AOCL_MMD_MEM_CAPABILITY_SUPPORTED (1 << 0)
+/**
+ *   Supports atomic access to the memory by either the host or device.
+ */
+#define AOCL_MMD_MEM_CAPABILITY_ATOMIC (1 << 1)
+/**
+ * Supports concurrent access to the memory either by host or device if the
+ * accesses are not on the same block. Block granularity is defined by
+ * AOCL_MMD_*_MEM_CONCURRENT_GRANULARITY., blocks are aligned to this
+ * granularity
+ */
+#define AOCL_MMD_MEM_CAPABILITY_CONCURRENT (1 << 2)
+/**
+ * Memory can be accessed by multiple devices at the same time.
+ */
+#define AOCL_MMD_MEM_CAPABILITY_P2P (1 << 3)
+
+/* Defines the set of characteristics that can be probed about the board after
+ * opening a device. This can involve communication to the device
+ *
+ * AOCL_MMD_NUM_KERNEL_INTERFACES - The number of kernel interfaces, usually 1
+ *
+ * AOCL_MMD_KERNEL_INTERFACES - the handle for each kernel interface.
+ * param_value will have size AOCL_MMD_NUM_KERNEL_INTERFACES * sizeof int
+ *
+ * AOCL_MMD_PLL_INTERFACES - the handle for each pll associated with each
+ * kernel interface. If a kernel interface is not clocked by acl_kernel_clk
+ * then return -1
+ *
+ * */
+typedef enum {
+  AOCL_MMD_NUM_KERNEL_INTERFACES = 1,            /* Number of Kernel interfaces (int) */
+  AOCL_MMD_KERNEL_INTERFACES = 2,                /* Kernel interface (int*) */
+  AOCL_MMD_PLL_INTERFACES = 3,                   /* Kernel clk handles (int*) */
+  AOCL_MMD_MEMORY_INTERFACE = 4,                 /* Global memory handle (int) */
+  AOCL_MMD_TEMPERATURE = 5,                      /* Temperature measurement (float) */
+  AOCL_MMD_PCIE_INFO = 6,                        /* PCIe information (char*) */
+  AOCL_MMD_BOARD_NAME = 7,                       /* Name of board (char*) */
+  AOCL_MMD_BOARD_UNIQUE_ID = 8,                  /* Unique ID of board (int) */
+  AOCL_MMD_CONCURRENT_READS = 9,                 /* # of parallel reads; 1 is serial*/
+  AOCL_MMD_CONCURRENT_WRITES = 10,               /* # of parallel writes; 1 is serial*/
+  AOCL_MMD_CONCURRENT_READS_OR_WRITES = 11,      /* total # of concurrent operations read + writes*/
+  AOCL_MMD_MIN_HOST_MEMORY_ALIGNMENT = 12,       /* Min alignment that the BSP supports for host allocations (size_t) */
+  AOCL_MMD_HOST_MEM_CAPABILITIES = 13,           /* Capabilities of aocl_mmd_host_alloc() (unsigned int)*/
+  AOCL_MMD_SHARED_MEM_CAPABILITIES = 14,         /* Capabilities of aocl_mmd_shared_alloc (unsigned int)*/
+  AOCL_MMD_DEVICE_MEM_CAPABILITIES = 15,         /* Capabilities of aocl_mmd_device_alloc (unsigned int)*/
+  AOCL_MMD_HOST_MEM_CONCURRENT_GRANULARITY = 16, /*(size_t)*/
+  AOCL_MMD_SHARED_MEM_CONCURRENT_GRANULARITY = 17, /*(size_t)*/
+  AOCL_MMD_DEVICE_MEM_CONCURRENT_GRANULARITY = 18, /*(size_t)*/
+} aocl_mmd_info_t;
+
+typedef struct {
+  unsigned long long int exception_type;
+  void* user_private_info;
+  size_t user_cb;
+} aocl_mmd_interrupt_info;
+
+typedef void (*aocl_mmd_interrupt_handler_fn)(int handle, void* user_data);
+typedef void (*aocl_mmd_device_interrupt_handler_fn)(int handle, aocl_mmd_interrupt_info* data_in, void* user_data);
+typedef void (*aocl_mmd_status_handler_fn)(int handle, void* user_data, aocl_mmd_op_t op, int status);
+
+/* Get information about the board using the enum aocl_mmd_offline_info_t for
+ * offline info (called without a handle), and the enum aocl_mmd_info_t for
+ * info specific to a certain board.
+ * Arguments:
+ *
+ *   requested_info_id - a value from the aocl_mmd_offline_info_t enum
+ *
+ *   param_value_size - size of the param_value field in bytes. This should
+ *     match the size of the return type expected as indicated in the enum
+ *     definition. For example, the AOCL_MMD_TEMPERATURE returns a float, so
+ *     the param_value_size should be set to sizeof(float) and you should
+ *     expect the same number of bytes returned in param_size_ret.
+ *
+ *   param_value - pointer to the variable that will receive the returned info
+ *
+ *   param_size_ret - receives the number of bytes of data actually returned
+ *
+ * Returns: a negative value to indicate error.
+ */
+AOCL_MMD_CALL int aocl_mmd_get_offline_info(aocl_mmd_offline_info_t requested_info_id,
+                                            size_t param_value_size,
+                                            void* param_value,
+                                            size_t* param_size_ret) WEAK;
+
+// AOCL_MMD_CALL int aocl_mmd_get_info(int handle,
+//                                     aocl_mmd_info_t requested_info_id,
+//                                     size_t param_value_size,
+//                                     void* param_value,
+//                                     size_t* param_size_ret) WEAK;
+
+/* Open and initialize the named device.
+ *
+ * The name is typically one specified by the AOCL_MMD_BOARD_NAMES offline
+ * info.
+ *
+ * Arguments:
+ *    name - open the board with this name (provided as a C-style string,
+ *           i.e. NUL terminated ASCII.)
+ *
+ * Returns: the non-negative integer handle for the board, otherwise a
+ * negative value to indicate error. Upon receiving the error, the OpenCL
+ * runtime will proceed to open other known devices, hence the MMD mustn't
+ * exit the application if an open call fails.
+ */
+AOCL_MMD_CALL int aocl_mmd_open(const char* name) WEAK;
+
+/* Close an opened device, by its handle.
+ * Returns: 0 on success, negative values on error.
+ */
+AOCL_MMD_CALL int aocl_mmd_close(int handle) WEAK;
+
+/* Set the interrupt handler for the opened device.
+ * The interrupt handler is called whenever the client needs to be notified
+ * of an asynchronous event signaled by the device internals.
+ * For example, the kernel has completed or is stalled.
+ *
+ * Important: Interrupts from the kernel must be ignored until this handler is
+ * set
+ *
+ * Arguments:
+ *   fn - the callback function to invoke when a kernel interrupt occurs
+ *   user_data - the data that should be passed to fn when it is called.
+ *
+ * Returns: 0 if successful, negative on error
+ */
+AOCL_MMD_CALL int aocl_mmd_set_interrupt_handler(int handle, aocl_mmd_interrupt_handler_fn fn, void* user_data) WEAK;
+
+/* Set the device interrupt handler for the opened device.
+ * The device interrupt handler is called whenever the client needs to be notified
+ * of a device event signaled by the device internals.
+ * For example, an ECC error has been reported.
+ *
+ * Important: Interrupts from the device must be ignored until this handler is
+ * set
+ *
+ * Arguments:
+ *   fn - the callback function to invoke when a device interrupt occurs
+ *   user_data - the data that should be passed to fn when it is called.
+ *
+ * Returns: 0 if successful, negative on error
+ */
+// AOCL_MMD_CALL int aocl_mmd_set_device_interrupt_handler(int handle,
+//                                                         aocl_mmd_device_interrupt_handler_fn fn,
+//                                                         void* user_data) WEAK;
+
+/* Set the operation status handler for the opened device.
+ * The operation status handler is called with
+ *    status 0 when the operation has completed successfully.
+ *    status negative when the operation completed with errors.
+ *
+ * Arguments:
+ *   fn - the callback function to invoke when a status update is to be
+ *   performed.
+ *   user_data - the data that should be passed to fn when it is called.
+ *
+ * Returns: 0 if successful, negative on error
+ */
+//AOCL_MMD_CALL int aocl_mmd_set_status_handler(int handle, aocl_mmd_status_handler_fn fn, void* user_data) WEAK;
+
+/* If AOCL_MMD_USES_YIELD is 1, this function is called when the host is idle
+ * and hence possibly waiting for events to be processed by the device.
+ * If AOCL_MMD_USES_YIELD is 0, this function is never called and the MMD is
+ * assumed to provide status/event updates via some other execution thread
+ * such as through an interrupt handler.
+ *
+ * Returns: non-zero if the yield function performed useful work such as
+ * processing DMA transactions, 0 if there is no useful work to be performed
+ *
+ * NOTE: yield may be called continuously as long as it reports that it has useful work
+ */
+//AOCL_MMD_CALL int aocl_mmd_yield(int handle) WEAK;
+
+/* Read, write and copy operations on a single interface.
+ * If op is NULL
+ *    - Then these calls must block until the operation is complete.
+ *    - The status handler is not called for this operation.
+ *
+ * If op is non-NULL, then:
+ *    - These may be non-blocking calls
+ *    - The status handler must be called upon completion, with status 0
+ *    for success, and a negative value for failure.
+ *
+ * Arguments:
+ *   op - the operation object used to track this operations progress
+ *
+ *   len - the size in bytes to transfer
+ *
+ *   src - the host buffer being read from
+ *
+ *   dst - the host buffer being written to
+ *
+ *   mmd_interface - the handle to the interface being accessed. E.g. To
+ *   access global memory this handle will be whatever is returned by
+ *   aocl_mmd_get_info when called with AOCL_MMD_MEMORY_INTERFACE.
+ *
+ *   offset/src_offset/dst_offset - the byte offset within the interface that
+ *   the transfer will begin at.
+ *
+ * The return value is 0 if the operation launch was successful, and
+ * negative otherwise.
+ */
+AOCL_MMD_CALL int aocl_mmd_read(
+    int handle, aocl_mmd_op_t op, size_t len, void* dst, int mmd_interface, size_t offset) WEAK;
+AOCL_MMD_CALL int aocl_mmd_write(
+    int handle, aocl_mmd_op_t op, size_t len, const void* src, int mmd_interface, size_t offset) WEAK;
+// AOCL_MMD_CALL int aocl_mmd_copy(
+//     int handle, aocl_mmd_op_t op, size_t len, int mmd_interface, size_t src_offset, size_t dst_offset) WEAK;
+
+/* Host Channel create operation
+ * Opens channel between host and kernel.
+ *
+ * Arguments:
+ *   channel_name - name of channel to initialize. Same name as used in board_spec.xml
+ *
+ *   queue_depth - the size in bytes of pinned memory queue in system memory
+ *
+ *   direction - the direction of the channel
+ *
+ * The return value is negative if initialization was unsuccessful, and
+ * positive otherwise. Positive return value is handle to the channel to be used for
+ * subsequent calls for the channel.
+ */
+//AOCL_MMD_CALL int aocl_mmd_hostchannel_create(int handle, char* channel_name, size_t queue_depth, int direction) WEAK;
+
+/* Host Channel destroy operation
+ * Closes channel between host and kernel.
+ *
+ * Arguments:
+ *   channel - the handle to the channel to close, that was obtained with
+ *             create channel
+ *
+ * The return value is 0 if the destroy was successful, and negative
+ * otherwise.
+ */
+//AOCL_MMD_CALL int aocl_mmd_hostchannel_destroy(int handle, int channel) WEAK;
+
+/* Host Channel get buffer operation
+ * Provide host with pointer to buffer they can access to write or
+ * read from kernel, along with space or data available in the buffer
+ * in bytes.
+ *
+ * Arguments:
+ *   channel - the handle to the channel to get the buffer for
+ *
+ *   buffer_size - the address that this call will write the amount of
+ *                 space or data that's available in the buffer,
+ *                 depending on direction of the channel, in bytes
+ *
+ *   status - the address that this call will write to for result of this
+ *            call. Value will be 0 for success, and negative otherwise
+ *
+ * The return value is the pointer to the buffer that host can write
+ * to or read from. NULL if the status is negative.
+ */
+//AOCL_MMD_CALL void* aocl_mmd_hostchannel_get_buffer(int handle, int channel, size_t* buffer_size, int* status) WEAK;
+
+/* Host Channel acknowledge buffer operation
+ * Acknowledge to the channel that the user has written or read data from
+ * it. This will make the data or additional buffer space available to
+ * write to or read from kernel.
+ *
+ * Arguments:
+ *   channel - the handle to the channel that user is acknowledging
+ *
+ *   send_size - the size in bytes that the user is acknowledging
+ *
+ *   status - the address that this call will write to for result of this
+ *            call. Value will be 0 for success, and negative otherwise
+ *
+ * The return value is equal to send_size if send_size was less than or
+ * equal to the buffer_size from get buffer call. If send_size was
+ * greater, then return value is the amount that was actually sent.
+ */
+//AOCL_MMD_CALL size_t aocl_mmd_hostchannel_ack_buffer(int handle, int channel, size_t send_size, int* status) WEAK;
+
+/* Program the device
+ *
+ * The host will guarantee that no operations are currently executing on the
+ * device. That means the kernels will be idle and no read/write/copy
+ * commands are active. Interrupts should be disabled and the FPGA should
+ * be reprogrammed with the data from user_data which has size size. The host
+ * will then call aocl_mmd_set_status_handler and aocl_mmd_set_interrupt_handler
+ * again. At this point interrupts can be enabled.
+ *
+ * The new handle to the board after reprogram does not have to be the same as
+ * the one before.
+ *
+ * Arguments:
+ *   user_data - The binary contents of the fpga.bin file created during
+ *   Quartus II compilation.
+ *   size - the size in bytes of user_data
+ *   program_mode - bit field for programming attributes. See
+ *   aocl_mmd_program_mode_t definition
+ *
+ * Returns: the new non-negative integer handle for the board, otherwise a
+ * negative value to indicate error.
+ */
+
+// #ifdef DLA_MMD
+// // CoreDLA BSP has removed some stuff that MMD tries to handshake with, so provide a "raw access" function to
+// // reprogram the FPGA directly from the sof. Can't call quartus_pgm directly since the MMD still needs to mask
+// // the PCIe surprise down error (when full-chip programming the FPGA, the CPU thinks a PCIe device has disappeared).
+// // BEWARE: reprogramming will invalidate the handle
+// AOCL_MMD_CALL int aocl_mmd_program_sof(int handle, const char* sof_filename) WEAK;
+// #else
+// AOCL_MMD_CALL int aocl_mmd_program(int handle, void* user_data, size_t size, aocl_mmd_program_mode_t program_mode) WEAK;
+// #endif
+
+/** Error values*/
+#define AOCL_MMD_ERROR_SUCCESS 0
+#define AOCL_MMD_ERROR_INVALID_HANDLE -1
+#define AOCL_MMD_ERROR_OUT_OF_MEMORY -2
+#define AOCL_MMD_ERROR_UNSUPPORTED_ALIGNMENT -3
+#define AOCL_MMD_ERROR_UNSUPPORTED_PROPERTY -4
+#define AOCL_MMD_ERROR_INVALID_POINTER -5
+#define AOCL_MMD_ERROR_INVALID_MIGRATION_SIZE -6
+
+/** Memory properties*/
+typedef enum {
+  /**
+   *  Specifies the name of a global memory that can be found in the
+   *  board_spec.xml file for the BSP. Allocations will be allocated to this
+   *  global memory interface.
+   */
+  AOCL_MMD_MEM_PROPERTIES_GLOBAL_MEMORY = 1,
+  /**
+   *  Specifies the index of a bank inside the global memory interface that can be found in
+   *  the board_spec.xml file for the BSP. Allocations will be allocated to this
+   *  memory bank. It is invalid to specify this property without also specifying
+   *  AOCL_MMD_GLOBAL_MEMORY_INTERFACE.
+   */
+  AOCL_MMD_MEM_PROPERTIES_MEMORY_BANK
+} aocl_mmd_mem_properties_t;
+
+/**
+ *  Host allocations provide memory that is allocated on the host. Host
+ *  allocations are accessible by the host and one or more devices.
+ *  The same pointer to a host allocation may be used on the host and all
+ *  supported devices; they have address equivalence. This memory must be
+ *  deallocated with aocl_mmd_free();
+ *
+ *  Once the device has signaled completion through
+ *  aocl_mmd_interrupt_handler_fn() the host can assume it has access to the
+ *  latest contents of the memory, allocated by this call.
+ *
+ *  @param handles Handles for devices that will need access to this memory
+ *  @param num_devices Number of devices in the handles
+ *  @param size The size of the memory region
+ *  @param alignment The alignment in bytes of the allocation
+ *  @param properties Specifies additional information about the allocated
+ *    memory, described by a property type name and its corresponding value.
+ *    Each property type name is immediately followed by the corresponding
+ *    desired value. The list is terminated with 0. Supported values are
+ *    described above. Example: [<property1>, <value1>, <property2>, <value2>, 0]
+ *  @param error The error code defined by AOCL_MMD_ERROR*
+ *  @return valid pointer, on error NULL
+ */
+// AOCL_MMD_CALL void* aocl_mmd_host_alloc(int* handles,
+//                                         size_t num_devices,
+//                                         size_t size,
+//                                         size_t alignment,
+//                                         aocl_mmd_mem_properties_t* properties,
+//                                         int* error) WEAK;
+
+/**
+ * Frees memory that has been allocated by MMD
+ *
+ * @param mem The pointer to the memory region. Must be a pointer that is
+ *   allocated by the MMD.
+ * @return AOCL_MMD_ERROR_SUCCESS if success, else error code
+ */
+// AOCL_MMD_CALL int aocl_mmd_free(void* mem) WEAK;
+
+/**
+ *  Allocate memory that is owned by the device. This pointer can only be
+ *  accessed by the kernel; can't be accessed by the host. The host is able to
+ *  manipulate the pointer (e.g. increment it) just not access the underlying
+ *  data. This memory must be deallocated by aocl_mmd_free();
+ *
+ *  @param  handle Device that will have access to this memory
+ *  @param  size The size of the memory region
+ *  @param  alignment The alignment in bytes of the memory region
+ *  @param  properties Specifies additional information about the allocated
+ *    memory, described by a property type name and its corresponding value.
+ *    Each property type name is immediately followed by the corresponding
+ *    desired value. The list is terminated with 0. Supported values are
+ *    described above. Example: [<property1>, <value1>, <property2>, <value2>, 0]
+ *  @param error The error code defined by AOCL_MMD_ERROR*
+ *  @return Pointer that can be passed into the kernel. NULL on failure.
+ */
+// AOCL_MMD_CALL void* aocl_mmd_device_alloc(
+//     int handle, size_t size, size_t alignment, aocl_mmd_mem_properties_t* properties, int* error) WEAK;
+
+/**
+ *  Shared allocations may migrate between the host and one or more associated
+ *  device. The same pointer to a shared allocation may be used on the host and
+ *  the supported device; they have address equivalence.
+ *
+ *  If the device does not support concurrent access to memory allocated by
+ *  aocl_mmd_shared_alloc() then a call must be made to
+ *  aocl_mmd_shared_mem_migrate() to indicate that the shared allocation should
+ *  be migrated to the device before the device accesses this memory.  For
+ *  example, a call to aocl_mmd_shared_mem_migrate() should be made before a
+ *  kernel accessing this memory is launched).  Conversely,
+ *  aocl_mmd_shared_mem_migrate() should be called again to indicate that the
+ *  shared allocation should be migrated to the host before the host accesses
+ *  this memory again.  If the device supports concurrent access to memory
+ *  allocated with aocl_mmd_shared_alloc(), then the call to
+ *  aocl_mmd_shared_mem_migrate() is not necessary, but may still be made.  In
+ *  the case of concurrent access, it is the responsibility of the MMD to ensure
+ *  both the device and host can access aocl_mmd_shared_alloc() allocations at
+ *  all times.
+ *
+ *  Memory allocated by aocl_mmd_shared_alloc() must be deallocated with
+ *  aocl_mmd_free().
+ *
+ *  @param  handle Device that will have access to this memory
+ *  @param  size The size of the memory region
+ *  @param alignment The alignment in bytes of the memory region
+ *  @param  properties Specifies additional information about the allocated
+ *    memory, described by a property type name and its corresponding value.
+ *    Each property type name is immediately followed by the corresponding
+ *    desired value. The list is terminated with 0. Supported properties are
+ *    listed above and have the prefix AOCL_MMD_MEM_PROPERTIES_.
+ *    Example: [<property1>, <value1>, <property2>, <value2>, 0]
+ *  @param error The error code defined by AOCL_MMD_ERROR*
+ *  @return valid pointer, on error NULL
+ */
+// AOCL_MMD_CALL void* aocl_mmd_shared_alloc(
+//     int handle, size_t size, size_t alignment, aocl_mmd_mem_properties_t* properties, int* error) WEAK;
+
+typedef enum { AOCL_MMD_MIGRATE_TO_HOST = 0, AOCL_MMD_MIGRATE_TO_DEVICE = 1 } aocl_mmd_migrate_t;
+
+/**
+ *  A call to aocl_mmd_shared_migrate() must be made for non-concurrent shared
+ *  allocations any time the accessor of the allocation changes.  For example,
+ *  aocl_mmd_shared_migrate() should be called indicating that the allocation
+ *  should be migrated to the device before a kernel accessing the allocation
+ *  is launched on the device.  Similarly, aocl_mmd_shared_migrate() should be
+ *  called indicating that the allocation is migrated to the host before the
+ *  host accesses the memory after kernel completion.
+ *
+ *  For concurrent allocations this call may be used as a performance hint, but
+ *  is not strictly required for functionality.
+ *
+ *  @param  handle Device that will have access to this memory
+ *  @param shared_ptr Pointer allocated by aocl_mmd_shared_alloc()
+ *  @param size In bytes, the size of the migration. Must be of multiple of a
+ *   page boundary that the BSP supports.
+ *  @param destination The destination of migration
+ *  @return The error code defined by AOCL_MMD_ERROR*
+ */
+// AOCL_MMD_CALL int aocl_mmd_shared_migrate(int handle,
+//                                           void* shared_ptr,
+//                                           size_t size,
+//                                           aocl_mmd_migrate_t destination) WEAK;
+
+// CoreDLA modifications
+// To support multiple different FPGA boards, anything board specific must be implemented in a
+// board-specific MMD instead of the CoreDLA runtime layer.
+#ifdef DLA_MMD
+// Query functions to get board-specific values
+AOCL_MMD_CALL int dla_mmd_get_max_num_instances() WEAK;
+AOCL_MMD_CALL uint64_t dla_mmd_get_ddr_size_per_instance() WEAK;
+AOCL_MMD_CALL double dla_mmd_get_ddr_clock_freq() WEAK;
+
+// Wrappers around CSR and DDR reads and writes to abstract away board-specific offsets
+AOCL_MMD_CALL int dla_mmd_csr_write(int handle, int instance, uint64_t addr, const uint32_t* data) WEAK;
+AOCL_MMD_CALL int dla_mmd_csr_read(int handle, int instance, uint64_t addr, uint32_t* data) WEAK;
+AOCL_MMD_CALL int dla_mmd_ddr_write(int handle, int instance, uint64_t addr, uint64_t length, const void* data) WEAK;
+AOCL_MMD_CALL int dla_mmd_ddr_read(int handle, int instance, uint64_t addr, uint64_t length, void* data) WEAK;
+
+#define STREAM_CONTROLLER_ACCESS
+#ifdef STREAM_CONTROLLER_ACCESS
+AOCL_MMD_CALL bool dla_is_stream_controller_valid(int handle, int instance) WEAK;
+AOCL_MMD_CALL int dla_mmd_stream_controller_write(int handle, int instance, uint64_t addr, uint64_t length, const void* data) WEAK;
+AOCL_MMD_CALL int dla_mmd_stream_controller_read(int handle, int instance, uint64_t addr, uint64_t length, void* data) WEAK;
+#endif
+
+// Get the PLL clock frequency in MHz, returns a negative value if there is an error
+AOCL_MMD_CALL double dla_mmd_get_coredla_clock_freq(int handle) WEAK;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif