sylveos

gpio.zig (6424B)

---

 const std = @import("std");
 const shared = @import("shared");
 
 const mem = @import("../mem.zig");
 const interrupts = @import("../interrupts.zig");
 
 pub const Error = error{
     PinOutOfRange,
 };
 
 // Page 90, Table 6-1: GPIO Register Assignment
 const BASE_ADDRESS: usize = mem.BASE_ADDRESS + 0x0020_0000;
 const GPFSEL0: usize = BASE_ADDRESS + 0x0000;
 const GPSET0: usize = BASE_ADDRESS + 0x001C;
 const GPCLR0: usize = BASE_ADDRESS + 0x0028;
 const GPLEV0: usize = BASE_ADDRESS + 0x0034;
 const GPEDS0: usize = BASE_ADDRESS + 0x0040;
 const GPREN0: usize = BASE_ADDRESS + 0x004C;
 const GPFEN0: usize = BASE_ADDRESS + 0x0058;
 const GPHEN0: usize = BASE_ADDRESS + 0x0064;
 const GPLEN0: usize = BASE_ADDRESS + 0x0070;
 const GPPUD: usize = BASE_ADDRESS + 0x0094;
 const GPPUDCLK0: usize = BASE_ADDRESS + 0x0098;
 
 pub const MAX_GPIO: u8 = 53;
 const GPIO_PER_FSEL: u8 = 10;
 
 fn gpio_check(pin: u8) Error!void {
     if (pin > MAX_GPIO) return Error.PinOutOfRange;
 }
 
 fn get_address(pin: u8, offset: usize, chunk: ?u32) Error!*u32 {
     try gpio_check(pin);
 
     // One might say "@bitSizeOf(u32)" is redundant but I do not care
     const index = @divFloor(pin, chunk orelse @bitSizeOf(u32)) * @sizeOf(u32);
     const address: *u32 = @ptrFromInt(offset + index);
 
     return address;
 }
 
 // Page 92, Table 6-2: GPIO Alternate function select register 0
 // All function select registers reflect this bit layout
 pub const FunctionSelect = enum(u3) {
     input = 0b000,
     output = 0b001,
 
     alt_fn_0 = 0b100,
     alt_fn_1 = 0b101,
     alt_fn_2 = 0b110,
     alt_fn_3 = 0b111,
     alt_fn_4 = 0b011,
     alt_fn_5 = 0b010,
 };
 
 pub fn fn_sel(pin: u8, sel: FunctionSelect) Error!void {
     const address = try get_address(pin, GPFSEL0, GPIO_PER_FSEL);
 
     const offset: u5 = @truncate((pin % GPIO_PER_FSEL) * 3);
     const mask = ~(@as(u32, 0b111) << offset);
 
     var state = mem.get_u32(address);
     state &= mask;
     state |= (@as(u32, @intCast(@intFromEnum(sel))) << offset);
     mem.put_u32(address, state);
 }
 
 fn addr_bitset(pin: u8, address: *u32) void {
     const offset: u5 = @truncate(pin % 32);
     const mask = (@as(u32, 1) << offset);
 
     // We don't want to preserve the old value
     // SET and CLR are separated for this purpose
     mem.put_u32(address, mask);
 }
 
 fn addr_bitget(pin: u8, address: *u32) bool {
     const offset: u5 = @truncate(pin % 32);
     const mask = (@as(u32, 1) << offset);
 
     return (mem.get_u32(address) & mask) != 0;
 }
 
 fn addr_bitor_set(pin: u8, address: *u32) void {
     const offset: u5 = @truncate(pin % 32);
     const mask = (@as(u32, 1) << offset);
 
     mem.put_u32(address, mem.get_u32(address) | mask);
 }
 
 fn addr_bitor_unset(pin: u8, address: *u32) void {
     const offset: u5 = @truncate(pin % 32);
     const mask = (@as(u32, 1) << offset);
 
     mem.put_u32(address, mem.get_u32(address) | ~mask);
 }
 
 // Turn on
 fn output_set(pin: u8) Error!void {
     addr_bitset(pin, try get_address(pin, GPSET0, null));
 }
 
 // Turn off
 fn output_clear(pin: u8) Error!void {
     addr_bitset(pin, try get_address(pin, GPCLR0, null));
 }
 
 // Public API
 pub fn set_output(pin: u8) Error!void {
     try fn_sel(pin, .output);
 }
 
 pub fn set_input(pin: u8) Error!void {
     try fn_sel(pin, .input);
 }
 
 pub fn set_on(pin: u8) Error!void {
     try output_set(pin);
 }
 
 pub fn set_off(pin: u8) Error!void {
     try output_clear(pin);
 }
 
 pub fn read(pin: u8) Error!bool {
     const address = try get_address(pin, GPLEV0, null);
 
     const offset: u5 = @truncate(pin % 32);
     const mask = (@as(u32, 1) << offset);
 
     return (mem.get_u32(address) & mask) == mask;
 }
 
 pub fn write(pin: u8, state: bool) Error!void {
     if (state) {
         try set_on(pin);
     } else {
         try set_off(pin);
     }
 }
 
 pub const PullMode = enum(u2) {
     Off = 0b00,
     Down = 0b01,
     Up = 0b10,
 };
 
 fn wait(count: usize) void {
     var c = count;
     while (c != 0) {
         c -= 1;
     }
 }
 
 pub fn set_pull(pin: u8, pull: PullMode) Error!void {
     try gpio_check(pin);
 
     // Set GPPUD
     mem.put_u32(@ptrFromInt(GPPUD), @intFromEnum(pull));
 
     // Wait 150 cycles
     wait(150);
 
     // Set GPPUDCLK
     const GPPUDCLK = try get_address(pin, GPPUDCLK0, null);
     addr_bitset(pin, GPPUDCLK);
 
     // Wait 150 cycles
     wait(150);
 
     // Clear GPPUD & GPPUDCLK
     mem.put_u32(GPPUDCLK, 0);
     mem.put_u32(@ptrFromInt(GPPUDCLK0), 0);
 }
 
 pub const Event = union(enum) {
     PinEvent: u8,
     PinRisingEdge: u8,
     PinFallingEdge: u8,
 };
 var buffer: [1024]u8 = undefined;
 var fba: std.heap.FixedBufferAllocator = undefined;
 pub var ev: shared.Publisher(Event) = undefined;
 
 pub fn rising_edge_interrupt(pin: u8, enable: bool) Error!void {
     try gpio_check(pin);
 
     if (enable) {
         addr_bitor_set(pin, try get_address(pin, GPREN0, null));
     } else {
         addr_bitor_unset(pin, try get_address(pin, GPREN0, null));
     }
 }
 
 pub fn falling_edge_interrupt(pin: u8, enable: bool) Error!void {
     try gpio_check(pin);
 
     if (enable) {
         addr_bitor_set(pin, try get_address(pin, GPFEN0, null));
     } else {
         addr_bitor_unset(pin, try get_address(pin, GPFEN0, null));
     }
 }
 
 fn has_event(pin: u8) Error!bool {
     try gpio_check(pin);
 
     return addr_bitget(pin, try get_address(pin, GPEDS0, null));
 }
 
 fn clear_event(pin: u8) Error!void {
     try gpio_check(pin);
 
     addr_bitset(pin, try get_address(pin, GPEDS0, null));
 }
 
 pub fn enable_interrupts() !void {
     mem.barrier(.Write);
 
     fba = .init(&buffer);
     ev = try .init(fba.allocator());
 
     interrupts.set_exception_handler(.IRQ, gpio_handler);
     interrupts.enable_peripheral_interrupt(.GPIO0);
     interrupts.enable_peripheral_interrupt(.GPIO1);
 
     mem.barrier(.Write);
 }
 
 noinline fn gpio_handler(registers: interrupts.Registers) void {
     _ = registers;
     mem.barrier(.Write);
     defer mem.barrier(.Write);
 
     // Pins 0-53
     if (!interrupts.pending_peripheral_interrupt(.GPIO0) and !interrupts.pending_peripheral_interrupt(.GPIO1)) {
         return;
     }
 
     // Find out which pin had the event
 
     // A bit rubbish
     for (0..(MAX_GPIO + 1)) |n| {
         const pin: u8 = @truncate(n);
         if (!(has_event(pin) catch false)) continue;
 
         if (read(pin) catch unreachable) {
             // Likely rising
             ev.publish(.PinRisingEdge, pin);
         } else {
             // Likely falling
             ev.publish(.PinFallingEdge, pin);
         }
 
         clear_event(pin) catch {};
     }
 }