initial software driver for dma

examples/10.dma_test/README.md

@@ -0,0 +1,4 @@
+DMA example
+===================
+
+

examples/10.dma_test/dma_test.cc

@@ -0,0 +1,73 @@
+// Copyright Microsoft and CHERIoT Contributors.
+// SPDX-License-Identifier: MIT
+
+#include <compartment.h>
+#include <cstdint>
+#include <cstdlib>
+#include <debug.hh>
+#include <utils.hh>
+
+#include <fail-simulator-on-error.h>
+#include <../../sdk/core/dma/dma.h>
+
+#include <thread.h>
+#include <thread_pool.h>
+
+// Expose debugging features unconditionally for this compartment.
+using Debug = ConditionalDebug<true, "DMA Compartment">;
+
+using namespace thread_pool;
+
+// Thread entry point.
+void __cheri_compartment("dma_app") dma_request()
+{
+	Debug::log("DMA app entered!");
+
+	// This is a dma process between two different memory addresses
+	uint32_t bytes = 1024;
+	uint32_t words = bytes/4;
+	uint32_t byteSwap = 4;
+
+	uint32_t *sourceAddress = (uint32_t*) malloc(bytes);
+	uint32_t *targetAddress = (uint32_t*) malloc(bytes);
+	uint32_t *alternateAddress = (uint32_t*) malloc(bytes);
+
+	for (int i=0; i < words; i++)
+	{
+		*(sourceAddress + i) = i + 100;
+		*(sourceAddress + i) = i + 200;
+		*(targetAddress + i) = 0;
+
+	}
+
+	Debug::log("Ind: 0 and last, Source values BEFORE dma: {}, {}", *(sourceAddress), *(sourceAddress + words -1 ));
+	Debug::log("Ind: 0 and last, Dest-n values BEFORE dma: {}, {}", *(targetAddress),  *(targetAddress + words -1 ));
+
+	DMA::Device dmaDevice;
+
+	async([&]() {
+		Debug::log("Thread 1, start");
+
+		int ret = dmaDevice.configure_and_launch(sourceAddress, targetAddress, bytes, 0, 0, byteSwap);
+
+	    Debug::log("Ind: 0 and last, Source values AFTER dma: {}, {}", *(sourceAddress), *(sourceAddress + words -1 ));
+	    Debug::log("Ind: 0 and last, Dest-n values AFTER dma: {}, {}", *(targetAddress),  *(targetAddress + words -1 ));
+
+	    Debug::log("Thread 1, ret: {}", ret);
+	});
+
+	async([&]() 
+	{
+		Debug::log("Thread 2, start");
+
+		int ret = dmaDevice.configure_and_launch(alternateAddress, targetAddress, bytes, 0, 0, 0);
+
+		Debug::log("Ind: 0 and last, Source values AFTER dma: {}, {}", *(alternateAddress), *(alternateAddress + words -1 ));
+		Debug::log("Ind: 0 and last, Dest-n values AFTER dma: {}, {}", *(targetAddress),  *(targetAddress + words -1 ));
+
+	    Debug::log("Thread 2, ret: {}", ret);
+	});
+
+	Debug::log("Ind: 0 and last, Dest-n values AFTER dma: {}, {}", *(targetAddress),  *(targetAddress + words -1 ));
+	Debug::log("End of test");
+}

examples/10.dma_test/xmake.lua

@@ -0,0 +1,39 @@
+-- Copyright Microsoft and CHERIoT Contributors.
+-- SPDX-License-Identifier: MIT
+
+set_project("CHERIoT Simple DMA App")
+sdkdir = "../../sdk"
+includes(sdkdir)
+set_toolchains("cheriot-clang")
+
+-- Support libraries
+includes(path.join(sdkdir, "lib/freestanding"),
+         path.join(sdkdir, "lib/atomic"),
+         path.join(sdkdir, "lib/crt"))
+
+option("board")
+    set_default("sail")
+
+compartment("dma")
+    add_files(path.join(sdkdir, "core/dma/dma_compartment.cc"))
+
+compartment("dma_app")
+    add_files("dma_test.cc")
+
+-- Firmware image for the example.
+firmware("dma_test")
+    add_deps("crt", "freestanding", "atomic_fixed")
+    add_deps("dma", "dma_app")
+    -- add_deps("dma_app")
+    on_load(function(target)
+        target:values_set("board", "$(board)")
+        target:values_set("threads", {
+            {
+                compartment = "dma_app",
+                priority = 1,
+                entry_point = "dma_request",
+                stack_size = 0x400,
+                trusted_stack_frames = 2
+            }
+        }, {expand = false})
+    end)

ibex.json

