From 26681f7b3098802cb4c0cfc3e3a062a7202773dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felix=20=28xq=29=20Quei=C3=9Fner?= Date: Wed, 28 Apr 2021 23:57:39 +0200 Subject: [PATCH] blinky works for lpc1768 --- .gitignore | 1 + src/core/gpio.zig | 26 +++++++++++++++++--- src/core/interrupts.zig | 8 +++--- src/modules/chips/atmega328p/atmega328p.zig | 7 ++++++ src/modules/chips/lpc1768/lpc1768.zig | 7 ++++++ src/modules/cpus/cortex-m3/cortex-m3.zig | 27 ++++++++++++++++++--- 6 files changed, 65 insertions(+), 11 deletions(-) diff --git a/.gitignore b/.gitignore index 3cef7be..ac2eddc 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ zig-cache/ +dev-scripts/ \ No newline at end of file diff --git a/src/core/gpio.zig b/src/core/gpio.zig index fc5665f..bbbe57d 100644 --- a/src/core/gpio.zig +++ b/src/core/gpio.zig @@ -83,12 +83,30 @@ pub fn Gpio(comptime pin: type, config: anytype) type { } // bi-di: - fn setDirection(dir: Direction, output_state: State) void {} - fn getDirection() Direction {} + fn setDirection(dir: Direction, output_state: State) void { + switch (dir) { + .output => { + chip.gpio.setOutput(pin.source_pin); + write(output_state); + }, + .input => chip.gpio.setInput(pin.source_pin), + } + } + fn getDirection() Direction { + if (chip.gpio.isOutput(pin.source_pin)) { + return .output; + } else { + return .input; + } + } // open drain - fn setDrive(drive: Drive) void {} - fn getDrive() Drive {} + fn setDrive(drive: Drive) void { + @compileError("open drain not implemented yet!"); + } + fn getDrive() Drive { + @compileError("open drain not implemented yet!"); + } }; // return only a subset of Generic for the requested pin. switch (mode) { diff --git a/src/core/interrupts.zig b/src/core/interrupts.zig index 8ca66bc..10013c4 100644 --- a/src/core/interrupts.zig +++ b/src/core/interrupts.zig @@ -4,17 +4,17 @@ const micro = @import("microzig.zig"); /// Unmasks the given interrupt and enables its execution. /// Note that interrupts must be globally enabled with `sei()` as well. pub fn enable(comptime interrupt: anytype) void { - @panic("not implemented yet!"); + @compileError("not implemented yet!"); } /// Masks the given interrupt and disables its execution. pub fn disable(comptime interrupt: anytype) void { - @panic("not implemented yet!"); + @compileError("not implemented yet!"); } /// Returns true when the given interrupt is unmasked. pub fn isEnabled(comptime interrupt: anytype) bool { - @panic("not implemented yet!"); + @compileError("not implemented yet!"); } /// *Set Enable Interrupt*, will enable IRQs globally, but keep the masking done via @@ -31,7 +31,7 @@ pub fn cli() void { /// Returns true, when interrupts are globally enabled via `sei()`. pub fn areGloballyEnabled() bool { - @panic("not implemented yet!"); + @compileError("not implemented yet!"); } /// Enters a critical section and disables interrupts globally. diff --git a/src/modules/chips/atmega328p/atmega328p.zig b/src/modules/chips/atmega328p/atmega328p.zig index 876679d..3e6b978 100644 --- a/src/modules/chips/atmega328p/atmega328p.zig +++ b/src/modules/chips/atmega328p/atmega328p.zig @@ -33,6 +33,13 @@ pub const gpio = struct { return @intToPtr(*volatile u8, 0x01); } + pub fn setOutput(comptime pin: type) void { + dirReg(pin).* |= (1 << pin.pin); + } + pub fn setInput(comptime pin: type) void { + dirReg(pin).* &= ~(@as(u8, 1) << pin.pin); + } + pub fn read(comptime pin: type) u1 { return if ((pinReg(pin).* & (1 << pin.pin)) != 0) @as(u1, 1) diff --git a/src/modules/chips/lpc1768/lpc1768.zig b/src/modules/chips/lpc1768/lpc1768.zig index 7bde22e..ec7e100 100644 --- a/src/modules/chips/lpc1768/lpc1768.zig +++ b/src/modules/chips/lpc1768/lpc1768.zig @@ -26,6 +26,13 @@ pub fn parsePin(comptime spec: []const u8) type { } pub const gpio = struct { + pub fn setOutput(comptime pin: type) void { + pin.gpio_register.dir |= pin.gpio_mask; + } + pub fn setInput(comptime pin: type) void { + pin.gpio_register.dir &= ~pin.gpio_mask; + } + pub fn read(comptime pin: type) u1 { return if ((pin.gpio_register.pin & pin.gpio_mask) != 0) @as(u1, 1) diff --git a/src/modules/cpus/cortex-m3/cortex-m3.zig b/src/modules/cpus/cortex-m3/cortex-m3.zig index b1f6d7a..4c82311 100644 --- a/src/modules/cpus/cortex-m3/cortex-m3.zig +++ b/src/modules/cpus/cortex-m3/cortex-m3.zig @@ -74,11 +74,32 @@ pub const startup_logic = struct { extern fn microzig_main() noreturn; + extern var microzig_data_start: c_void; + extern var microzig_data_end: c_void; + extern var microzig_bss_start: c_void; + extern var microzig_bss_end: c_void; + extern const microzig_data_load_start: c_void; + fn _start() callconv(.C) noreturn { - // TODO: - // - Load .data - // - Clear .bss + // fill .bss with zeroes + { + const bss_start = @ptrCast([*]u8, µzig_bss_start); + const bss_end = @ptrCast([*]u8, µzig_bss_end); + const bss_len = @ptrToInt(bss_end) - @ptrToInt(bss_start); + + std.mem.set(u8, bss_start[0..bss_len], 0); + } + + // load .data from flash + { + const data_start = @ptrCast([*]u8, µzig_data_start); + const data_end = @ptrCast([*]u8, µzig_data_end); + const data_len = @ptrToInt(data_end) - @ptrToInt(data_start); + const data_src = @ptrCast([*]const u8, µzig_data_load_start); + + std.mem.copy(u8, data_start[0..data_len], data_src[0..data_len]); + } microzig_main(); }