initial software driver for dma

examples/10.dma_test/README.md

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

examples/10.dma_test/dma-test-v1.cc

@@ -0,0 +1,52 @@
+// Copyright Microsoft and CHERIoT Contributors.
+// SPDX-License-Identifier: MIT
+
+#include <compartment.h>
+#include <cstdint>
+#include <cstdlib>
+#include <debug.hh>
+#include <utils.hh>
+
+#include <../../sdk/core/dma-v1/dma.h>
+
+// Expose debugging features unconditionally for this compartment.
+using Debug = ConditionalDebug<true, "DMA Compartment">;
+
+// Thread entry point.
+void __cheri_compartment("dma_test") test_dma()
+{
+	Debug::log("DMA app entered, v1!");
+
+	// This is a dma process between two different memory addresses
+	uint32_t bytes    = 1024;
+	uint32_t words    = bytes / 4;
+	uint32_t byteSwap = 0;
+
+	uint32_t *sourceAddress    = (uint32_t *)malloc(bytes);
+	uint32_t *targetAddress    = (uint32_t *)malloc(bytes);
+
+	for (int i = 0; i < words; i++)
+	{
+		*(sourceAddress + i)    = i + 100;
+		*(targetAddress + i)    = 0;
+	}
+
+	Debug::log("M:Ind: 0 and last, Source values BEFORE dma: {}, {}",
+	           *(sourceAddress),
+	           *(sourceAddress + words - 1));
+	Debug::log("M: Ind: 0 and last, Dest-n values BEFORE dma: {}, {}",
+	           *(targetAddress),
+	           *(targetAddress + words - 1));
+
+	static DMA::Device dmaDevice;
+
+	int ret = dmaDevice.configure_and_launch(
+	sourceAddress, targetAddress, bytes, 0, 0, byteSwap);
+
+	Debug::log("Main, ret: {}", ret);
+
+	Debug::log("M: Ind: 0 and last, Dest-n values AFTER dma: {}, {}",
+	           *(targetAddress),
+	           *(targetAddress + words - 1));
+	Debug::log("M: End of test");
+}

examples/10.dma_test/dma-test-v2.cc

@@ -0,0 +1,54 @@
+// Copyright Microsoft and CHERIoT Contributors.
+// SPDX-License-Identifier: MIT
+#define MALLOC_QUOTA 0x10000000
+
+#include <compartment.h>
+#include <cstdint>
+#include <cstdlib>
+#include <debug.hh>
+#include <utils.hh>
+
+#include <../../sdk/core/dma-v2/dma.h>
+
+// Expose debugging features unconditionally for this compartment.
+using Debug = ConditionalDebug<true, "DMA Compartment">;
+
+// Thread entry point.
+void __cheri_compartment("dma_test") test_dma()
+{
+	Debug::log("DMA app entered, v3.3!");
+
+	// This is a dma process between two different memory addresses
+	uint32_t bytes    = 8096;
+	uint32_t words    = bytes / 4;
+	uint32_t byteSwap = 0;
+
+	uint32_t *sourceAddress    = (uint32_t *)malloc(bytes);
+	uint32_t *targetAddress    = (uint32_t *)malloc(bytes);
+
+	for (int i = 0; i < words; i++)
+	{
+		*(sourceAddress + i)    = i + 100;
+		*(targetAddress + i)    = 0;
+	}
+
+	Debug::log("M:Ind: 0 and last, Source values BEFORE dma: {}, {}",
+	           *(sourceAddress),
+	           *(sourceAddress + words - 1));
+	Debug::log("M: Ind: 0 and last, Dest-n values BEFORE dma: {}, {}",
+	           *(targetAddress),
+	           *(targetAddress + words - 1));
+
+	static DMA::Device dmaDevice;
+
+	int ret = dmaDevice.configure_and_launch(
+	sourceAddress, targetAddress, bytes, 0, 0, byteSwap);
+
+	Debug::log("Main, ret: {}", ret);
+
+	Debug::log("M: Ind: 0 and last, Dest-n values AFTER dma: {}, {}",
+	           *(targetAddress),
+	           *(targetAddress + words - 1));
+
+	Debug::log("M: End of test");
+}

examples/10.dma_test/dma-test-v3.cc

@@ -0,0 +1,54 @@
+// Copyright Microsoft and CHERIoT Contributors.
+// SPDX-License-Identifier: MIT
+#define MALLOC_QUOTA 0x10000000
+
+#include <compartment.h>
+#include <cstdint>
+#include <cstdlib>
+#include <debug.hh>
+#include <utils.hh>
+
+#include <../../sdk/core/dma-v3/dma.h>
+
+// Expose debugging features unconditionally for this compartment.
+using Debug = ConditionalDebug<true, "DMA Compartment">;
+
+// Thread entry point.
+void __cheri_compartment("dma_test") test_dma()
+{
+	Debug::log("DMA app entered, v3.0!");
+
+	// This is a dma process between two different memory addresses
+	uint32_t bytes    = 8096;
+	uint32_t words    = bytes / 4;
+	uint32_t byteSwap = 0;
+
+	uint32_t *sourceAddress    = (uint32_t *)malloc(bytes);
+	uint32_t *targetAddress    = (uint32_t *)malloc(bytes);
+
+	for (int i = 0; i < words; i++)
+	{
+		*(sourceAddress + i)    = i + 100;
+		*(targetAddress + i)    = 0;
+	}
+
+	Debug::log("M:Ind: 0 and last, Source values BEFORE dma: {}, {}",
+	           *(sourceAddress),
+	           *(sourceAddress + words - 1));
+	Debug::log("M: Ind: 0 and last, Dest-n values BEFORE dma: {}, {}",
+	           *(targetAddress),
+	           *(targetAddress + words - 1));
+
+	static DMA::Device dmaDevice;
+
+	int ret = dmaDevice.configure_and_launch(
+	sourceAddress, targetAddress, bytes, 0, 0, byteSwap);
+
+	Debug::log("Main, ret: {}", ret);
+
+	Debug::log("M: Ind: 0 and last, Dest-n values AFTER dma: {}, {}",
+	           *(targetAddress),
+	           *(targetAddress + words - 1));
+
+	Debug::log("M: End of test");
+}

