//! By convention, main.zig is where your main function lives in the case that
//! you are building an executable. If you are making a library, the convention
//! is to delete this file and start with root.zig instead.
//const std = @import("std");

const gpio_registers = packed struct {
    moder: u32,
    otyper: u32,
    ospeedr: u32,
    pupdr: u32,
    idr: u32,
    odr: u32,
    bsrr: u32,
    lckr: u32,
    afrl: u32,
    afrh: u32,
    brr: u32,
    ascr: u32,
};

const gpio = struct {
    port: *gpio_registers,

    const mode = enum {
        input,
        output,
        alternate,
        analog,
    };

    pub fn set_mode(self: gpio, pin: u4, m: mode) void {
        self.port.moder &= ~(@as(u32, 0x3) << (2 * pin));

        const mask: u32 = switch (m) {
            .input => 0,
            .output => 1,
            .alternate => 2,
            .analog => 3
        };

        self.port.moder |= mask << (2 * pin);
    }

    pub fn toggle(self: gpio, pin: u4) void {
        self.port.odr ^= @as(u32, 1) << pin;
    }
};

const cpu = struct {
    pub fn interrupt_disable() void {
        asm volatile("cpsid i");
    }

    pub fn interrupt_enable() void {
        asm volatile("cpsie i");
    }
};

const gpioa = gpio { .port = @ptrFromInt(0x48000000) };
const rcc: *[39]u32 = @ptrFromInt(0x40021000);

export fn _start() callconv(.C) noreturn {
    cpu.interrupt_disable();

    rcc[19] |= 1; // gpioaen
    gpioa.set_mode(5, .output);

    while (true) {
        gpioa.toggle(5);
    }
}

export fn fault_handler() callconv(.C) void {
    while (true) {}
}