@@ -0,0 +1,71 @@
+{
+	"devices" :
+	{
+		"hspTimer" : {
+			"start"  : 0x8f000800,
+			"length" : 0x20
+		},
+		"hspInteruptController" : {
+			"start"  : 0x8f000600,
+			"length" : 0x14
+		},
+		"uart" : {
+			"start" : 0x8f00b000,
+			"length": 0x100
+		},
+		"shadow" : {
+			"start" : 0x200f0000,
+			"end"   : 0x200f1800
+		},
+		"revoker" : {
+			"start" : 0x8f000000,
+			"length": 0xc
+		},
+		"dmb" : {
+			"start" : 0x8f0f0000,
+			"length": 0x400
+		},
+		"ethernet" : {
+			"start" : 0x98000000,
+			"length": 0x204
+		},
+		"LEDs" : {
+			"start" : 0x8f00 f004,
+			"end": 0x2020_0040
+		},
+		"dma" : {
+			"start" : 0x2020_0000,
+			"end"   : 0x2020_0040	  
+		}
+	},
+	"instruction_memory" : {
+		"start" : 0x20000080,
+		"end"   : 0x20060000
+	},
+	"heap" : {
+		"end"   : 0x20060000
+	},
+	"revokable_memory_start" : 0x20000000,
+	"interrupts": [
+		{
+			"name": "Ethernet",
+			"number": 16,
+			"priority": 0
+		}
+	],
+	"defines" : [
+		"IBEX",
+		"IBEX_SHADOW_BASE=0x200f0000U",
+		"IBEX_SHADOW_SIZE=0x1800U"
+	],
+	"driver_includes" : [
+		"../include/",
+		"${sdk}/include/platform/ibex",
+		"${sdk}/include/platform/generic-riscv"
+	],
+	"timer_hz" : 20000000,
+	"tickrate_hz" : 100,
+	"stack_high_water_mark" : true,
+	"revoker" : "hardware",
+	"simulator" : "${board}/../scripts/deploy-ibex-fpga.sh"
+}

sdk/core/dma/dma.h

@@ -0,0 +1,100 @@
+#include "dma_compartment.hh"
+#include "futex.h"
+#include "platform-dma.hh"
+#include <concepts>
+#include <cstddef>
+#include <stdint.h>
+#include <utils.hh>
+#include <interrupt.h>
+#include <errno.h>
+
+DECLARE_AND_DEFINE_INTERRUPT_CAPABILITY(dmaInterruptCapability, dma, true, true);
+
+namespace DMA 
+{		
+
+    template<typename T>
+	concept IsDmaDevice = requires(T device, uint32_t *sourceAddress, uint32_t *targetAddress, size_t lengthInBytes,
+                                        uint32_t sourceStrides, uint32_t targetStrides, uint32_t byteSwapAmount)
+	{
+		{
+			device.write_conf_and_start(sourceAddress, targetAddress, lengthInBytes,
+											sourceStrides, targetStrides, byteSwapAmount)
+			} -> std::same_as<void>;
+        {
+			device.reset_dma()
+			} -> std::same_as<void>;
+	};
+
+    template<typename PlatformDMA>
+
+	requires IsDmaDevice<PlatformDMA>
+
+	class GenericDMA : public PlatformDMA
+	{
+		public:
+
+        int configure_and_launch(uint32_t *sourceAddress, uint32_t *targetAddress, uint32_t lengthInBytes,
+                        uint32_t sourceStrides, uint32_t targetStrides, uint32_t byteSwapAmount)
+        {	
+			/**
+			 *  Fetch the interrupt counter for the dma
+			 *  to use for future operations
+			 */
+
+			const uint32_t *dmaFutex = interrupt_futex_get(STATIC_SEALED_VALUE(dmaInterruptCapability));
+
+			/** 
+			 *  Dma launch call: 
+			 *  - checks for the dma ownership status, 
+			 *  - for access rights,
+			 *  - creates claims for each source and destination addresses,
+			 *  - automatically resets the claims and the dma registers
+			 *    at the end of the transfer.
+			 */
+
+			int dmaInterruptReturn = launch_dma(sourceAddress, targetAddress, lengthInBytes,
+                        sourceStrides, targetStrides, byteSwapAmount);
+
+			/**
+			 *  Negative interrupt return is for 
+			 *  the failed dma launch and forces to wait for the interrupt.
+			 *  However, wait only until timeout elapses
+			 */
+
+			Timeout t{10};
+
+			while (dmaInterruptReturn < 0)
+			{	
+				uint32_t realInterruptNumber = -(dmaInterruptReturn)-1;
+
+				futex_timed_wait(&t, dmaFutex, realInterruptNumber);
+
+				dmaInterruptReturn = launch_dma(sourceAddress, targetAddress, lengthInBytes,
+                        sourceStrides, targetStrides, byteSwapAmount);
+
+				if (!t.remaining)
+				{
+					return -EINVAL;
+				}
+			}
+
+			/**
+			 *  Handle the interrupt here, once dmaFutex woke up via scheduler.
+			 *  DMA interrupt means that the dma operation is finished 
+			 *  and it is time to reset and clear the dma configuration registers.
+			 *  Unlike with futex wait of other threads, as an occupying thread we 
+			 *  wait indefinitely as much as needed for the dma completion			
+			 */
+			futex_wait(dmaFutex, dmaInterruptReturn);
+
+    		reset_and_clear_dma(dmaInterruptReturn);
+
+			return 0;
+		}
+
+	};
+
+    using Device = GenericDMA<PlatformDMA>;
+}
+