examples/10.dma_test/dma-test-v4.cc

@@ -0,0 +1,69 @@
+// Copyright Microsoft and CHERIoT Contributors.
+// SPDX-License-Identifier: MIT
+#define MALLOC_QUOTA 0x10000000
+
+#include <../../sdk/core/dma-v4/platform-dma.hh>
+#include <compartment.h>
+#include <cstdint>
+#include <cstdlib>
+#include <debug.hh>
+#include <utils.hh>
+
+#include <../../sdk/core/dma-v4/dma.h>
+
+// Expose debugging features unconditionally for this compartment.
+using Debug = ConditionalDebug<true, "DMA Driver">;
+
+using namespace Ibex;
+
+// Thread entry point.
+void __cheri_compartment("dma_test") test_dma()
+{
+	Debug::log("DMA app entered, v4.0!");
+
+	// This is a dma process between two different memory addresses
+	uint32_t bytes    = 8096;
+	uint32_t words    = bytes / 4;
+	uint32_t byteSwap = 0;
+
+	uint32_t *sourceAddress    = (uint32_t *)malloc(bytes);
+	uint32_t *targetAddress    = (uint32_t *)malloc(bytes);
+
+	for (int i = 0; i < words; i++)
+	{
+		*(sourceAddress + i)    = i + 100;
+		*(targetAddress + i)    = 0;
+	}
+
+	DMADescriptor *dmaDescriptorPointer = (DMADescriptor *) malloc(sizeof(DMADescriptor));
+
+	/**
+	 *  Set the configurations here,
+	 *  before sending the descriptor to the DMA
+	 */
+	dmaDescriptorPointer->sourceCapability = sourceAddress;
+	dmaDescriptorPointer->targetCapability = targetAddress;
+	dmaDescriptorPointer->lengthInBytes    = bytes;
+	dmaDescriptorPointer->sourceStrides    = 0;
+	dmaDescriptorPointer->targetStrides    = 0;
+	dmaDescriptorPointer->byteSwaps		   = byteSwap;
+
+	Debug::log("M:Ind: 0 and last, Source values BEFORE dma: {}, {}",
+	           *(sourceAddress),
+	           *(sourceAddress + words - 1));
+	Debug::log("M: Ind: 0 and last, Dest-n values BEFORE dma: {}, {}",
+	           *(targetAddress),
+	           *(targetAddress + words - 1));
+
+	static DMA::Device dmaDevice;
+
+	int ret = dmaDevice.configure_and_launch(dmaDescriptorPointer);
+
+	Debug::log("Main, ret: {}", ret);
+
+	Debug::log("M: Ind: 0 and last, Dest-n values AFTER dma: {}, {}",
+	           *(targetAddress),
+	           *(targetAddress + words - 1));
+
+	Debug::log("M: 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/cxxrt"),
+         path.join(sdkdir, "lib/atomic"),
+         path.join(sdkdir, "lib/crt"))
+
+option("board")
+    set_default("sail")
+
+compartment("dma")
+    add_files(path.join(sdkdir, "core/dma-v2/dma_compartment.cc"))
+
+compartment("dma_test")
+    add_files("dma-test-v2.cc")
+
+-- Firmware image for the example.
+firmware("dma-test-v2")
+    add_deps("crt", "cxxrt", "freestanding", "atomic_fixed")
+    add_deps("dma", "dma_test")
+    on_load(function(target)
+        target:values_set("board", "$(board)")
+        target:values_set("threads", {
+            {
+                compartment = "dma_test",
+                priority = 2,
+                entry_point = "test_dma",
+                stack_size = 0x1000,
+                trusted_stack_frames = 9
+            }
+        }, {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/allocator/alloc.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include "../dma-v2/platform-dma.hh"
 #include "alloc_config.h"
 #include "revoker.h"
 #include <algorithm>
@@ -21,6 +22,8 @@
 
 extern Revocation::Revoker revoker;
 
+Ibex::PlatformDMA platformDma;
+
 /// Do we have temporal safety support in hardware?
 constexpr bool HasTemporalSafety =
   !std::is_same_v<Revocation::Revoker, Revocation::NoTemporalSafety>;
@@ -1174,6 +1177,13 @@ class MState
 		 * the user capability (or its progeny) that undid our work of zeroing!
 		 */
 		revoker.shadow_paint_range<true>(mem.address(), chunk.cell_next());
+
+		/**
+		 * notify the DMA, so it can stop the transfer if its the DMA's source
+		 * and destination addresses that are freed. 
+		 */
+		// platformDma.notify_the_dma();
+		Debug::log("freed address: {}", mem.address());
 
 		/*
 		 * Shadow bits have been painted. From now on user caps to this chunk