add async dma

Author: piotrfila

core/src/core/Io.zig

@@ -26,11 +26,13 @@ fn to_stack_units(size: usize) usize {
 /// Downside: Performance (may be mitigated once https://github.com/ziglang/zig/issues/23367 is implemeted).
 pub const PauseReason = union(enum) {
     const OnStack = [to_stack_units(@sizeOf(@This()))]StackUint;
+    const PtrMask = struct { ptr: *const usize, mask: usize };
 
     /// Task volutarily gave up execution, but is ready to continue.
     yield,
     sleep_until: time.Absolute align(@alignOf(StackUint)),
-    bits_mask_any_high: struct { ptr: *const usize, mask: usize },
+    bits_mask_all_low: PtrMask,
+    bits_mask_any_high: PtrMask,
     /// This value means there is no context stored on this stack
     /// so it can be used to launch a new task.
     no_task,
@@ -48,6 +50,9 @@ pub const PauseReason = union(enum) {
             .bits_mask_any_high => |info| {
                 return @atomicLoad(usize, info.ptr, .acquire) & info.mask != 0;
             },
+            .bits_mask_all_low => |info| {
+                return @atomicLoad(usize, info.ptr, .acquire) & info.mask == 0;
+            },
             .sleep_until => |t| t.is_reached_by(io.monotonic_clock()),
         };
     }
@@ -303,11 +308,24 @@ pub const RoundRobin = struct {
     pub fn monotonic_clock(this: *@This()) time.Absolute {
         return this.vtable.monotonic_clock();
     }
+
+    /// Perform memcpy with DMA. `dst` and `src` must have the same length.
+    pub fn dma_memcpy(this: *@This(), T: type, dst: []T, src: []const T) !DmaResult {
+        assert(dst.len == src.len);
+        return this.vtable.dma_memcpy(dst.ptr, src.ptr, dst.len * @sizeOf(T));
+    }
+};
+
+/// TODO: I hate this
+pub const DmaResult = struct {
+    await: *const fn (*@This(), *RoundRobin) void,
+    channel: u32,
 };
 
 /// Common functionality between all implementations.
 /// Needs to be specified by every port.
 pub const VTable = struct {
     /// A clock source that only ever goes up, not synchronized with epoch.
     monotonic_clock: *const fn () time.Absolute,
+    dma_memcpy: *const fn (*anyopaque, *const anyopaque, usize) anyerror!DmaResult,
 };

examples/raspberrypi/rp2xxx/src/async_blinky.zig

@@ -49,10 +49,18 @@ pub fn main() !void {
     io.async(task_blink, .{ &io, 24_000 });
     io.async(task_blink, .{ &io, 25_000 });
 
+    // DMA demo: using large arrays to prove waiting for transfer completion works.
+    const src: [1 << 15]u32 = @splat(1);
+    var dst: [1 << 15]u32 = @splat(0);
+    std.log.info("Before DMA: {any}", .{dst[dst.len - 16 ..]});
+    var future_dma = try io.dma_memcpy(u32, &dst, &src);
+    future_dma.await(&future_dma, &io);
+    std.log.info("After DMA: {any}", .{dst[dst.len - 16 ..]});
+
     var deadline: time.Absolute = io.monotonic_clock();
     var cnt: u32 = 0;
     while (true) {
-        try uart.writer().print("Hello! {}\r\n", .{cnt});
+        std.log.info("Hello! {}\r\n", .{cnt});
         cnt += 1;
         deadline = deadline.add_duration(.from_ms(1000));
         io.pause(&.{ .sleep_until = deadline });

port/raspberrypi/rp2xxx/src/hal.zig

@@ -19,11 +19,7 @@ pub const dma = @import("hal/dma.zig");
 pub const drivers = @import("hal/drivers.zig");
 pub const flash = @import("hal/flash.zig");
 pub const gpio = @import("hal/gpio.zig");
-pub const Io = struct {
-    pub const vtable: microzig.core.Io.VTable = .{
-        .monotonic_clock = time.get_time_since_boot,
-    };
-};
+pub const Io = @import("hal/Io.zig");
 pub const multicore = @import("hal/multicore.zig");
 pub const mutex = @import("hal/mutex.zig");
 pub const pins = @import("hal/pins.zig");

port/raspberrypi/rp2xxx/src/hal/Io.zig

@@ -0,0 +1,31 @@
+const std = @import("std");
+const microzig = @import("microzig");
+const rp2xxx = @import("../hal.zig");
+const Io = microzig.core.Io;
+
+/// See Io.VTable for function descriptions.
+pub const vtable: Io.VTable = .{
+    .monotonic_clock = rp2xxx.time.get_time_since_boot,
+    .dma_memcpy = dma_memcpy,
+};
+
+pub fn dma_memcpy(dst: *anyopaque, src: *const anyopaque, size: usize) !Io.DmaResult {
+    const channel = rp2xxx.dma.claim_unused_channel().?;
+    try channel.setup_transfer(
+        @as([*]u8, @ptrCast(dst))[0..size],
+        @as([*]const u8, @ptrCast(src))[0..size],
+        .{ .trigger = true, .enable = true },
+    );
+    return .{
+        .await = &dma_await,
+        .channel = @intFromEnum(channel),
+    };
+}
+
+pub fn dma_await(result: *Io.DmaResult, io: *Io.RoundRobin) void {
+    const channel = rp2xxx.dma.channel(@intCast(result.channel));
+    const ctrl = &channel.get_regs().ctrl_trig;
+    var mask: @TypeOf(ctrl.*).underlying_type = @bitCast(@as(u32, 0));
+    mask.BUSY = 1;
+    io.pause(&.{ .bits_mask_all_low = .{ .ptr = @ptrCast(@volatileCast(ctrl)), .mask = @bitCast(mask) } });
+}

port/raspberrypi/rp2xxx/src/hal/dma.zig

@@ -183,15 +183,16 @@ pub const Channel = enum(u4) {
             inline fn get_addr(value: anytype) u32 {
                 const Type = @TypeOf(value);
                 const Info = @typeInfo(Type);
-                switch (Info) {
+                return switch (Info) {
                     .@"struct" => {
-                        return value.addr;
+                        value.addr;
                     },
-                    .pointer => {
-                        return @intFromPtr(value);
+                    .pointer => |ptr| switch (ptr.size) {
+                        .one, .c, .many => @intFromPtr(value),
+                        .slice => @intFromPtr(value.ptr),
                     },
                     else => comptime unreachable,
-                }
+                };
             }
 
             inline fn get_dreq(value: anytype) Dreq {