paoda
/
zba
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: paoda:954fb279ad8b7e16aa26f39bf09ba2e409101b41
Branches Tags
paoda:main
paoda:april-fools
paoda:window
paoda:apu-things
..
compare: paoda:8b4faca80fe9b062e6e30d879026e8449952dbca
Branches Tags
paoda:main
paoda:april-fools
paoda:window
paoda:apu-things

4 Commits
954fb279ad ... 8b4faca80f

Author SHA1 Message Date
Rekai Nyangadzayi Musuka 8b4faca80f ci: re-enable zig master builds on CI 2023-07-17 01:11:57 -05:00
Rekai Nyangadzayi Musuka f73b096d62 chore: update dependencies 2023-07-17 01:09:54 -05:00
Rekai Nyangadzayi Musuka d4b7167e29 chore: simply some zig fmt builtin changes 2023-07-17 01:09:54 -05:00
Rekai Nyangadzayi Musuka d96c9c01ff chore: update to latest builtin syntax 2023-07-10 22:09:48 -05:00
29 changed files with 700 additions and 707 deletions
Show Stats Expand all files Collapse all files

2
.github/workflows/main.yml vendored
View File

@ -20,7 +20,7 @@ jobs:
steps: steps:
- uses: goto-bus-stop/setup-zig@v2 - uses: goto-bus-stop/setup-zig@v2
with: with:
version: 0.11.0-dev.3395+1e7dcaa3a version: master
- name: prepare-linux - name: prepare-linux
if: runner.os == 'Linux' if: runner.os == 'Linux'
run: | run: |

32
build.zig.zon
View File

@ -3,36 +3,36 @@
.version = "0.1.0", .version = "0.1.0",
.dependencies = .{ .dependencies = .{
.nfd = .{ .nfd = .{
.url = "https://github.com/fabioarnold/nfd-zig/archive/8520a6807f046a23ecf3143e22fc49d2a9d1c189.tar.gz", .url = "https://github.com/fabioarnold/nfd-zig/archive/ae6df5e13f1013cee66929d934d34225b7bbb372.tar.gz",
.hash = "122089e0f5ab5e4729a09aed48d721b98ed2b362923ead797c6af3b54ef9a725203f", .hash = "122040d748f2fed10c4786077ef2b6edbe65ab15c741a6450befab5867e3f828eb24",
}, },
.@"known-folders" = .{ .@"known-folders" = .{
.url = "https://github.com/ziglibs/known-folders/archive/d13ba6137084e55f873f6afb67447fe8906cc951.tar.gz", .url = "https://github.com/ziglibs/known-folders/archive/03b70c3179e404c0d03b5480ddda52d4e0c8b744.tar.gz",
.hash = "122028c00915d9b37296059be8a3883c718dbb5bd174350caedf152fed1f46f99607", .hash = "1220480ebdabd57a5aa79889239c7f353a76a83a0185cced414589cf7bae29fcd272",
}, },
.@"zig-datetime" = .{ .@"zig-datetime" = .{
.url = "https://github.com/frmdstryr/zig-datetime/archive/e4a2bc92b3771a745145c9a6961f0b5277a48335.tar.gz", .url = "https://github.com/frmdstryr/zig-datetime/archive/ddecb4e508e99ad6ab1314378225413959d54756.tar.gz",
.hash = "12209fc05ecb5add8f87152f03f99243a419c9dd5a04c6b4a359d6b4f13426fede0c", .hash = "12202cbb909feb6b09164ac997307c6b1ab35cb05a846198cf41f7ec608d842c1761",
}, },
.@"zig-clap" = .{ .@"zig-clap" = .{
.url = "https://github.com/Hejsil/zig-clap/archive/a1b7a7301b0006bb4c8daaaf5ade8a6df8ec13ae.tar.gz", .url = "https://github.com/Hejsil/zig-clap/archive/bdb5853b678d68f342ec65b04a6785af522ca6c9.tar.gz",
.hash = "12205aeff59f41f96033d280471730c171c9a825d8758743249bed834e1590f593e3", .hash = "12202af04ec78191f2018458a7be29f54e0d9118f7688e7a226857acf754d68b8473",
}, },
.@"zba-gdbstub" = .{ .@"zba-gdbstub" = .{
.url = "https://git.musuka.dev/paoda/zba-gdbstub/archive/39a4260ffd83bae7bb44bb098872c96382fb5ba3.tar.gz", .url = "https://git.musuka.dev/paoda/zba-gdbstub/archive/dc159b4aebfa4a6dbafcd0ad0006ee9fe53a8bad.tar.gz",
.hash = "1220b87e4c519f28dce7380ed83f936a4aea2d81046209b18a23eb6c0738b156ca16", .hash = "122021a32734d559087b912c72be759709d7f57758d747b2ae0176e88a7a3bf39ad6",
}, },
.@"zba-util" = .{ .@"zba-util" = .{
.url = "https://git.musuka.dev/paoda/zba-util/archive/e616cf09e53f5c402c8f040d14baa211683e70e3.tar.gz", .url = "https://git.musuka.dev/paoda/zba-util/archive/322c798e384a0d24cc84ffcfa2e4a3ca807798a0.tar.gz",
.hash = "1220b80b2c0989dcc47275ab9d7d70da4858ef3c1fe1f934e8d838e65028127f6ef3", .hash = "12209ce0e729460b997706e47a53a32f1842672cd120189e612f4871731780a30ed0",
}, },
.tomlz = .{ .tomlz = .{
.url = "https://github.com/mattyhall/tomlz/archive/4928d38e9bb682a9966ffe7f41230435d0111b1e.tar.gz", .url = "https://github.com/mattyhall/tomlz/archive/1a6f112183fa04ec88b2cab2a2e71cb1f8a40dd1.tar.gz",
.hash = "12202b57d7b46fff8d16a17371c4f9b711a56b866f0cd11844e4243c09343a2c4c6d", .hash = "122098fcc1a1699303f7207d7ca3528750a972d927be2942eef4cd454ee52036650d",
}, },
.arm32 = .{ .arm32 = .{
.url = "https://git.musuka.dev/paoda/arm32/archive/3c8a87c14dfa2501bd0a7f2236259e2d8d0fbcd9.tar.gz", .url = "https://git.musuka.dev/paoda/arm32/archive/6c81608c5914888858abea56514707712d64272a.tar.gz",
.hash = "12202a06a5d20d0da9ab6596a04821431d261c9900c7916a87148619dcb77c745044", .hash = "1220b305f4ecba1918479e60dbe31c99f7763a0ce3883e7dcf30d24e0dc11f44a9c9",
}, },
}, },
} }

2
lib/SDL.zig

@ -1 +1 @@
Subproject commit fbe5f599c65b7a5642990443b2a686d1c53a4985 Subproject commit 4d565b54227b862c1540719e0e21a36d649e87d5

10
lib/bitfield.zig
View File

@ -26,13 +26,13 @@ fn BitType(comptime FieldType: type, comptime ValueType: type, comptime shamt: u
} }
pub fn read(self: anytype) ValueType { pub fn read(self: anytype) ValueType {
return @bitCast(ValueType, @truncate(u1, self.bits.field().* >> shamt)); return @bitCast(@as(u1, @truncate(self.bits.field().* >> shamt)));
} }
// Since these are mostly used with MMIO, I want to avoid // Since these are mostly used with MMIO, I want to avoid
// reading the memory just to write it again, also races // reading the memory just to write it again, also races
pub fn write(self: anytype, val: ValueType) void { pub fn write(self: anytype, val: ValueType) void {
if (@bitCast(bool, val)) { if (@as(bool, @bitCast(val))) {
self.set(); self.set();
} else { } else {
self.unset(); self.unset();
@ -67,17 +67,17 @@ pub fn Bitfield(comptime FieldType: type, comptime shamt: usize, comptime num_bi
dummy: FieldType, dummy: FieldType,
fn field(self: anytype) PtrCastPreserveCV(@This(), @TypeOf(self), FieldType) { fn field(self: anytype) PtrCastPreserveCV(@This(), @TypeOf(self), FieldType) {
return @ptrCast(PtrCastPreserveCV(@This(), @TypeOf(self), FieldType), self); return @ptrCast(self);
} }
pub fn write(self: anytype, val: ValueType) void { pub fn write(self: anytype, val: ValueType) void {
self.field().* &= ~self_mask; self.field().* &= ~self_mask;
self.field().* |= @intCast(FieldType, val) << shamt; self.field().* |= @as(FieldType, @intCast(val)) << shamt;
} }
pub fn read(self: anytype) ValueType { pub fn read(self: anytype) ValueType {
const val: FieldType = self.field().*; const val: FieldType = self.field().*;
return @intCast(ValueType, (val & self_mask) >> shamt); return @intCast((val & self_mask) >> shamt);
} }
}; };
} }

688
lib/gl.zig
View File

File diff suppressed because it is too large Load Diff

2
lib/zgui

@ -1 +1 @@
Subproject commit 5149d4b1def740194cf627d8d68bce18024dc7ce Subproject commit 25fa193b1f324d9183b3808bc6582ee7d0e3b13f

56
src/core/Bus.zig
View File

@ -98,7 +98,7 @@ pub fn deinit(self: *Self) void {
// This is so I can deallocate the original `allocator.alloc`. I have to re-make the type // This is so I can deallocate the original `allocator.alloc`. I have to re-make the type
// since I'm not keeping it around, This is very jank and bad though // since I'm not keeping it around, This is very jank and bad though
// FIXME: please figure out another way // FIXME: please figure out another way
self.allocator.free(@ptrCast([*]const ?*anyopaque, self.read_table[0..])[0 .. 3 * table_len]); self.allocator.free(@as([*]const ?*anyopaque, @ptrCast(self.read_table[0..]))[0 .. 3 * table_len]);
self.* = undefined; self.* = undefined;
} }
@ -147,7 +147,7 @@ fn fillReadTable(self: *Self, table: *[table_len]?*const anyopaque) void {
const vramMirror = @import("ppu/Vram.zig").mirror; const vramMirror = @import("ppu/Vram.zig").mirror;
for (table, 0..) |*ptr, i| { for (table, 0..) |*ptr, i| {
const addr = @intCast(u32, page_size * i); const addr: u32 = @intCast(page_size * i);
ptr.* = switch (addr) { ptr.* = switch (addr) {
// General Internal Memory // General Internal Memory
@ -174,7 +174,7 @@ fn fillWriteTable(self: *Self, comptime T: type, table: *[table_len]?*const anyo
const vramMirror = @import("ppu/Vram.zig").mirror; const vramMirror = @import("ppu/Vram.zig").mirror;
for (table, 0..) |*ptr, i| { for (table, 0..) |*ptr, i| {
const addr = @intCast(u32, page_size * i); const addr: u32 = @intCast(page_size * i);
ptr.* = switch (addr) { ptr.* = switch (addr) {
// General Internal Memory // General Internal Memory
@ -227,7 +227,7 @@ fn fillReadTableExternal(self: *Self, addr: u32) ?*anyopaque {
// We are using a "small" EEPROM which means that if the below check is true // We are using a "small" EEPROM which means that if the below check is true
// (that is, we're in the 0xD address page) then we must handle at least one // (that is, we're in the 0xD address page) then we must handle at least one
// address in this page in slowmem // address in this page in slowmem
if (@truncate(u4, addr >> 24) == 0xD) return null; if (@as(u4, @truncate(addr >> 24)) == 0xD) return null;
} }
} }
@ -257,7 +257,7 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
// the most recently fetched instruction by the pipeline // the most recently fetched instruction by the pipeline
if (!self.cpu.cpsr.t.read()) break :blk self.cpu.pipe.stage[1].?; if (!self.cpu.cpsr.t.read()) break :blk self.cpu.pipe.stage[1].?;
const page = @truncate(u8, r15 >> 24); const page: u8 = @truncate(r15 >> 24);
// PC + 2 = stage[0] // PC + 2 = stage[0]
// PC + 4 = stage[1] // PC + 4 = stage[1]
@ -266,7 +266,7 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
switch (page) { switch (page) {
// EWRAM, PALRAM, VRAM, and Game ROM (16-bit) // EWRAM, PALRAM, VRAM, and Game ROM (16-bit)
0x02, 0x05, 0x06, 0x08...0x0D => { 0x02, 0x05, 0x06, 0x08...0x0D => {
const halfword: u32 = @truncate(u16, self.cpu.pipe.stage[1].?); const halfword: u32 = @as(u16, @truncate(self.cpu.pipe.stage[1].?));
break :blk halfword << 16 | halfword; break :blk halfword << 16 | halfword;
}, },
@ -277,8 +277,8 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
const aligned = address & 3 == 0b00; const aligned = address & 3 == 0b00;
// TODO: What to do on PC + 6? // TODO: What to do on PC + 6?
const high: u32 = if (aligned) self.dbgRead(u16, r15 + 4) else @truncate(u16, self.cpu.pipe.stage[1].?); const high: u32 = if (aligned) self.dbgRead(u16, r15 + 4) else @as(u16, @truncate(self.cpu.pipe.stage[1].?));
const low: u32 = @truncate(u16, self.cpu.pipe.stage[@boolToInt(aligned)].?); const low: u32 = @as(u16, @truncate(self.cpu.pipe.stage[@intFromBool(aligned)].?));
break :blk high << 16 | low; break :blk high << 16 | low;
}, },
@ -289,8 +289,8 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
// Unaligned: (PC + 4) | (PC + 2) // Unaligned: (PC + 4) | (PC + 2)
const aligned = address & 3 == 0b00; const aligned = address & 3 == 0b00;
const high: u32 = @truncate(u16, self.cpu.pipe.stage[1 - @boolToInt(aligned)].?); const high: u32 = @as(u16, @truncate(self.cpu.pipe.stage[1 - @intFromBool(aligned)].?));
const low: u32 = @truncate(u16, self.cpu.pipe.stage[@boolToInt(aligned)].?); const low: u32 = @as(u16, @truncate(self.cpu.pipe.stage[@intFromBool(aligned)].?));
break :blk high << 16 | low; break :blk high << 16 | low;
}, },
@ -301,7 +301,7 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
} }
}; };
return @truncate(T, word); return @truncate(word);
} }
pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T { pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
@ -310,15 +310,14 @@ pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
const offset = unaligned_address & (page_size - 1); const offset = unaligned_address & (page_size - 1);
// whether or not we do this in slowmem or fastmem, we should advance the scheduler // whether or not we do this in slowmem or fastmem, we should advance the scheduler
self.sched.tick += timings[@boolToInt(T == u32)][@truncate(u4, unaligned_address >> 24)]; self.sched.tick += timings[@intFromBool(T == u32)][@as(u4, @truncate(unaligned_address >> 24))];
// We're doing some serious out-of-bounds open-bus reads // We're doing some serious out-of-bounds open-bus reads
if (page >= table_len) return self.openBus(T, unaligned_address); if (page >= table_len) return self.openBus(T, unaligned_address);
if (self.read_table[page]) |some_ptr| { if (self.read_table[page]) |some_ptr| {
// We have a pointer to a page, cast the pointer to it's underlying type // We have a pointer to a page, cast the pointer to it's underlying type
const Ptr = [*]const T; const ptr: [*]const T = @ptrCast(@alignCast(some_ptr));
const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
// Note: We don't check array length, since we force align the // Note: We don't check array length, since we force align the
// lower bits of the address as the GBA would // lower bits of the address as the GBA would
@ -338,8 +337,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
if (self.read_table[page]) |some_ptr| { if (self.read_table[page]) |some_ptr| {
// We have a pointer to a page, cast the pointer to it's underlying type // We have a pointer to a page, cast the pointer to it's underlying type
const Ptr = [*]const T; const ptr: [*]const T = @ptrCast(@alignCast(some_ptr));
const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
// Note: We don't check array length, since we force align the // Note: We don't check array length, since we force align the
// lower bits of the address as the GBA would // lower bits of the address as the GBA would
@ -352,7 +350,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T { fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
@setCold(true); @setCold(true);
const page = @truncate(u8, unaligned_address >> 24); const page: u8 = @truncate(unaligned_address >> 24);
const address = forceAlign(T, unaligned_address); const address = forceAlign(T, unaligned_address);
return switch (page) { return switch (page) {
@ -380,7 +378,7 @@ fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
} }
fn dbgSlowRead(self: *const Self, comptime T: type, unaligned_address: u32) T { fn dbgSlowRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
const page = @truncate(u8, unaligned_address >> 24); const page: u8 = @truncate(unaligned_address >> 24);
const address = forceAlign(T, unaligned_address); const address = forceAlign(T, unaligned_address);
return switch (page) { return switch (page) {
@ -426,22 +424,21 @@ pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
const offset = unaligned_address & (page_size - 1); const offset = unaligned_address & (page_size - 1);
// whether or not we do this in slowmem or fastmem, we should advance the scheduler // whether or not we do this in slowmem or fastmem, we should advance the scheduler
self.sched.tick += timings[@boolToInt(T == u32)][@truncate(u4, unaligned_address >> 24)]; self.sched.tick += timings[@intFromBool(T == u32)][@as(u4, @truncate(unaligned_address >> 24))];
// We're doing some serious out-of-bounds open-bus writes, they do nothing though // We're doing some serious out-of-bounds open-bus writes, they do nothing though
if (page >= table_len) return; if (page >= table_len) return;
if (self.write_tables[@boolToInt(T == u8)][page]) |some_ptr| { if (self.write_tables[@intFromBool(T == u8)][page]) |some_ptr| {
// We have a pointer to a page, cast the pointer to it's underlying type // We have a pointer to a page, cast the pointer to it's underlying type
const Ptr = [*]T; const ptr: [*]T = @ptrCast(@alignCast(some_ptr));
const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
// Note: We don't check array length, since we force align the // Note: We don't check array length, since we force align the
// lower bits of the address as the GBA would // lower bits of the address as the GBA would
ptr[forceAlign(T, offset) / @sizeOf(T)] = value; ptr[forceAlign(T, offset) / @sizeOf(T)] = value;
} else { } else {
// we can return early if this is an 8-bit OAM write // we can return early if this is an 8-bit OAM write
if (T == u8 and @truncate(u8, unaligned_address >> 24) == 0x07) return; if (T == u8 and @as(u8, @truncate(unaligned_address >> 24)) == 0x07) return;
self.slowWrite(T, unaligned_address, value); self.slowWrite(T, unaligned_address, value);
} }
@ -456,17 +453,16 @@ pub fn dbgWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T)
// We're doing some serious out-of-bounds open-bus writes, they do nothing though // We're doing some serious out-of-bounds open-bus writes, they do nothing though
if (page >= table_len) return; if (page >= table_len) return;
if (self.write_tables[@boolToInt(T == u8)][page]) |some_ptr| { if (self.write_tables[@intFromBool(T == u8)][page]) |some_ptr| {
// We have a pointer to a page, cast the pointer to it's underlying type // We have a pointer to a page, cast the pointer to it's underlying type
const Ptr = [*]T; const ptr: [*]T = @ptrCast(@alignCast(some_ptr));
const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
// Note: We don't check array length, since we force align the // Note: We don't check array length, since we force align the
// lower bits of the address as the GBA would // lower bits of the address as the GBA would
ptr[forceAlign(T, offset) / @sizeOf(T)] = value; ptr[forceAlign(T, offset) / @sizeOf(T)] = value;
} else { } else {
// we can return early if this is an 8-bit OAM write // we can return early if this is an 8-bit OAM write
if (T == u8 and @truncate(u8, unaligned_address >> 24) == 0x07) return; if (T == u8 and @as(u8, @truncate(unaligned_address >> 24)) == 0x07) return;
self.dbgSlowWrite(T, unaligned_address, value); self.dbgSlowWrite(T, unaligned_address, value);
} }
@ -475,7 +471,7 @@ pub fn dbgWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T)
fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void { fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
@setCold(true); @setCold(true);
const page = @truncate(u8, unaligned_address >> 24); const page: u8 = @truncate(unaligned_address >> 24);
const address = forceAlign(T, unaligned_address); const address = forceAlign(T, unaligned_address);
switch (page) { switch (page) {
@ -492,7 +488,7 @@ fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
// External Memory (Game Pak) // External Memory (Game Pak)
0x08...0x0D => self.pak.write(T, self.dma[3].word_count, address, value), 0x08...0x0D => self.pak.write(T, self.dma[3].word_count, address, value),
0x0E...0x0F => self.pak.backup.write(unaligned_address, @truncate(u8, rotr(T, value, 8 * rotateBy(T, unaligned_address)))), 0x0E...0x0F => self.pak.backup.write(unaligned_address, @truncate(rotr(T, value, 8 * rotateBy(T, unaligned_address)))),
else => {}, else => {},
} }
} }
@ -500,7 +496,7 @@ fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
fn dbgSlowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void { fn dbgSlowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
@setCold(true); @setCold(true);
const page = @truncate(u8, unaligned_address >> 24); const page: u8 = @truncate(unaligned_address >> 24);
const address = forceAlign(T, unaligned_address); const address = forceAlign(T, unaligned_address);
switch (page) { switch (page) {

80
src/core/apu.zig
View File

@ -22,7 +22,7 @@ pub const host_rate = @import("../platform.zig").sample_rate;
pub const host_format = @import("../platform.zig").sample_format; pub const host_format = @import("../platform.zig").sample_format;
pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T { pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
const byte_addr = @truncate(u8, addr); const byte_addr: u8 = @truncate(addr);
return switch (T) { return switch (T) {
u32 => switch (byte_addr) { u32 => switch (byte_addr) {
@ -73,27 +73,27 @@ pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }), else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }),
}, },
u8 => switch (byte_addr) { u8 => switch (byte_addr) {
0x60, 0x61 => @truncate(T, @as(u16, apu.ch1.sound1CntL()) >> getHalf(byte_addr)), 0x60, 0x61 => @truncate(@as(u16, apu.ch1.sound1CntL()) >> getHalf(byte_addr)),
0x62, 0x63 => @truncate(T, apu.ch1.sound1CntH() >> getHalf(byte_addr)), 0x62, 0x63 => @truncate(apu.ch1.sound1CntH() >> getHalf(byte_addr)),
0x64, 0x65 => @truncate(T, apu.ch1.sound1CntX() >> getHalf(byte_addr)), 0x64, 0x65 => @truncate(apu.ch1.sound1CntX() >> getHalf(byte_addr)),
0x66, 0x67 => 0x00, // assuming behaviour is identical to that of 16-bit reads 0x66, 0x67 => 0x00, // assuming behaviour is identical to that of 16-bit reads
0x68, 0x69 => @truncate(T, apu.ch2.sound2CntL() >> getHalf(byte_addr)), 0x68, 0x69 => @truncate(apu.ch2.sound2CntL() >> getHalf(byte_addr)),
0x6A, 0x6B => 0x00, 0x6A, 0x6B => 0x00,
0x6C, 0x6D => @truncate(T, apu.ch2.sound2CntH() >> getHalf(byte_addr)), 0x6C, 0x6D => @truncate(apu.ch2.sound2CntH() >> getHalf(byte_addr)),
0x6E, 0x6F => 0x00, 0x6E, 0x6F => 0x00,
0x70, 0x71 => @truncate(T, @as(u16, apu.ch3.sound3CntL()) >> getHalf(byte_addr)), // SOUND3CNT_L 0x70, 0x71 => @truncate(@as(u16, apu.ch3.sound3CntL()) >> getHalf(byte_addr)), // SOUND3CNT_L
0x72, 0x73 => @truncate(T, apu.ch3.sound3CntH() >> getHalf(byte_addr)), 0x72, 0x73 => @truncate(apu.ch3.sound3CntH() >> getHalf(byte_addr)),
0x74, 0x75 => @truncate(T, apu.ch3.sound3CntX() >> getHalf(byte_addr)), // SOUND3CNT_L 0x74, 0x75 => @truncate(apu.ch3.sound3CntX() >> getHalf(byte_addr)), // SOUND3CNT_L
0x76, 0x77 => 0x00, 0x76, 0x77 => 0x00,
0x78, 0x79 => @truncate(T, apu.ch4.sound4CntL() >> getHalf(byte_addr)), 0x78, 0x79 => @truncate(apu.ch4.sound4CntL() >> getHalf(byte_addr)),
0x7A, 0x7B => 0x00, 0x7A, 0x7B => 0x00,
0x7C, 0x7D => @truncate(T, apu.ch4.sound4CntH() >> getHalf(byte_addr)), 0x7C, 0x7D => @truncate(apu.ch4.sound4CntH() >> getHalf(byte_addr)),
0x7E, 0x7F => 0x00, 0x7E, 0x7F => 0x00,
0x80, 0x81 => @truncate(T, apu.soundCntL() >> getHalf(byte_addr)), // SOUNDCNT_L 0x80, 0x81 => @truncate(apu.soundCntL() >> getHalf(byte_addr)), // SOUNDCNT_L
0x82, 0x83 => @truncate(T, apu.soundCntH() >> getHalf(byte_addr)), // SOUNDCNT_H 0x82, 0x83 => @truncate(apu.soundCntH() >> getHalf(byte_addr)), // SOUNDCNT_H
0x84, 0x85 => @truncate(T, @as(u16, apu.soundCntX()) >> getHalf(byte_addr)), 0x84, 0x85 => @truncate(@as(u16, apu.soundCntX()) >> getHalf(byte_addr)),
0x86, 0x87 => 0x00, 0x86, 0x87 => 0x00,
0x88, 0x89 => @truncate(T, apu.bias.raw >> getHalf(byte_addr)), // SOUNDBIAS 0x88, 0x89 => @truncate(apu.bias.raw >> getHalf(byte_addr)), // SOUNDBIAS
0x8A, 0x8B => 0x00, 0x8A, 0x8B => 0x00,
0x8C...0x8F => null, 0x8C...0x8F => null,
0x90...0x9F => apu.ch3.wave_dev.read(T, apu.ch3.select, addr), 0x90...0x9F => apu.ch3.wave_dev.read(T, apu.ch3.select, addr),
@ -106,7 +106,7 @@ pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
} }
pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void { pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
const byte_addr = @truncate(u8, addr); const byte_addr: u8 = @truncate(addr);
if (byte_addr <= 0x81 and !apu.cnt.apu_enable.read()) return; if (byte_addr <= 0x81 and !apu.cnt.apu_enable.read()) return;
@ -117,20 +117,20 @@ pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
switch (byte_addr) { switch (byte_addr) {
0x60 => apu.ch1.setSound1Cnt(value), 0x60 => apu.ch1.setSound1Cnt(value),
0x64 => apu.ch1.setSound1CntX(&apu.fs, @truncate(u16, value)), 0x64 => apu.ch1.setSound1CntX(&apu.fs, @truncate(value)),
0x68 => apu.ch2.setSound2CntL(@truncate(u16, value)), 0x68 => apu.ch2.setSound2CntL(@truncate(value)),
0x6C => apu.ch2.setSound2CntH(&apu.fs, @truncate(u16, value)), 0x6C => apu.ch2.setSound2CntH(&apu.fs, @truncate(value)),
0x70 => apu.ch3.setSound3Cnt(value), 0x70 => apu.ch3.setSound3Cnt(value),
0x74 => apu.ch3.setSound3CntX(&apu.fs, @truncate(u16, value)), 0x74 => apu.ch3.setSound3CntX(&apu.fs, @truncate(value)),
0x78 => apu.ch4.setSound4CntL(@truncate(u16, value)), 0x78 => apu.ch4.setSound4CntL(@truncate(value)),
0x7C => apu.ch4.setSound4CntH(&apu.fs, @truncate(u16, value)), 0x7C => apu.ch4.setSound4CntH(&apu.fs, @truncate(value)),
0x80 => apu.setSoundCnt(value), 0x80 => apu.setSoundCnt(value),
0x84 => apu.setSoundCntX(value >> 7 & 1 == 1), 0x84 => apu.setSoundCntX(value >> 7 & 1 == 1),
0x88 => apu.bias.raw = @truncate(u16, value), 0x88 => apu.bias.raw = @truncate(value),
0x8C => {}, 0x8C => {},
0x90, 0x94, 0x98, 0x9C => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value), 0x90, 0x94, 0x98, 0x9C => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
@ -143,7 +143,7 @@ pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
if (byte_addr <= 0x81 and !apu.cnt.apu_enable.read()) return; if (byte_addr <= 0x81 and !apu.cnt.apu_enable.read()) return;
switch (byte_addr) { switch (byte_addr) {
0x60 => apu.ch1.setSound1CntL(@truncate(u8, value)), // SOUND1CNT_L 0x60 => apu.ch1.setSound1CntL(@truncate(value)), // SOUND1CNT_L
0x62 => apu.ch1.setSound1CntH(value), 0x62 => apu.ch1.setSound1CntH(value),
0x64 => apu.ch1.setSound1CntX(&apu.fs, value), 0x64 => apu.ch1.setSound1CntX(&apu.fs, value),
0x66 => {}, 0x66 => {},
@ -153,7 +153,7 @@ pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
0x6C => apu.ch2.setSound2CntH(&apu.fs, value), 0x6C => apu.ch2.setSound2CntH(&apu.fs, value),
0x6E => {}, 0x6E => {},
0x70 => apu.ch3.setSound3CntL(@truncate(u8, value)), 0x70 => apu.ch3.setSound3CntL(@truncate(value)),
0x72 => apu.ch3.setSound3CntH(value), 0x72 => apu.ch3.setSound3CntH(value),
0x74 => apu.ch3.setSound3CntX(&apu.fs, value), 0x74 => apu.ch3.setSound3CntX(&apu.fs, value),
0x76 => {}, 0x76 => {},
@ -330,8 +330,8 @@ pub const Apu = struct {
/// SOUNDCNT /// SOUNDCNT
fn setSoundCnt(self: *Self, value: u32) void { fn setSoundCnt(self: *Self, value: u32) void {
if (self.cnt.apu_enable.read()) self.setSoundCntL(@truncate(u16, value)); if (self.cnt.apu_enable.read()) self.setSoundCntL(@truncate(value));
self.setSoundCntH(@truncate(u16, value >> 16)); self.setSoundCntH(@truncate(value >> 16));
} }
/// SOUNDCNT_L /// SOUNDCNT_L
@ -384,12 +384,12 @@ pub const Apu = struct {
/// NR52 /// NR52
pub fn soundCntX(self: *const Self) u8 { pub fn soundCntX(self: *const Self) u8 {
const apu_enable: u8 = @boolToInt(self.cnt.apu_enable.read()); const apu_enable: u8 = @intFromBool(self.cnt.apu_enable.read());
const ch1_enable: u8 = @boolToInt(self.ch1.enabled); const ch1_enable: u8 = @intFromBool(self.ch1.enabled);
const ch2_enable: u8 = @boolToInt(self.ch2.enabled); const ch2_enable: u8 = @intFromBool(self.ch2.enabled);
const ch3_enable: u8 = @boolToInt(self.ch3.enabled); const ch3_enable: u8 = @intFromBool(self.ch3.enabled);
const ch4_enable: u8 = @boolToInt(self.ch4.enabled); const ch4_enable: u8 = @intFromBool(self.ch4.enabled);
return apu_enable << 7 | ch4_enable << 3 | ch3_enable << 2 | ch2_enable << 1 | ch1_enable; return apu_enable << 7 | ch4_enable << 3 | ch3_enable << 2 | ch2_enable << 1 | ch1_enable;
} }
@ -450,8 +450,8 @@ pub const Apu = struct {
left += bias; left += bias;
right += bias; right += bias;
const clamped_left = std.math.clamp(@bitCast(u16, left), std.math.minInt(u11), std.math.maxInt(u11)); const clamped_left = std.math.clamp(@as(u16, @bitCast(left)), 0, std.math.maxInt(u11));
const clamped_right = std.math.clamp(@bitCast(u16, right), std.math.minInt(u11), std.math.maxInt(u11)); const clamped_right = std.math.clamp(@as(u16, @bitCast(right)), 0, std.math.maxInt(u11));
// Extend to 16-bit signed audio samples // Extend to 16-bit signed audio samples
const ext_left = (clamped_left << 5) | (clamped_left >> 6); const ext_left = (clamped_left << 5) | (clamped_left >> 6);
@ -473,7 +473,7 @@ pub const Apu = struct {
defer SDL.SDL_FreeAudioStream(old_stream); defer SDL.SDL_FreeAudioStream(old_stream);
self.sampling_cycle = self.bias.sampling_cycle.read(); self.sampling_cycle = self.bias.sampling_cycle.read();
self.stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, @intCast(c_int, sample_rate), host_format, 2, host_rate).?; self.stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, @intCast(sample_rate), host_format, 2, host_rate).?;
} }
fn interval(self: *const Self) u64 { fn interval(self: *const Self) u64 {
@ -521,16 +521,16 @@ pub const Apu = struct {
pub fn onDmaAudioSampleRequest(self: *Self, cpu: *Arm7tdmi, tim_id: u3) void { pub fn onDmaAudioSampleRequest(self: *Self, cpu: *Arm7tdmi, tim_id: u3) void {
if (!self.cnt.apu_enable.read()) return; if (!self.cnt.apu_enable.read()) return;
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
if (@boolToInt(self.dma_cnt.chA_timer.read()) == tim_id) { if (@intFromBool(self.dma_cnt.chA_timer.read()) == tim_id) {
if (!self.chA.enabled) return; if (!self.chA.enabled) return;
self.chA.updateSample(); self.chA.updateSample();
if (self.chA.len() <= 15) bus_ptr.dma[1].requestAudio(0x0400_00A0); if (self.chA.len() <= 15) bus_ptr.dma[1].requestAudio(0x0400_00A0);
} }
if (@boolToInt(self.dma_cnt.chB_timer.read()) == tim_id) { if (@intFromBool(self.dma_cnt.chB_timer.read()) == tim_id) {
if (!self.chB.enabled) return; if (!self.chB.enabled) return;
self.chB.updateSample(); self.chB.updateSample();
@ -578,11 +578,11 @@ pub fn DmaSound(comptime kind: DmaSoundKind) type {
} }
pub fn updateSample(self: *Self) void { pub fn updateSample(self: *Self) void {
if (self.fifo.readItem()) |sample| self.sample = @bitCast(i8, sample); if (self.fifo.readItem()) |sample| self.sample = @bitCast(sample);
} }
pub fn amplitude(self: *const Self) i16 { pub fn amplitude(self: *const Self) i16 {
return @as(i16, self.sample); return self.sample;
} }
}; };
} }

12
src/core/apu/Noise.zig
View File

@ -76,14 +76,14 @@ pub fn sound4CntL(self: *const Self) u16 {
/// NR41, NR42 /// NR41, NR42
pub fn setSound4CntL(self: *Self, value: u16) void { pub fn setSound4CntL(self: *Self, value: u16) void {
self.setNr41(@truncate(u8, value)); self.setNr41(@truncate(value));
self.setNr42(@truncate(u8, value >> 8)); self.setNr42(@truncate(value >> 8));
} }
/// NR41 /// NR41
pub fn setNr41(self: *Self, len: u8) void { pub fn setNr41(self: *Self, len: u8) void {
self.len = @truncate(u6, len); self.len = @truncate(len);
self.len_dev.timer = @as(u7, 64) - @truncate(u6, len); self.len_dev.timer = @as(u7, 64) - self.len;
} }
/// NR42 /// NR42
@ -99,8 +99,8 @@ pub fn sound4CntH(self: *const Self) u16 {
/// NR43, NR44 /// NR43, NR44
pub fn setSound4CntH(self: *Self, fs: *const FrameSequencer, value: u16) void { pub fn setSound4CntH(self: *Self, fs: *const FrameSequencer, value: u16) void {
self.poly.raw = @truncate(u8, value); self.poly.raw = @truncate(value);
self.setNr44(fs, @truncate(u8, value >> 8)); self.setNr44(fs, @truncate(value >> 8));
} }
/// NR44 /// NR44

10
src/core/apu/Tone.zig
View File

@ -77,14 +77,14 @@ pub fn sound2CntL(self: *const Self) u16 {
/// NR21, NR22 /// NR21, NR22
pub fn setSound2CntL(self: *Self, value: u16) void { pub fn setSound2CntL(self: *Self, value: u16) void {
self.setNr21(@truncate(u8, value)); self.setNr21(@truncate(value));
self.setNr22(@truncate(u8, value >> 8)); self.setNr22(@truncate(value >> 8));
} }
/// NR21 /// NR21
pub fn setNr21(self: *Self, value: u8) void { pub fn setNr21(self: *Self, value: u8) void {
self.duty.raw = value; self.duty.raw = value;
self.len_dev.timer = @as(u7, 64) - @truncate(u6, value); self.len_dev.timer = @as(u7, 64) - @as(u6, @truncate(value));
} }
/// NR22 /// NR22
@ -100,8 +100,8 @@ pub fn sound2CntH(self: *const Self) u16 {
/// NR23, NR24 /// NR23, NR24
pub fn setSound2CntH(self: *Self, fs: *const FrameSequencer, value: u16) void { pub fn setSound2CntH(self: *Self, fs: *const FrameSequencer, value: u16) void {
self.setNr23(@truncate(u8, value)); self.setNr23(@truncate(value));
self.setNr24(fs, @truncate(u8, value >> 8)); self.setNr24(fs, @truncate(value >> 8));
} }
/// NR23 /// NR23

14
src/core/apu/ToneSweep.zig
View File

@ -81,8 +81,8 @@ pub fn onToneSweepEvent(self: *Self, late: u64) void {
/// NR10, NR11, NR12 /// NR10, NR11, NR12
pub fn setSound1Cnt(self: *Self, value: u32) void { pub fn setSound1Cnt(self: *Self, value: u32) void {
self.setSound1CntL(@truncate(u8, value)); self.setSound1CntL(@truncate(value));
self.setSound1CntH(@truncate(u16, value >> 16)); self.setSound1CntH(@truncate(value >> 16));
} }
/// NR10 /// NR10
@ -111,14 +111,14 @@ pub fn sound1CntH(self: *const Self) u16 {
/// NR11, NR12 /// NR11, NR12
pub fn setSound1CntH(self: *Self, value: u16) void { pub fn setSound1CntH(self: *Self, value: u16) void {
self.setNr11(@truncate(u8, value)); self.setNr11(@truncate(value));
self.setNr12(@truncate(u8, value >> 8)); self.setNr12(@truncate(value >> 8));
} }
/// NR11 /// NR11
pub fn setNr11(self: *Self, value: u8) void { pub fn setNr11(self: *Self, value: u8) void {
self.duty.raw = value; self.duty.raw = value;
self.len_dev.timer = @as(u7, 64) - @truncate(u6, value); self.len_dev.timer = @as(u7, 64) - @as(u6, @truncate(value));
} }
/// NR12 /// NR12
@ -134,8 +134,8 @@ pub fn sound1CntX(self: *const Self) u16 {
/// NR13, NR14 /// NR13, NR14
pub fn setSound1CntX(self: *Self, fs: *const FrameSequencer, value: u16) void { pub fn setSound1CntX(self: *Self, fs: *const FrameSequencer, value: u16) void {
self.setNr13(@truncate(u8, value)); self.setNr13(@truncate(value));
self.setNr14(fs, @truncate(u8, value >> 8)); self.setNr14(fs, @truncate(value >> 8));
} }
/// NR13 /// NR13

12
src/core/apu/Wave.zig
View File

@ -64,8 +64,8 @@ pub fn tick(self: *Self, comptime kind: Tick) void {
/// NR30, NR31, NR32 /// NR30, NR31, NR32
pub fn setSound3Cnt(self: *Self, value: u32) void { pub fn setSound3Cnt(self: *Self, value: u32) void {
self.setSound3CntL(@truncate(u8, value)); self.setSound3CntL(@truncate(value));
self.setSound3CntH(@truncate(u16, value >> 16)); self.setSound3CntH(@truncate(value >> 16));
} }
/// NR30 /// NR30
@ -86,8 +86,8 @@ pub fn sound3CntH(self: *const Self) u16 {
/// NR31, NR32 /// NR31, NR32
pub fn setSound3CntH(self: *Self, value: u16) void { pub fn setSound3CntH(self: *Self, value: u16) void {
self.setNr31(@truncate(u8, value)); self.setNr31(@truncate(value));
self.vol.raw = (@truncate(u8, value >> 8)); self.vol.raw = @truncate(value >> 8);
} }
/// NR31 /// NR31
@ -98,8 +98,8 @@ pub fn setNr31(self: *Self, len: u8) void {
/// NR33, NR34 /// NR33, NR34
pub fn setSound3CntX(self: *Self, fs: *const FrameSequencer, value: u16) void { pub fn setSound3CntX(self: *Self, fs: *const FrameSequencer, value: u16) void {
self.setNr33(@truncate(u8, value)); self.setNr33(@truncate(value));
self.setNr34(fs, @truncate(u8, value >> 8)); self.setNr34(fs, @truncate(value >> 8));
} }
/// NR33, NR34 /// NR33, NR34

4
src/core/apu/device/Sweep.zig
View File

@ -28,8 +28,8 @@ pub fn tick(self: *Self, ch1: *ToneSweep) void {
const new_freq = self.calculate(ch1.sweep, &ch1.enabled); const new_freq = self.calculate(ch1.sweep, &ch1.enabled);
if (new_freq <= 0x7FF and ch1.sweep.shift.read() != 0) { if (new_freq <= 0x7FF and ch1.sweep.shift.read() != 0) {
ch1.freq.frequency.write(@truncate(u11, new_freq)); ch1.freq.frequency.write(@as(u11, @truncate(new_freq)));
self.shadow = @truncate(u11, new_freq); self.shadow = @truncate(new_freq);
_ = self.calculate(ch1.sweep, &ch1.enabled); _ = self.calculate(ch1.sweep, &ch1.enabled);
} }

2
src/core/apu/signal/Wave.zig
View File

@ -70,7 +70,7 @@ pub fn sample(self: *const Self, nr30: io.WaveSelect) u4 {
const base = if (nr30.bank.read()) @as(u32, 0x10) else 0; const base = if (nr30.bank.read()) @as(u32, 0x10) else 0;
const value = self.buf[base + self.offset / 2]; const value = self.buf[base + self.offset / 2];
return if (self.offset & 1 == 0) @truncate(u4, value >> 4) else @truncate(u4, value); return if (self.offset & 1 == 0) @truncate(value >> 4) else @truncate(value);
} }
/// TODO: Write comment /// TODO: Write comment

4
src/core/bus/Bios.zig
View File

@ -27,7 +27,7 @@ pub fn read(self: *Self, comptime T: type, r15: u32, address: u32) T {
log.warn("Open Bus! Read from 0x{X:0>8}, but PC was 0x{X:0>8}", .{ address, r15 }); log.warn("Open Bus! Read from 0x{X:0>8}, but PC was 0x{X:0>8}", .{ address, r15 });
const value = self._read(u32, self.addr_latch); const value = self._read(u32, self.addr_latch);
return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address))); return @truncate(rotr(u32, value, 8 * rotateBy(T, address)));
} }
fn rotateBy(comptime T: type, address: u32) u32 { fn rotateBy(comptime T: type, address: u32) u32 {
@ -43,7 +43,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, r15: u32, address: u32) T {
if (r15 < Self.size) return self._read(T, forceAlign(T, address)); if (r15 < Self.size) return self._read(T, forceAlign(T, address));
const value = self._read(u32, self.addr_latch); const value = self._read(u32, self.addr_latch);
return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address))); return @truncate(rotr(u32, value, 8 * rotateBy(T, address)));
} }
/// Read without the GBA safety checks /// Read without the GBA safety checks

24
src/core/bus/GamePak.zig
View File

@ -30,7 +30,7 @@ pub fn read(self: *Self, comptime T: type, address: u32) T {
// Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if // Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if
// * Backup type is EEPROM // * Backup type is EEPROM
// * Small ROM (less than 16MB) // * Small ROM (less than 16MB)
if (@truncate(u8, address >> 24) == 0x0D) if (@as(u8, @truncate(address >> 24)) == 0x0D)
return self.backup.eeprom.read(); return self.backup.eeprom.read();
} }
} }
@ -77,7 +77,7 @@ inline fn get(self: *const Self, i: u32) u8 {
if (i < self.buf.len) return self.buf[i]; if (i < self.buf.len) return self.buf[i];
const lhs = i >> 1 & 0xFFFF; const lhs = i >> 1 & 0xFFFF;
return @truncate(u8, lhs >> 8 * @truncate(u5, i & 1)); return @truncate(lhs >> 8 * @as(u5, @truncate(i & 1)));
} }
pub fn dbgRead(self: *const Self, comptime T: type, address: u32) T { pub fn dbgRead(self: *const Self, comptime T: type, address: u32) T {
@ -94,7 +94,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, address: u32) T {
// Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if // Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if
// * Backup type is EEPROM // * Backup type is EEPROM
// * Small ROM (less than 16MB) // * Small ROM (less than 16MB)
if (@truncate(u8, address >> 24) == 0x0D) if (@as(u8, @truncate(address >> 24)) == 0x0D)
return self.backup.eeprom.dbgRead(); return self.backup.eeprom.dbgRead();
} }
} }
@ -139,7 +139,7 @@ pub fn write(self: *Self, comptime T: type, word_count: u16, address: u32, value
const addr = address & 0x1FF_FFFF; const addr = address & 0x1FF_FFFF;
if (self.backup.kind == .Eeprom) { if (self.backup.kind == .Eeprom) {
const bit = @truncate(u1, value); const bit: u1 = @truncate(value);
if (self.buf.len > 0x100_0000) { // Large if (self.buf.len > 0x100_0000) { // Large
// Addresses 0x1FF_FF00 to 0x1FF_FFFF are reserved from EEPROM accesses if // Addresses 0x1FF_FF00 to 0x1FF_FFFF are reserved from EEPROM accesses if
@ -151,7 +151,7 @@ pub fn write(self: *Self, comptime T: type, word_count: u16, address: u32, value
// Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if // Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if
// * Backup type is EEPROM // * Backup type is EEPROM
// * Small ROM (less than 16MB) // * Small ROM (less than 16MB)
if (@truncate(u8, address >> 24) == 0x0D) if (@as(u8, @truncate(address >> 24)) == 0x0D)
return self.backup.eeprom.write(word_count, &self.backup.buf, bit); return self.backup.eeprom.write(word_count, &self.backup.buf, bit);
} }
} }
@ -159,19 +159,19 @@ pub fn write(self: *Self, comptime T: type, word_count: u16, address: u32, value
switch (T) { switch (T) {
u32 => switch (address) { u32 => switch (address) {
0x0800_00C4 => { 0x0800_00C4 => {
self.gpio.write(.Data, @truncate(u4, value)); self.gpio.write(.Data, @as(u4, @truncate(value)));
self.gpio.write(.Direction, @truncate(u4, value >> 16)); self.gpio.write(.Direction, @as(u4, @truncate(value >> 16)));
}, },
0x0800_00C6 => { 0x0800_00C6 => {
self.gpio.write(.Direction, @truncate(u4, value)); self.gpio.write(.Direction, @as(u4, @truncate(value)));
self.gpio.write(.Control, @truncate(u1, value >> 16)); self.gpio.write(.Control, @as(u1, @truncate(value >> 16)));
}, },
else => log.err("Wrote {} 0x{X:0>8} to 0x{X:0>8}, Unhandled", .{ T, value, address }), else => log.err("Wrote {} 0x{X:0>8} to 0x{X:0>8}, Unhandled", .{ T, value, address }),
}, },
u16 => switch (address) { u16 => switch (address) {
0x0800_00C4 => self.gpio.write(.Data, @truncate(u4, value)), 0x0800_00C4 => self.gpio.write(.Data, @as(u4, @truncate(value))),
0x0800_00C6 => self.gpio.write(.Direction, @truncate(u4, value)), 0x0800_00C6 => self.gpio.write(.Direction, @as(u4, @truncate(value))),
0x0800_00C8 => self.gpio.write(.Control, @truncate(u1, value)), 0x0800_00C8 => self.gpio.write(.Control, @as(u1, @truncate(value))),
else => log.err("Wrote {} 0x{X:0>4} to 0x{X:0>8}, Unhandled", .{ T, value, address }), else => log.err("Wrote {} 0x{X:0>4} to 0x{X:0>8}, Unhandled", .{ T, value, address }),
}, },
u8 => log.debug("Wrote {} 0x{X:0>2} to 0x{X:0>8}, Ignored.", .{ T, value, address }), u8 => log.debug("Wrote {} 0x{X:0>2} to 0x{X:0>8}, Ignored.", .{ T, value, address }),

2
src/core/bus/backup.zig
View File

@ -77,7 +77,7 @@ pub const Backup = struct {
switch (addr) { switch (addr) {
0x0000 => if (self.kind == .Flash1M and self.flash.set_bank) { 0x0000 => if (self.kind == .Flash1M and self.flash.set_bank) {
self.flash.bank = @truncate(u1, byte); self.flash.bank = @truncate(byte);
}, },
0x5555 => { 0x5555 => {
if (self.flash.state == .Command) { if (self.flash.state == .Command) {

30
src/core/bus/backup/eeprom.zig
View File

@ -108,7 +108,7 @@ pub const Eeprom = struct {
switch (self.state) { switch (self.state) {
.Ready => { .Ready => {
if (self.writer.len() == 2) { if (self.writer.len() == 2) {
const req = @intCast(u2, self.writer.finish()); const req: u2 = @intCast(self.writer.finish());
switch (req) { switch (req) {
0b11 => self.state = .Read, 0b11 => self.state = .Read,
0b10 => self.state = .Write, 0b10 => self.state = .Write,
@ -120,7 +120,7 @@ pub const Eeprom = struct {
switch (self.kind) { switch (self.kind) {
.Large => { .Large => {
if (self.writer.len() == 14) { if (self.writer.len() == 14) {
const addr = @intCast(u10, self.writer.finish()); const addr: u10 = @intCast(self.writer.finish());
const value = std.mem.readIntSliceLittle(u64, buf[@as(u13, addr) * 8 ..][0..8]); const value = std.mem.readIntSliceLittle(u64, buf[@as(u13, addr) * 8 ..][0..8]);
self.reader.configure(value); self.reader.configure(value);
@ -130,7 +130,7 @@ pub const Eeprom = struct {
.Small => { .Small => {
if (self.writer.len() == 6) { if (self.writer.len() == 6) {
// FIXME: Duplicated code from above // FIXME: Duplicated code from above
const addr = @intCast(u6, self.writer.finish()); const addr: u6 = @intCast(self.writer.finish());
const value = std.mem.readIntSliceLittle(u64, buf[@as(u13, addr) * 8 ..][0..8]); const value = std.mem.readIntSliceLittle(u64, buf[@as(u13, addr) * 8 ..][0..8]);
self.reader.configure(value); self.reader.configure(value);
@ -144,13 +144,13 @@ pub const Eeprom = struct {
switch (self.kind) { switch (self.kind) {
.Large => { .Large => {
if (self.writer.len() == 14) { if (self.writer.len() == 14) {
self.addr = @intCast(u10, self.writer.finish()); self.addr = @as(u10, @intCast(self.writer.finish()));
self.state = .WriteTransfer; self.state = .WriteTransfer;
} }
}, },
.Small => { .Small => {
if (self.writer.len() == 6) { if (self.writer.len() == 6) {
self.addr = @intCast(u6, self.writer.finish()); self.addr = @as(u6, @intCast(self.writer.finish()));
self.state = .WriteTransfer; self.state = .WriteTransfer;
} }
}, },
@ -186,11 +186,9 @@ const Reader = struct {
fn read(self: *Self) u1 { fn read(self: *Self) u1 {
if (!self.enabled) return 1; if (!self.enabled) return 1;
const bit = if (self.i < 4) blk: { const bit: u1 = if (self.i < 4) 0 else blk: {
break :blk 0; const idx: u6 = @intCast(63 - (self.i - 4));
} else blk: { break :blk @truncate(self.data >> idx);
const idx = @intCast(u6, 63 - (self.i - 4));
break :blk @truncate(u1, self.data >> idx);
}; };
self.i = (self.i + 1) % (64 + 4); self.i = (self.i + 1) % (64 + 4);
@ -202,11 +200,11 @@ const Reader = struct {
fn dbgRead(self: *const Self) u1 { fn dbgRead(self: *const Self) u1 {
if (!self.enabled) return 1; if (!self.enabled) return 1;
const bit = if (self.i < 4) blk: { const bit: u1 = if (self.i < 4) blk: {
break :blk 0; break :blk 0;
} else blk: { } else blk: {
const idx = @intCast(u6, 63 - (self.i - 4)); const idx: u6 = @intCast(63 - (self.i - 4));
break :blk @truncate(u1, self.data >> idx); break :blk @truncate(self.data >> idx);
}; };
return bit; return bit;
@ -230,7 +228,7 @@ const Writer = struct {
} }
fn requestWrite(self: *Self, bit: u1) void { fn requestWrite(self: *Self, bit: u1) void {
const idx = @intCast(u1, 1 - self.i); const idx: u1 = @intCast(1 - self.i);
self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx); self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
self.i += 1; self.i += 1;
} }
@ -244,13 +242,13 @@ const Writer = struct {
.Unknown => unreachable, .Unknown => unreachable,
}; };
const idx = @intCast(u4, size - self.i); const idx: u4 = @intCast(size - self.i);
self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx); self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
self.i += 1; self.i += 1;
} }
fn dataWrite(self: *Self, bit: u1) void { fn dataWrite(self: *Self, bit: u1) void {
const idx = @intCast(u6, 63 - self.i); const idx: u6 = @intCast(63 - self.i);
self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx); self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
self.i += 1; self.i += 1;
} }

30
src/core/bus/dma.zig
View File

@ -20,7 +20,7 @@ pub fn create() DmaTuple {
} }
pub fn read(comptime T: type, dma: *const DmaTuple, addr: u32) ?T { pub fn read(comptime T: type, dma: *const DmaTuple, addr: u32) ?T {
const byte_addr = @truncate(u8, addr); const byte_addr: u8 = @truncate(addr);
return switch (T) { return switch (T) {
u32 => switch (byte_addr) { u32 => switch (byte_addr) {
@ -55,19 +55,19 @@ pub fn read(comptime T: type, dma: *const DmaTuple, addr: u32) ?T {
u8 => switch (byte_addr) { u8 => switch (byte_addr) {
0xB0...0xB7 => null, // DMA0SAD, DMA0DAD 0xB0...0xB7 => null, // DMA0SAD, DMA0DAD
0xB8, 0xB9 => 0x00, // DMA0CNT_L 0xB8, 0xB9 => 0x00, // DMA0CNT_L
0xBA, 0xBB => @truncate(T, dma.*[0].dmacntH() >> getHalf(byte_addr)), 0xBA, 0xBB => @truncate(dma.*[0].dmacntH() >> getHalf(byte_addr)),
0xBC...0xC3 => null, // DMA1SAD, DMA1DAD 0xBC...0xC3 => null, // DMA1SAD, DMA1DAD
0xC4, 0xC5 => 0x00, // DMA1CNT_L 0xC4, 0xC5 => 0x00, // DMA1CNT_L
0xC6, 0xC7 => @truncate(T, dma.*[1].dmacntH() >> getHalf(byte_addr)), 0xC6, 0xC7 => @truncate(dma.*[1].dmacntH() >> getHalf(byte_addr)),
0xC8...0xCF => null, // DMA2SAD, DMA2DAD 0xC8...0xCF => null, // DMA2SAD, DMA2DAD
0xD0, 0xD1 => 0x00, // DMA2CNT_L 0xD0, 0xD1 => 0x00, // DMA2CNT_L
0xD2, 0xD3 => @truncate(T, dma.*[2].dmacntH() >> getHalf(byte_addr)), 0xD2, 0xD3 => @truncate(dma.*[2].dmacntH() >> getHalf(byte_addr)),
0xD4...0xDB => null, // DMA3SAD, DMA3DAD 0xD4...0xDB => null, // DMA3SAD, DMA3DAD
0xDC, 0xDD => 0x00, // DMA3CNT_L 0xDC, 0xDD => 0x00, // DMA3CNT_L
0xDE, 0xDF => @truncate(T, dma.*[3].dmacntH() >> getHalf(byte_addr)), 0xDE, 0xDF => @truncate(dma.*[3].dmacntH() >> getHalf(byte_addr)),
else => util.io.read.err(T, log, "unexpected {} read from 0x{X:0>8}", .{ T, addr }), else => util.io.read.err(T, log, "unexpected {} read from 0x{X:0>8}", .{ T, addr }),
}, },
else => @compileError("DMA: Unsupported read width"), else => @compileError("DMA: Unsupported read width"),
@ -75,7 +75,7 @@ pub fn read(comptime T: type, dma: *const DmaTuple, addr: u32) ?T {
} }
pub fn write(comptime T: type, dma: *DmaTuple, addr: u32, value: T) void { pub fn write(comptime T: type, dma: *DmaTuple, addr: u32, value: T) void {
const byte_addr = @truncate(u8, addr); const byte_addr: u8 = @truncate(addr);
switch (T) { switch (T) {
u32 => switch (byte_addr) { u32 => switch (byte_addr) {
@ -209,7 +209,7 @@ fn DmaController(comptime id: u2) type {
} }
pub fn setDmacntL(self: *Self, halfword: u16) void { pub fn setDmacntL(self: *Self, halfword: u16) void {
self.word_count = @truncate(@TypeOf(self.word_count), halfword); self.word_count = @truncate(halfword);
} }
pub fn dmacntH(self: *const Self) u16 { pub fn dmacntH(self: *const Self) u16 {
@ -233,16 +233,16 @@ fn DmaController(comptime id: u2) type {
} }
pub fn setDmacnt(self: *Self, word: u32) void { pub fn setDmacnt(self: *Self, word: u32) void {
self.setDmacntL(@truncate(u16, word)); self.setDmacntL(@truncate(word));
self.setDmacntH(@truncate(u16, word >> 16)); self.setDmacntH(@truncate(word >> 16));
} }
pub fn step(self: *Self, cpu: *Arm7tdmi) void { pub fn step(self: *Self, cpu: *Arm7tdmi) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
const is_fifo = (id == 1 or id == 2) and self.cnt.start_timing.read() == 0b11; const is_fifo = (id == 1 or id == 2) and self.cnt.start_timing.read() == 0b11;
const sad_adj = @intToEnum(Adjustment, self.cnt.sad_adj.read()); const sad_adj: Adjustment = @enumFromInt(self.cnt.sad_adj.read());
const dad_adj = if (is_fifo) .Fixed else @intToEnum(Adjustment, self.cnt.dad_adj.read()); const dad_adj: Adjustment = if (is_fifo) .Fixed else @enumFromInt(self.cnt.dad_adj.read());
const transfer_type = is_fifo or self.cnt.transfer_type.read(); const transfer_type = is_fifo or self.cnt.transfer_type.read();
const offset: u32 = if (transfer_type) @sizeOf(u32) else @sizeOf(u16); const offset: u32 = if (transfer_type) @sizeOf(u32) else @sizeOf(u16);
@ -260,10 +260,10 @@ fn DmaController(comptime id: u2) type {
self.data_latch = value << 16 | value; self.data_latch = value << 16 | value;
} }
cpu.bus.write(u16, dad_addr, @truncate(u16, rotr(u32, self.data_latch, 8 * (dad_addr & 3)))); cpu.bus.write(u16, dad_addr, @as(u16, @truncate(rotr(u32, self.data_latch, 8 * (dad_addr & 3)))));
} }
switch (@truncate(u8, sad_addr >> 24)) { switch (@as(u8, @truncate(sad_addr >> 24))) {
// according to fleroviux, DMAs with a source address in ROM misbehave // according to fleroviux, DMAs with a source address in ROM misbehave
// the resultant behaviour is that the source address will increment despite what DMAXCNT says // the resultant behaviour is that the source address will increment despite what DMAXCNT says
0x08...0x0D => self.sad_latch +%= offset, // obscure behaviour 0x08...0x0D => self.sad_latch +%= offset, // obscure behaviour
@ -321,7 +321,7 @@ fn DmaController(comptime id: u2) type {
// Reload internal DAD latch if we are in IncrementRelaod // Reload internal DAD latch if we are in IncrementRelaod
if (self.in_progress) { if (self.in_progress) {
self._word_count = if (self.word_count == 0) std.math.maxInt(@TypeOf(self._word_count)) else self.word_count; self._word_count = if (self.word_count == 0) std.math.maxInt(@TypeOf(self._word_count)) else self.word_count;
if (@intToEnum(Adjustment, self.cnt.dad_adj.read()) == .IncrementReload) self.dad_latch = self.dad; if (@as(Adjustment, @enumFromInt(self.cnt.dad_adj.read())) == .IncrementReload) self.dad_latch = self.dad;
} }
} }

50
src/core/bus/gpio.zig
View File

@ -31,8 +31,8 @@ pub const Gpio = struct {
fn step(self: *Device, value: u4) u4 { fn step(self: *Device, value: u4) u4 {
return switch (self.kind) { return switch (self.kind) {
.Rtc => blk: { .Rtc => blk: {
const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), self.ptr.?)); const clock: *Clock = @ptrCast(@alignCast(self.ptr.?));
break :blk clock.step(Clock.Data{ .raw = value }); break :blk clock.step(.{ .raw = value });
}, },
.None => value, .None => value,
}; };
@ -94,7 +94,7 @@ pub const Gpio = struct {
pub fn deinit(self: *Self, allocator: Allocator) void { pub fn deinit(self: *Self, allocator: Allocator) void {
switch (self.device.kind) { switch (self.device.kind) {
.Rtc => allocator.destroy(@ptrCast(*Clock, @alignCast(@alignOf(*Clock), self.device.ptr.?))), .Rtc => allocator.destroy(@as(*Clock, @ptrCast(@alignCast(self.device.ptr.?)))),
.None => {}, .None => {},
} }
@ -146,16 +146,16 @@ pub const Clock = struct {
/// 2. A `count`, which keeps track of which byte is currently being read /// 2. A `count`, which keeps track of which byte is currently being read
/// 3. An index, which keeps track of which bit of the byte determined by `count` is being read /// 3. An index, which keeps track of which bit of the byte determined by `count` is being read
fn read(self: *Reader, clock: *const Clock, register: Register) u1 { fn read(self: *Reader, clock: *const Clock, register: Register) u1 {
const idx = @intCast(u3, self.i); const idx: u3 = @intCast(self.i);
defer self.i += 1; defer self.i += 1;
// FIXME: What do I do about the unused bits? // FIXME: What do I do about the unused bits?
return switch (register) { return switch (register) {
.Control => @truncate(u1, switch (self.count) { .Control => @truncate(switch (self.count) {
0 => clock.cnt.raw >> idx, 0 => clock.cnt.raw >> idx,
else => std.debug.panic("Tried to read from byte #{} of {} (hint: there's only 1 byte)", .{ self.count, register }), else => std.debug.panic("Tried to read from byte #{} of {} (hint: there's only 1 byte)", .{ self.count, register }),
}), }),
.DateTime => @truncate(u1, switch (self.count) { .DateTime => @truncate(switch (self.count) {
// Date // Date
0 => clock.year >> idx, 0 => clock.year >> idx,
1 => @as(u8, clock.month) >> idx, 1 => @as(u8, clock.month) >> idx,
@ -168,7 +168,7 @@ pub const Clock = struct {
6 => @as(u8, clock.second) >> idx, 6 => @as(u8, clock.second) >> idx,
else => std.debug.panic("Tried to read from byte #{} of {} (hint: there's only 7 bytes)", .{ self.count, register }), else => std.debug.panic("Tried to read from byte #{} of {} (hint: there's only 7 bytes)", .{ self.count, register }),
}), }),
.Time => @truncate(u1, switch (self.count) { .Time => @truncate(switch (self.count) {
0 => @as(u8, clock.hour) >> idx, 0 => @as(u8, clock.hour) >> idx,
1 => @as(u8, clock.minute) >> idx, 1 => @as(u8, clock.minute) >> idx,
2 => @as(u8, clock.second) >> idx, 2 => @as(u8, clock.second) >> idx,
@ -207,7 +207,7 @@ pub const Clock = struct {
/// Append a bit to the internal bit buffer (aka an integer) /// Append a bit to the internal bit buffer (aka an integer)
fn push(self: *Writer, value: u1) void { fn push(self: *Writer, value: u1) void {
const idx = @intCast(u3, self.i); const idx: u3 = @intCast(self.i);
self.buf = (self.buf & ~(@as(u8, 1) << idx)) | @as(u8, value) << idx; self.buf = (self.buf & ~(@as(u8, 1) << idx)) | @as(u8, value) << idx;
self.i += 1; self.i += 1;
} }
@ -290,22 +290,22 @@ pub const Clock = struct {
.gpio = gpio, // Can't use Arm7tdmi ptr b/c not initialized yet .gpio = gpio, // Can't use Arm7tdmi ptr b/c not initialized yet
}; };
const sched_ptr = @ptrCast(*Scheduler, @alignCast(@alignOf(Scheduler), cpu.sched.ptr)); const sched_ptr: *Scheduler = @ptrCast(@alignCast(cpu.sched.ptr));
sched_ptr.push(.RealTimeClock, 1 << 24); // Every Second sched_ptr.push(.RealTimeClock, 1 << 24); // Every Second
} }
pub fn onClockUpdate(self: *Self, late: u64) void { pub fn onClockUpdate(self: *Self, late: u64) void {
const sched_ptr = @ptrCast(*Scheduler, @alignCast(@alignOf(Scheduler), self.cpu.sched.ptr)); const sched_ptr: *Scheduler = @ptrCast(@alignCast(self.cpu.sched.ptr));
sched_ptr.push(.RealTimeClock, (1 << 24) -| late); // Reschedule sched_ptr.push(.RealTimeClock, (1 << 24) -| late); // Reschedule
const now = DateTime.now(); const now = DateTime.now();
self.year = bcd(@intCast(u8, now.date.year - 2000)); self.year = bcd(@intCast(now.date.year - 2000));
self.month = @truncate(u5, bcd(now.date.month)); self.month = @truncate(bcd(now.date.month));
self.day = @truncate(u6, bcd(now.date.day)); self.day = @truncate(bcd(now.date.day));
self.weekday = @truncate(u3, bcd((now.date.weekday() + 1) % 7)); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6 self.weekday = @truncate(bcd((now.date.weekday() + 1) % 7)); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6
self.hour = @truncate(u6, bcd(now.time.hour)); self.hour = @truncate(bcd(now.time.hour));
self.minute = @truncate(u7, bcd(now.time.minute)); self.minute = @truncate(bcd(now.time.minute));
self.second = @truncate(u7, bcd(now.time.second)); self.second = @truncate(bcd(now.time.second));
} }
fn step(self: *Self, value: Data) u4 { fn step(self: *Self, value: Data) u4 {
@ -321,14 +321,14 @@ pub const Clock = struct {
} }
} }
break :blk @truncate(u4, value.raw); break :blk @truncate(value.raw);
}, },
.Command => blk: { .Command => blk: {
if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state}); if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state});
// If SCK rises, sample SIO // If SCK rises, sample SIO
if (!cache.sck.read() and value.sck.read()) { if (!cache.sck.read() and value.sck.read()) {
self.writer.push(@boolToInt(value.sio.read())); self.writer.push(@intFromBool(value.sio.read()));
if (self.writer.finished()) { if (self.writer.finished()) {
self.state = self.processCommand(self.writer.buf); self.state = self.processCommand(self.writer.buf);
@ -338,14 +338,14 @@ pub const Clock = struct {
} }
} }
break :blk @truncate(u4, value.raw); break :blk @truncate(value.raw);
}, },
.Write => |register| blk: { .Write => |register| blk: {
if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state}); if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state});
// If SCK rises, sample SIO // If SCK rises, sample SIO
if (!cache.sck.read() and value.sck.read()) { if (!cache.sck.read() and value.sck.read()) {
self.writer.push(@boolToInt(value.sio.read())); self.writer.push(@intFromBool(value.sio.read()));
const register_width: u32 = switch (register) { const register_width: u32 = switch (register) {
.Control => 1, .Control => 1,
@ -364,7 +364,7 @@ pub const Clock = struct {
} }
} }
break :blk @truncate(u4, value.raw); break :blk @truncate(value.raw);
}, },
.Read => |register| blk: { .Read => |register| blk: {
if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state}); if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state});
@ -390,7 +390,7 @@ pub const Clock = struct {
} }
} }
break :blk @truncate(u4, ret.raw); break :blk @truncate(ret.raw);
}, },
}; };
} }
@ -403,7 +403,7 @@ pub const Clock = struct {
} }
fn irq(self: *Self) void { fn irq(self: *Self) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), self.cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(self.cpu.bus.ptr));
// TODO: Confirm that this is the right behaviour // TODO: Confirm that this is the right behaviour
log.debug("Force GamePak IRQ", .{}); log.debug("Force GamePak IRQ", .{});
@ -429,7 +429,7 @@ pub const Clock = struct {
log.debug("Handling Command 0x{X:0>2} [0b{b:0>8}]", .{ command, command }); log.debug("Handling Command 0x{X:0>2} [0b{b:0>8}]", .{ command, command });
const is_write = command & 1 == 0; const is_write = command & 1 == 0;
const rtc_register = @truncate(u3, command >> 1 & 0x7); const rtc_register: u3 = @truncate(command >> 1 & 0x7);
if (is_write) { if (is_write) {
return switch (rtc_register) { return switch (rtc_register) {

34
src/core/bus/io.zig
View File

@ -43,8 +43,8 @@ pub const Io = struct {
} }
fn setIrqs(self: *Io, word: u32) void { fn setIrqs(self: *Io, word: u32) void {
self.ie.raw = @truncate(u16, word); self.ie.raw = @truncate(word);
self.irq.raw &= ~@truncate(u16, word >> 16); self.irq.raw &= ~@as(u16, @truncate(word >> 16));
} }
}; };
@ -75,8 +75,8 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
// Interrupts // Interrupts
0x0400_0200 => @as(u32, bus.io.irq.raw) << 16 | bus.io.ie.raw, 0x0400_0200 => @as(u32, bus.io.irq.raw) << 16 | bus.io.ie.raw,
0x0400_0204 => bus.io.waitcnt.raw, 0x0400_0204 => bus.io.waitcnt.raw,
0x0400_0208 => @boolToInt(bus.io.ime), 0x0400_0208 => @intFromBool(bus.io.ime),
0x0400_0300 => @enumToInt(bus.io.postflg), 0x0400_0300 => @intFromEnum(bus.io.postflg),
else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }), else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }),
}, },
u16 => switch (address) { u16 => switch (address) {
@ -109,9 +109,9 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
0x0400_0202 => bus.io.irq.raw, 0x0400_0202 => bus.io.irq.raw,
0x0400_0204 => bus.io.waitcnt.raw, 0x0400_0204 => bus.io.waitcnt.raw,
0x0400_0206 => 0x0000, 0x0400_0206 => 0x0000,
0x0400_0208 => @boolToInt(bus.io.ime), 0x0400_0208 => @intFromBool(bus.io.ime),
0x0400_020A => 0x0000, 0x0400_020A => 0x0000,
0x0400_0300 => @enumToInt(bus.io.postflg), 0x0400_0300 => @intFromEnum(bus.io.postflg),
0x0400_0302 => 0x0000, 0x0400_0302 => 0x0000,
else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }), else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }),
}, },
@ -141,13 +141,13 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
0x0400_015A, 0x0400_015B => 0x00, 0x0400_015A, 0x0400_015B => 0x00,
// Interrupts // Interrupts
0x0400_0200, 0x0400_0201 => @truncate(T, bus.io.ie.raw >> getHalf(@truncate(u8, address))), 0x0400_0200, 0x0400_0201 => @truncate(bus.io.ie.raw >> getHalf(@truncate(address))),
0x0400_0202, 0x0400_0203 => @truncate(T, bus.io.irq.raw >> getHalf(@truncate(u8, address))), 0x0400_0202, 0x0400_0203 => @truncate(bus.io.irq.raw >> getHalf(@truncate(address))),
0x0400_0204, 0x0400_0205 => @truncate(T, bus.io.waitcnt.raw >> getHalf(@truncate(u8, address))), 0x0400_0204, 0x0400_0205 => @truncate(bus.io.waitcnt.raw >> getHalf(@truncate(address))),
0x0400_0206, 0x0400_0207 => 0x00, 0x0400_0206, 0x0400_0207 => 0x00,
0x0400_0208, 0x0400_0209 => @truncate(T, @as(u16, @boolToInt(bus.io.ime)) >> getHalf(@truncate(u8, address))), 0x0400_0208, 0x0400_0209 => @truncate(@as(u16, @intFromBool(bus.io.ime)) >> getHalf(@truncate(address))),
0x0400_020A, 0x0400_020B => 0x00, 0x0400_020A, 0x0400_020B => 0x00,
0x0400_0300 => @enumToInt(bus.io.postflg), 0x0400_0300 => @intFromEnum(bus.io.postflg),
0x0400_0301 => null, 0x0400_0301 => null,
0x0400_0302, 0x0400_0303 => 0x00, 0x0400_0302, 0x0400_0303 => 0x00,
else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }), else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }),
@ -196,10 +196,10 @@ pub fn write(bus: *Bus, comptime T: type, address: u32, value: T) void {
// Interrupts // Interrupts
0x0400_0200 => bus.io.setIrqs(value), 0x0400_0200 => bus.io.setIrqs(value),
0x0400_0204 => bus.io.waitcnt.set(@truncate(u16, value)), 0x0400_0204 => bus.io.waitcnt.set(@truncate(value)),
0x0400_0208 => bus.io.ime = value & 1 == 1, 0x0400_0208 => bus.io.ime = value & 1 == 1,
0x0400_0300 => { 0x0400_0300 => {
bus.io.postflg = @intToEnum(PostFlag, value & 1); bus.io.postflg = @enumFromInt(value & 1);
bus.io.haltcnt = if (value >> 15 & 1 == 0) .Halt else @panic("TODO: Implement STOP"); bus.io.haltcnt = if (value >> 15 & 1 == 0) .Halt else @panic("TODO: Implement STOP");
}, },
else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, address }), else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, address }),
@ -246,7 +246,7 @@ pub fn write(bus: *Bus, comptime T: type, address: u32, value: T) void {
0x0400_0208 => bus.io.ime = value & 1 == 1, 0x0400_0208 => bus.io.ime = value & 1 == 1,
0x0400_020A => {}, 0x0400_020A => {},
0x0400_0300 => { 0x0400_0300 => {
bus.io.postflg = @intToEnum(PostFlag, value & 1); bus.io.postflg = @enumFromInt(value & 1);
bus.io.haltcnt = if (value >> 15 & 1 == 0) .Halt else @panic("TODO: Implement STOP"); bus.io.haltcnt = if (value >> 15 & 1 == 0) .Halt else @panic("TODO: Implement STOP");
}, },
else => util.io.write.undef(log, "Tried to write 0x{X:0>4}{} to 0x{X:0>8}", .{ value, T, address }), else => util.io.write.undef(log, "Tried to write 0x{X:0>4}{} to 0x{X:0>8}", .{ value, T, address }),
@ -273,16 +273,16 @@ pub fn write(bus: *Bus, comptime T: type, address: u32, value: T) void {
0x0400_0140 => log.debug("Wrote 0x{X:0>2} to JOYCNT_L", .{value}), 0x0400_0140 => log.debug("Wrote 0x{X:0>2} to JOYCNT_L", .{value}),
// Interrupts // Interrupts
0x0400_0200, 0x0400_0201 => bus.io.ie.raw = setHalf(u16, bus.io.ie.raw, @truncate(u8, address), value), 0x0400_0200, 0x0400_0201 => bus.io.ie.raw = setHalf(u16, bus.io.ie.raw, @truncate(address), value),
0x0400_0202 => bus.io.irq.raw &= ~@as(u16, value), 0x0400_0202 => bus.io.irq.raw &= ~@as(u16, value),
0x0400_0203 => bus.io.irq.raw &= ~@as(u16, value) << 8, // TODO: Is this good? 0x0400_0203 => bus.io.irq.raw &= ~@as(u16, value) << 8, // TODO: Is this good?
0x0400_0204, 0x0400_0205 => bus.io.waitcnt.set(setHalf(u16, @truncate(u16, bus.io.waitcnt.raw), @truncate(u8, address), value)), 0x0400_0204, 0x0400_0205 => bus.io.waitcnt.set(setHalf(u16, bus.io.waitcnt.raw, @truncate(address), value)),
0x0400_0206, 0x0400_0207 => {}, 0x0400_0206, 0x0400_0207 => {},
0x0400_0208 => bus.io.ime = value & 1 == 1, 0x0400_0208 => bus.io.ime = value & 1 == 1,
0x0400_0209 => {}, 0x0400_0209 => {},
0x0400_020A, 0x0400_020B => {}, 0x0400_020A, 0x0400_020B => {},
0x0400_0300 => bus.io.postflg = @intToEnum(PostFlag, value & 1), 0x0400_0300 => bus.io.postflg = @enumFromInt(value & 1),
0x0400_0301 => bus.io.haltcnt = if (value >> 7 & 1 == 0) .Halt else std.debug.panic("TODO: Implement STOP", .{}), 0x0400_0301 => bus.io.haltcnt = if (value >> 7 & 1 == 0) .Halt else std.debug.panic("TODO: Implement STOP", .{}),
0x0400_0410 => log.debug("Wrote 0x{X:0>2} to the common yet undocumented 0x{X:0>8}", .{ value, address }), 0x0400_0410 => log.debug("Wrote 0x{X:0>2} to the common yet undocumented 0x{X:0>8}", .{ value, address }),

30
src/core/bus/timer.zig
View File

@ -19,7 +19,7 @@ pub fn create(sched: *Scheduler) TimerTuple {
} }
pub fn read(comptime T: type, tim: *const TimerTuple, addr: u32) ?T { pub fn read(comptime T: type, tim: *const TimerTuple, addr: u32) ?T {
const nybble_addr = @truncate(u4, addr); const nybble_addr: u4 = @truncate(addr);
return switch (T) { return switch (T) {
u32 => switch (nybble_addr) { u32 => switch (nybble_addr) {
@ -44,24 +44,24 @@ pub fn read(comptime T: type, tim: *const TimerTuple, addr: u32) ?T {
else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }), else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }),
}, },
u8 => switch (nybble_addr) { u8 => switch (nybble_addr) {
0x0, 0x1 => @truncate(T, tim.*[0].timcntL() >> getHalf(nybble_addr)), 0x0, 0x1 => @truncate(tim.*[0].timcntL() >> getHalf(nybble_addr)),
0x2, 0x3 => @truncate(T, tim.*[0].cnt.raw >> getHalf(nybble_addr)), 0x2, 0x3 => @truncate(tim.*[0].cnt.raw >> getHalf(nybble_addr)),
0x4, 0x5 => @truncate(T, tim.*[1].timcntL() >> getHalf(nybble_addr)), 0x4, 0x5 => @truncate(tim.*[1].timcntL() >> getHalf(nybble_addr)),
0x6, 0x7 => @truncate(T, tim.*[1].cnt.raw >> getHalf(nybble_addr)), 0x6, 0x7 => @truncate(tim.*[1].cnt.raw >> getHalf(nybble_addr)),
0x8, 0x9 => @truncate(T, tim.*[2].timcntL() >> getHalf(nybble_addr)), 0x8, 0x9 => @truncate(tim.*[2].timcntL() >> getHalf(nybble_addr)),
0xA, 0xB => @truncate(T, tim.*[2].cnt.raw >> getHalf(nybble_addr)), 0xA, 0xB => @truncate(tim.*[2].cnt.raw >> getHalf(nybble_addr)),
0xC, 0xD => @truncate(T, tim.*[3].timcntL() >> getHalf(nybble_addr)), 0xC, 0xD => @truncate(tim.*[3].timcntL() >> getHalf(nybble_addr)),
0xE, 0xF => @truncate(T, tim.*[3].cnt.raw >> getHalf(nybble_addr)), 0xE, 0xF => @truncate(tim.*[3].cnt.raw >> getHalf(nybble_addr)),
}, },
else => @compileError("TIM: Unsupported read width"), else => @compileError("TIM: Unsupported read width"),
}; };
} }
pub fn write(comptime T: type, tim: *TimerTuple, addr: u32, value: T) void { pub fn write(comptime T: type, tim: *TimerTuple, addr: u32, value: T) void {
const nybble_addr = @truncate(u4, addr); const nybble_addr: u4 = @truncate(addr);
return switch (T) { return switch (T) {
u32 => switch (nybble_addr) { u32 => switch (nybble_addr) {
@ -141,7 +141,7 @@ fn Timer(comptime id: u2) type {
pub fn timcntL(self: *const Self) u16 { pub fn timcntL(self: *const Self) u16 {
if (self.cnt.cascade.read() or !self.cnt.enabled.read()) return self._counter; if (self.cnt.cascade.read() or !self.cnt.enabled.read()) return self._counter;
return self._counter +% @truncate(u16, (self.sched.now() - self._start_timestamp) / self.frequency()); return self._counter +% @as(u16, @truncate((self.sched.now() - self._start_timestamp) / self.frequency()));
} }
/// TIMCNT_L Setter /// TIMCNT_L Setter
@ -151,8 +151,8 @@ fn Timer(comptime id: u2) type {
/// TIMCNT_L & TIMCNT_H /// TIMCNT_L & TIMCNT_H
pub fn setTimcnt(self: *Self, word: u32) void { pub fn setTimcnt(self: *Self, word: u32) void {
self.setTimcntL(@truncate(u16, word)); self.setTimcntL(@truncate(word));
self.setTimcntH(@truncate(u16, word >> 16)); self.setTimcntH(@truncate(word >> 16));
} }
/// TIMCNT_H /// TIMCNT_H
@ -167,7 +167,7 @@ fn Timer(comptime id: u2) type {
self.sched.removeScheduledEvent(.{ .TimerOverflow = id }); self.sched.removeScheduledEvent(.{ .TimerOverflow = id });
// Counter should hold the value it stopped at meaning we have to calculate it now // Counter should hold the value it stopped at meaning we have to calculate it now
self._counter +%= @truncate(u16, (self.sched.now() - self._start_timestamp) / self.frequency()); self._counter +%= @truncate((self.sched.now() - self._start_timestamp) / self.frequency());
} }
// the timer has always been enabled, but the cascade bit which was blocking the timer has been unset // the timer has always been enabled, but the cascade bit which was blocking the timer has been unset
@ -194,7 +194,7 @@ fn Timer(comptime id: u2) type {
pub fn onTimerExpire(self: *Self, cpu: *Arm7tdmi, late: u64) void { pub fn onTimerExpire(self: *Self, cpu: *Arm7tdmi, late: u64) void {
// Fire IRQ if enabled // Fire IRQ if enabled
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
const io = &bus_ptr.io; const io = &bus_ptr.io;

8
src/core/cpu_util.zig
View File

@ -5,13 +5,13 @@ const Bank = @import("arm32").Arm7tdmi.Bank;
const Bus = @import("Bus.zig"); const Bus = @import("Bus.zig");
pub inline fn isHalted(cpu: *const Arm7tdmi) bool { pub inline fn isHalted(cpu: *const Arm7tdmi) bool {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
return bus_ptr.io.haltcnt == .Halt; return bus_ptr.io.haltcnt == .Halt;
} }
pub fn stepDmaTransfer(cpu: *Arm7tdmi) bool { pub fn stepDmaTransfer(cpu: *Arm7tdmi) bool {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
inline for (0..4) |i| { inline for (0..4) |i| {
if (bus_ptr.dma[i].in_progress) { if (bus_ptr.dma[i].in_progress) {
@ -24,7 +24,7 @@ pub fn stepDmaTransfer(cpu: *Arm7tdmi) bool {
} }
pub fn handleInterrupt(cpu: *Arm7tdmi) void { pub fn handleInterrupt(cpu: *Arm7tdmi) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
const should_handle = bus_ptr.io.ie.raw & bus_ptr.io.irq.raw; const should_handle = bus_ptr.io.ie.raw & bus_ptr.io.irq.raw;
// Return if IME is disabled, CPSR I is set or there is nothing to handle // Return if IME is disabled, CPSR I is set or there is nothing to handle
@ -57,7 +57,7 @@ pub fn handleInterrupt(cpu: *Arm7tdmi) void {
/// ///
/// TODO: Make above notice impossible to do in code /// TODO: Make above notice impossible to do in code
pub fn fastBoot(cpu: *Arm7tdmi) void { pub fn fastBoot(cpu: *Arm7tdmi) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
cpu.r = std.mem.zeroes([16]u32); cpu.r = std.mem.zeroes([16]u32);
// cpu.r[0] = 0x08000000; // cpu.r[0] = 0x08000000;

8
src/core/emu.zig
View File

@ -30,7 +30,7 @@ const frame_period = (std.time.ns_per_s * cycles_per_frame) / clock_rate;
/// Exact Value: 59.7275005696Hz /// Exact Value: 59.7275005696Hz
/// The inverse of the frame period /// The inverse of the frame period
pub const frame_rate: f64 = @intToFloat(f64, clock_rate) / cycles_per_frame; pub const frame_rate: f64 = @as(f64, @floatFromInt(clock_rate)) / cycles_per_frame;
const log = std.log.scoped(.Emulation); const log = std.log.scoped(.Emulation);
@ -58,7 +58,7 @@ fn inner(comptime kind: RunKind, audio_sync: bool, cpu: *Arm7tdmi, scheduler: *S
log.info("FPS tracking enabled", .{}); log.info("FPS tracking enabled", .{});
} }
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
var paused: bool = false; var paused: bool = false;
@ -256,14 +256,14 @@ pub fn reset(cpu: *Arm7tdmi) void {
} }
pub fn replaceGamepak(cpu: *Arm7tdmi, file_path: []const u8) !void { pub fn replaceGamepak(cpu: *Arm7tdmi, file_path: []const u8) !void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
try bus_ptr.replaceGamepak(file_path); try bus_ptr.replaceGamepak(file_path);
reset(cpu); reset(cpu);
} }
pub fn replaceBios(cpu: *Arm7tdmi, file_path: []const u8) !void { pub fn replaceBios(cpu: *Arm7tdmi, file_path: []const u8) !void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
const allocator = bus_ptr.bios.allocator; const allocator = bus_ptr.bios.allocator;
const bios_len = 0x4000; const bios_len = 0x4000;

204
src/core/ppu.zig
View File

@ -28,7 +28,7 @@ pub const height = 160;
pub const framebuf_pitch = width * @sizeOf(u32); pub const framebuf_pitch = width * @sizeOf(u32);
pub fn read(comptime T: type, ppu: *const Ppu, addr: u32) ?T { pub fn read(comptime T: type, ppu: *const Ppu, addr: u32) ?T {
const byte_addr = @truncate(u8, addr); const byte_addr: u8 = @truncate(addr);
return switch (T) { return switch (T) {
u32 => switch (byte_addr) { u32 => switch (byte_addr) {
@ -69,24 +69,24 @@ pub fn read(comptime T: type, ppu: *const Ppu, addr: u32) ?T {
else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }), else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }),
}, },
u8 => switch (byte_addr) { u8 => switch (byte_addr) {
0x00, 0x01 => @truncate(T, ppu.dispcnt.raw >> getHalf(byte_addr)), 0x00, 0x01 => @truncate(ppu.dispcnt.raw >> getHalf(byte_addr)),
0x02, 0x03 => null, 0x02, 0x03 => null,
0x04, 0x05 => @truncate(T, ppu.dispstat.raw >> getHalf(byte_addr)), 0x04, 0x05 => @truncate(ppu.dispstat.raw >> getHalf(byte_addr)),
0x06, 0x07 => @truncate(T, ppu.vcount.raw >> getHalf(byte_addr)), 0x06, 0x07 => @truncate(ppu.vcount.raw >> getHalf(byte_addr)),
0x08, 0x09 => @truncate(T, ppu.bg[0].bg0Cnt() >> getHalf(byte_addr)), 0x08, 0x09 => @truncate(ppu.bg[0].bg0Cnt() >> getHalf(byte_addr)),
0x0A, 0x0B => @truncate(T, ppu.bg[1].bg1Cnt() >> getHalf(byte_addr)), 0x0A, 0x0B => @truncate(ppu.bg[1].bg1Cnt() >> getHalf(byte_addr)),
0x0C, 0x0D => @truncate(T, ppu.bg[2].cnt.raw >> getHalf(byte_addr)), 0x0C, 0x0D => @truncate(ppu.bg[2].cnt.raw >> getHalf(byte_addr)),
0x0E, 0x0F => @truncate(T, ppu.bg[3].cnt.raw >> getHalf(byte_addr)), 0x0E, 0x0F => @truncate(ppu.bg[3].cnt.raw >> getHalf(byte_addr)),
0x10...0x1F => null, // BGXHOFS/VOFS 0x10...0x1F => null, // BGXHOFS/VOFS
0x20...0x2F => null, // BG2 Rot/Scaling 0x20...0x2F => null, // BG2 Rot/Scaling
0x30...0x3F => null, // BG3 Rot/Scaling 0x30...0x3F => null, // BG3 Rot/Scaling
0x40...0x47 => null, // WINXH/V Registers 0x40...0x47 => null, // WINXH/V Registers
0x48, 0x49 => @truncate(T, ppu.win.getIn() >> getHalf(byte_addr)), 0x48, 0x49 => @truncate(ppu.win.getIn() >> getHalf(byte_addr)),
0x4A, 0x4B => @truncate(T, ppu.win.getOut() >> getHalf(byte_addr)), 0x4A, 0x4B => @truncate(ppu.win.getOut() >> getHalf(byte_addr)),
0x4C, 0x4D => null, // MOSAIC 0x4C, 0x4D => null, // MOSAIC
0x4E, 0x4F => null, 0x4E, 0x4F => null,
0x50, 0x51 => @truncate(T, ppu.bld.getCnt() >> getHalf(byte_addr)), 0x50, 0x51 => @truncate(ppu.bld.getCnt() >> getHalf(byte_addr)),
0x52, 0x53 => @truncate(T, ppu.bld.getAlpha() >> getHalf(byte_addr)), 0x52, 0x53 => @truncate(ppu.bld.getAlpha() >> getHalf(byte_addr)),
0x54, 0x55 => null, // BLDY 0x54, 0x55 => null, // BLDY
else => util.io.read.err(T, log, "unexpected {} read from 0x{X:0>8}", .{ T, addr }), else => util.io.read.err(T, log, "unexpected {} read from 0x{X:0>8}", .{ T, addr }),
}, },
@ -95,14 +95,14 @@ pub fn read(comptime T: type, ppu: *const Ppu, addr: u32) ?T {
} }
pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void { pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
const byte_addr = @truncate(u8, addr); // prefixed with 0x0400_00 const byte_addr: u8 = @truncate(addr); // prefixed with 0x0400_00
switch (T) { switch (T) {
u32 => switch (byte_addr) { u32 => switch (byte_addr) {
0x00 => ppu.dispcnt.raw = @truncate(u16, value), 0x00 => ppu.dispcnt.raw = @truncate(value),
0x04 => { 0x04 => {
ppu.dispstat.set(@truncate(u16, value)); ppu.dispstat.set(@truncate(value));
ppu.vcount.raw = @truncate(u16, value >> 16); ppu.vcount.raw = @truncate(value >> 16);
}, },
0x08 => ppu.setAdjCnts(0, value), 0x08 => ppu.setAdjCnts(0, value),
0x0C => ppu.setAdjCnts(2, value), 0x0C => ppu.setAdjCnts(2, value),
@ -128,10 +128,10 @@ pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
0x4C => log.debug("Wrote 0x{X:0>8} to MOSAIC", .{value}), 0x4C => log.debug("Wrote 0x{X:0>8} to MOSAIC", .{value}),
0x50 => { 0x50 => {
ppu.bld.cnt.raw = @truncate(u16, value); ppu.bld.cnt.raw = @truncate(value);
ppu.bld.alpha.raw = @truncate(u16, value >> 16); ppu.bld.alpha.raw = @truncate(value >> 16);
}, },
0x54 => ppu.bld.y.raw = @truncate(u16, value), 0x54 => ppu.bld.y.raw = @truncate(value),
else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, addr }), else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, addr }),
}, },
u16 => switch (byte_addr) { u16 => switch (byte_addr) {
@ -154,19 +154,19 @@ pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
0x1C => ppu.bg[3].hofs.raw = value, 0x1C => ppu.bg[3].hofs.raw = value,
0x1E => ppu.bg[3].vofs.raw = value, 0x1E => ppu.bg[3].vofs.raw = value,
0x20 => ppu.aff_bg[0].pa = @bitCast(i16, value), 0x20 => ppu.aff_bg[0].pa = @bitCast(value),
0x22 => ppu.aff_bg[0].pb = @bitCast(i16, value), 0x22 => ppu.aff_bg[0].pb = @bitCast(value),
0x24 => ppu.aff_bg[0].pc = @bitCast(i16, value), 0x24 => ppu.aff_bg[0].pc = @bitCast(value),
0x26 => ppu.aff_bg[0].pd = @bitCast(i16, value), 0x26 => ppu.aff_bg[0].pd = @bitCast(value),
0x28, 0x2A => ppu.aff_bg[0].x = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[0].x), byte_addr, value)), 0x28, 0x2A => ppu.aff_bg[0].x = @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[0].x)), byte_addr, value)),
0x2C, 0x2E => ppu.aff_bg[0].y = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[0].y), byte_addr, value)), 0x2C, 0x2E => ppu.aff_bg[0].y = @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[0].y)), byte_addr, value)),
0x30 => ppu.aff_bg[1].pa = @bitCast(i16, value), 0x30 => ppu.aff_bg[1].pa = @bitCast(value),
0x32 => ppu.aff_bg[1].pb = @bitCast(i16, value), 0x32 => ppu.aff_bg[1].pb = @bitCast(value),
0x34 => ppu.aff_bg[1].pc = @bitCast(i16, value), 0x34 => ppu.aff_bg[1].pc = @bitCast(value),
0x36 => ppu.aff_bg[1].pd = @bitCast(i16, value), 0x36 => ppu.aff_bg[1].pd = @bitCast(value),
0x38, 0x3A => ppu.aff_bg[1].x = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[1].x), byte_addr, value)), 0x38, 0x3A => ppu.aff_bg[1].x = @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[1].x)), byte_addr, value)),
0x3C, 0x3E => ppu.aff_bg[1].y = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[1].y), byte_addr, value)), 0x3C, 0x3E => ppu.aff_bg[1].y = @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[1].y)), byte_addr, value)),
0x40 => ppu.win.h[0].raw = value, 0x40 => ppu.win.h[0].raw = value,
0x42 => ppu.win.h[1].raw = value, 0x42 => ppu.win.h[1].raw = value,
@ -205,20 +205,20 @@ pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
0x1E, 0x1F => ppu.bg[3].vofs.raw = setHalf(u16, ppu.bg[3].vofs.raw, byte_addr, value), 0x1E, 0x1F => ppu.bg[3].vofs.raw = setHalf(u16, ppu.bg[3].vofs.raw, byte_addr, value),
// BG2 Rot/Scaling // BG2 Rot/Scaling
0x20, 0x21 => ppu.aff_bg[0].pa = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pa), byte_addr, value)), 0x20, 0x21 => ppu.aff_bg[0].pa = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pa)), byte_addr, value)),
0x22, 0x23 => ppu.aff_bg[0].pb = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pb), byte_addr, value)), 0x22, 0x23 => ppu.aff_bg[0].pb = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pb)), byte_addr, value)),
0x24, 0x25 => ppu.aff_bg[0].pc = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pc), byte_addr, value)), 0x24, 0x25 => ppu.aff_bg[0].pc = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pc)), byte_addr, value)),
0x26, 0x27 => ppu.aff_bg[0].pd = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pd), byte_addr, value)), 0x26, 0x27 => ppu.aff_bg[0].pd = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pd)), byte_addr, value)),
0x28, 0x29, 0x2A, 0x2B => ppu.aff_bg[0].x = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[0].x), byte_addr, value)), 0x28, 0x29, 0x2A, 0x2B => ppu.aff_bg[0].x = @bitCast(setQuart(@bitCast(ppu.aff_bg[0].x), byte_addr, value)),
0x2C, 0x2D, 0x2E, 0x2F => ppu.aff_bg[0].y = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[0].y), byte_addr, value)), 0x2C, 0x2D, 0x2E, 0x2F => ppu.aff_bg[0].y = @bitCast(setQuart(@bitCast(ppu.aff_bg[0].y), byte_addr, value)),
// BG3 Rot/Scaling // BG3 Rot/Scaling
0x30, 0x31 => ppu.aff_bg[1].pa = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pa), byte_addr, value)), 0x30, 0x31 => ppu.aff_bg[1].pa = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pa)), byte_addr, value)),
0x32, 0x33 => ppu.aff_bg[1].pb = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pb), byte_addr, value)), 0x32, 0x33 => ppu.aff_bg[1].pb = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pb)), byte_addr, value)),
0x34, 0x35 => ppu.aff_bg[1].pc = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pc), byte_addr, value)), 0x34, 0x35 => ppu.aff_bg[1].pc = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pc)), byte_addr, value)),
0x36, 0x37 => ppu.aff_bg[1].pd = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pd), byte_addr, value)), 0x36, 0x37 => ppu.aff_bg[1].pd = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pd)), byte_addr, value)),
0x38, 0x39, 0x3A, 0x3B => ppu.aff_bg[1].x = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[1].x), byte_addr, value)), 0x38, 0x39, 0x3A, 0x3B => ppu.aff_bg[1].x = @bitCast(setQuart(@bitCast(ppu.aff_bg[1].x), byte_addr, value)),
0x3C, 0x3D, 0x3E, 0x3F => ppu.aff_bg[1].y = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[1].y), byte_addr, value)), 0x3C, 0x3D, 0x3E, 0x3F => ppu.aff_bg[1].y = @bitCast(setQuart(@bitCast(ppu.aff_bg[1].y), byte_addr, value)),
// Window // Window
0x40, 0x41 => ppu.win.h[0].raw = setHalf(u16, ppu.win.h[0].raw, byte_addr, value), 0x40, 0x41 => ppu.win.h[0].raw = setHalf(u16, ppu.win.h[0].raw, byte_addr, value),
@ -324,13 +324,13 @@ pub const Ppu = struct {
} }
pub fn setBgOffsets(self: *Self, comptime n: u2, word: u32) void { pub fn setBgOffsets(self: *Self, comptime n: u2, word: u32) void {
self.bg[n].hofs.raw = @truncate(u16, word); self.bg[n].hofs.raw = @truncate(word);
self.bg[n].vofs.raw = @truncate(u16, word >> 16); self.bg[n].vofs.raw = @truncate(word >> 16);
} }
pub fn setAdjCnts(self: *Self, comptime n: u2, word: u32) void { pub fn setAdjCnts(self: *Self, comptime n: u2, word: u32) void {
self.bg[n].cnt.raw = @truncate(u16, word); self.bg[n].cnt.raw = @truncate(word);
self.bg[n + 1].cnt.raw = @truncate(u16, word >> 16); self.bg[n + 1].cnt.raw = @truncate(word >> 16);
} }
/// Search OAM for Sprites that might be rendered on this scanline /// Search OAM for Sprites that might be rendered on this scanline
@ -341,11 +341,11 @@ pub const Ppu = struct {
search: while (i < self.oam.buf.len) : (i += 8) { search: while (i < self.oam.buf.len) : (i += 8) {
// Attributes in OAM are 6 bytes long, with 2 bytes of padding // Attributes in OAM are 6 bytes long, with 2 bytes of padding
// Grab Attributes from OAM // Grab Attributes from OAM
const attr0 = @bitCast(Attr0, self.oam.read(u16, i)); const attr0: Attr0 = @bitCast(self.oam.read(u16, i));
// Only consider enabled Sprites // Only consider enabled Sprites
if (attr0.is_affine.read() or !attr0.disabled.read()) { if (attr0.is_affine.read() or !attr0.disabled.read()) {
const attr1 = @bitCast(Attr1, self.oam.read(u16, i + 2)); const attr1: Attr1 = @bitCast(self.oam.read(u16, i + 2));
const d = spriteDimensions(attr0.shape.read(), attr1.size.read()); const d = spriteDimensions(attr0.shape.read(), attr1.size.read());
// Account for double-size affine sprites // Account for double-size affine sprites
@ -368,7 +368,7 @@ pub const Ppu = struct {
if (y_pos <= y and y < (y_pos + sprite_height)) { if (y_pos <= y and y < (y_pos + sprite_height)) {
for (self.scanline_sprites) |*maybe_sprite| { for (self.scanline_sprites) |*maybe_sprite| {
if (maybe_sprite.* == null) { if (maybe_sprite.* == null) {
maybe_sprite.* = Sprite.init(attr0, attr1, @bitCast(Attr2, self.oam.read(u16, i + 4))); maybe_sprite.* = Sprite.init(attr0, attr1, @bitCast(self.oam.read(u16, i + 4)));
continue :search; continue :search;
} }
} }
@ -414,7 +414,7 @@ pub const Ppu = struct {
const pc = self.oam.read(u16, base + 11 * @sizeOf(u16)); const pc = self.oam.read(u16, base + 11 * @sizeOf(u16));
const pd = self.oam.read(u16, base + 15 * @sizeOf(u16)); const pd = self.oam.read(u16, base + 15 * @sizeOf(u16));
const matrix = @bitCast([4]i16, [_]u16{ pa, pb, pc, pd }); const matrix: [4]i16 = @bitCast([_]u16{ pa, pb, pc, pd });
const sprite_width = sprite.width << if (double_size) 1 else 0; const sprite_width = sprite.width << if (double_size) 1 else 0;
const sprite_height = sprite.height << if (double_size) 1 else 0; const sprite_height = sprite.height << if (double_size) 1 else 0;
@ -425,7 +425,7 @@ pub const Ppu = struct {
var i: u9 = 0; var i: u9 = 0;
while (i < sprite_width) : (i += 1) { while (i < sprite_width) : (i += 1) {
// TODO: Something is wrong here // TODO: Something is wrong here
const x = @truncate(u9, @bitCast(u16, sprite_x + i)); const x: u9 = @truncate(@as(u16, @bitCast(sprite_x + i)));
if (x >= width) continue; if (x >= width) continue;
if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue; if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue;
@ -447,11 +447,11 @@ pub const Ppu = struct {
// Maybe this is the necessary check? // Maybe this is the necessary check?
if (rot_x >= sprite.width or rot_y >= sprite.height or rot_x < 0 or rot_y < 0) continue; if (rot_x >= sprite.width or rot_y >= sprite.height or rot_x < 0 or rot_y < 0) continue;
const tile_x = @bitCast(u16, rot_x); const tile_x: u16 = @bitCast(rot_x);
const tile_y = @bitCast(u16, rot_y); const tile_y: u16 = @bitCast(rot_y);
const col = @truncate(u3, tile_x); const col: u3 = @truncate(tile_x);
const row = @truncate(u3, tile_y); const row: u3 = @truncate(tile_y);
// TODO: Finish that 2D Sprites Test ROM // TODO: Finish that 2D Sprites Test ROM
const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1; const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1;
@ -461,12 +461,12 @@ pub const Ppu = struct {
const tile = self.vram.buf[tile_base + tile_offset]; const tile = self.vram.buf[tile_base + tile_offset];
const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile; const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile;
const global_x = @truncate(u9, @bitCast(u16, local_x + sprite_x)); const global_x: u9 = @truncate(@as(u16, @bitCast(local_x + sprite_x)));
// Sprite Palette starts at 0x0500_0200 // Sprite Palette starts at 0x0500_0200
if (pal_id != 0) { if (pal_id != 0) {
const bgr555 = self.palette.read(u16, 0x200 + pal_id * 2); const bgr555 = self.palette.read(u16, 0x200 + pal_id * 2);
drawSpritePixel(self.bld.cnt, &self.scanline, @bitCast(Attr0, sprite.attr0), global_x, bgr555); drawSpritePixel(self.bld.cnt, &self.scanline, @as(Attr0, @bitCast(sprite.attr0)), global_x, bgr555);
} }
} }
} }
@ -490,7 +490,7 @@ pub const Ppu = struct {
var i: u9 = 0; var i: u9 = 0;
while (i < sprite.width) : (i += 1) { while (i < sprite.width) : (i += 1) {
// TODO: Something is Wrong Here // TODO: Something is Wrong Here
const x = @truncate(u9, @bitCast(u16, sprite_x + i)); const x = @as(u9, @truncate(@as(u16, @bitCast(sprite_x + i))));
if (x >= width) continue; if (x >= width) continue;
if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue; if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue;
@ -504,11 +504,11 @@ pub const Ppu = struct {
// Note that we flip the tile_pos not the (tile_pos % 8) like we do for // Note that we flip the tile_pos not the (tile_pos % 8) like we do for
// Background Tiles. By doing this we mirror the entire sprite instead of // Background Tiles. By doing this we mirror the entire sprite instead of
// just a specific tile (see how sprite.width and sprite.height are involved) // just a specific tile (see how sprite.width and sprite.height are involved)
const tile_x = @intCast(u9, local_x) ^ if (sprite.hFlip()) (sprite.width - 1) else 0; const tile_x = @as(u9, @intCast(local_x)) ^ if (sprite.hFlip()) (sprite.width - 1) else 0;
const tile_y = @intCast(u8, local_y) ^ if (sprite.vFlip()) (sprite.height - 1) else 0; const tile_y = @as(u8, @intCast(local_y)) ^ if (sprite.vFlip()) (sprite.height - 1) else 0;
const col = @truncate(u3, tile_x); const col: u3 = @truncate(tile_x);
const row = @truncate(u3, tile_y); const row: u3 = @truncate(tile_y);
// TODO: Finish that 2D Sprites Test ROM // TODO: Finish that 2D Sprites Test ROM
const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1; const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1;
@ -518,7 +518,7 @@ pub const Ppu = struct {
const tile = self.vram.buf[tile_base + tile_offset]; const tile = self.vram.buf[tile_base + tile_offset];
const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile; const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile;
const global_x = @truncate(u9, @bitCast(u16, local_x + sprite_x)); const global_x: u9 = @truncate(@as(u16, @bitCast(local_x + sprite_x)));
// Sprite Palette starts at 0x0500_0200 // Sprite Palette starts at 0x0500_0200
if (pal_id != 0) { if (pal_id != 0) {
@ -550,8 +550,8 @@ pub const Ppu = struct {
aff_x += self.aff_bg[n - 2].pa; aff_x += self.aff_bg[n - 2].pa;
aff_y += self.aff_bg[n - 2].pc; aff_y += self.aff_bg[n - 2].pc;
const _x = @truncate(u9, @bitCast(u32, ix)); const _x: u9 = @truncate(@as(u32, @bitCast(ix)));
const _y = @truncate(u8, @bitCast(u32, iy)); const _y: u8 = @truncate(@as(u32, @bitCast(iy)));
const win_bounds = self.windowBounds(_x, _y); const win_bounds = self.windowBounds(_x, _y);
if (!shouldDrawBackground(self, n, win_bounds, i)) continue; if (!shouldDrawBackground(self, n, win_bounds, i)) continue;
@ -561,10 +561,10 @@ pub const Ppu = struct {
iy = if (iy > px_height) @rem(iy, px_height) else if (iy < 0) px_height + @rem(iy, px_height) else iy; iy = if (iy > px_height) @rem(iy, px_height) else if (iy < 0) px_height + @rem(iy, px_height) else iy;
} else if (ix > px_width or iy > px_height or ix < 0 or iy < 0) continue; } else if (ix > px_width or iy > px_height or ix < 0 or iy < 0) continue;
const x = @bitCast(u32, ix); const x: u32 = @bitCast(ix);
const y = @bitCast(u32, iy); const y: u32 = @bitCast(iy);
const tile_id: u32 = self.vram.read(u8, screen_base + ((y / 8) * @bitCast(u32, tile_width) + (x / 8))); const tile_id: u32 = self.vram.read(u8, screen_base + ((y / 8) * @as(u32, @bitCast(tile_width)) + (x / 8)));
const row = y & 7; const row = y & 7;
const col = x & 7; const col = x & 7;
@ -601,12 +601,12 @@ pub const Ppu = struct {
while (i < width) : (i += 1) { while (i < width) : (i += 1) {
const x = hofs + i; const x = hofs + i;
const win_bounds = self.windowBounds(@truncate(u9, x), @truncate(u8, y)); const win_bounds = self.windowBounds(@truncate(x), @truncate(y));
if (!shouldDrawBackground(self, n, win_bounds, i)) continue; if (!shouldDrawBackground(self, n, win_bounds, i)) continue;
// Grab the Screen Entry from VRAM // Grab the Screen Entry from VRAM
const entry_addr = screen_base + tilemapOffset(size, x, y); const entry_addr = screen_base + tilemapOffset(size, x, y);
const entry = @bitCast(ScreenEntry, self.vram.read(u16, entry_addr)); const entry: ScreenEntry = @bitCast(self.vram.read(u16, entry_addr));
// Calculate the Address of the Tile in the designated Charblock // Calculate the Address of the Tile in the designated Charblock
// We also take this opportunity to flip tiles if necessary // We also take this opportunity to flip tiles if necessary
@ -615,8 +615,8 @@ pub const Ppu = struct {
// Calculate row and column offsets. Understand that // Calculate row and column offsets. Understand that
// `tile_len`, `tile_row_offset` and `col` are subject to different // `tile_len`, `tile_row_offset` and `col` are subject to different
// values depending on whether we are in 4bpp or 8bpp mode. // values depending on whether we are in 4bpp or 8bpp mode.
const row = @truncate(u3, y) ^ if (entry.v_flip.read()) 7 else @as(u3, 0); const row = @as(u3, @truncate(y)) ^ if (entry.v_flip.read()) 7 else @as(u3, 0);
const col = @truncate(u3, x) ^ if (entry.h_flip.read()) 7 else @as(u3, 0); const col = @as(u3, @truncate(x)) ^ if (entry.h_flip.read()) 7 else @as(u3, 0);
const tile_addr = char_base + (tile_id * tile_len) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1; const tile_addr = char_base + (tile_id * tile_len) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1;
const tile = self.vram.buf[tile_addr]; const tile = self.vram.buf[tile_addr];
@ -649,7 +649,7 @@ pub const Ppu = struct {
if (obj_enable) self.fetchSprites(); if (obj_enable) self.fetchSprites();
for (0..4) |layer| { for (0..4) |layer| {
self.drawSprites(@truncate(u2, layer)); self.drawSprites(@truncate(layer));
if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0); if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0);
if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1); if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1);
if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawBackground(2); if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawBackground(2);
@ -663,7 +663,7 @@ pub const Ppu = struct {
if (obj_enable) self.fetchSprites(); if (obj_enable) self.fetchSprites();
for (0..4) |layer| { for (0..4) |layer| {
self.drawSprites(@truncate(u2, layer)); self.drawSprites(@as(u2, @truncate(layer)));
if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0); if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0);
if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1); if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1);
if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2); if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2);
@ -676,7 +676,7 @@ pub const Ppu = struct {
if (obj_enable) self.fetchSprites(); if (obj_enable) self.fetchSprites();
for (0..4) |layer| { for (0..4) |layer| {
self.drawSprites(@truncate(u2, layer)); self.drawSprites(@truncate(layer));
if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2); if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2);
if (layer == self.bg[3].cnt.priority.read() and bg_enable >> 3 & 1 == 1) self.drawAffineBackground(3); if (layer == self.bg[3].cnt.priority.read() and bg_enable >> 3 & 1 == 1) self.drawAffineBackground(3);
} }
@ -688,8 +688,8 @@ pub const Ppu = struct {
const framebuf_base = width * @as(usize, scanline); const framebuf_base = width * @as(usize, scanline);
// FIXME: @ptrCast between slices changing the length isn't implemented yet // FIXME: @ptrCast between slices changing the length isn't implemented yet
const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf)); const vram_buf: [*]const u16 = @ptrCast(@alignCast(self.vram.buf));
const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator))); const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
for (vram_buf[vram_base .. vram_base + width], 0..) |bgr555, i| { for (vram_buf[vram_base .. vram_base + width], 0..) |bgr555, i| {
framebuf[framebuf_base + i] = rgba888(bgr555); framebuf[framebuf_base + i] = rgba888(bgr555);
@ -702,8 +702,8 @@ pub const Ppu = struct {
const framebuf_base = width * @as(usize, scanline); const framebuf_base = width * @as(usize, scanline);
// FIXME: @ptrCast between slices changing the length isn't implemented yet // FIXME: @ptrCast between slices changing the length isn't implemented yet
const pal_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.palette.buf)); const pal_buf: [*]const u16 = @ptrCast(@alignCast(self.palette.buf));
const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator))); const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
for (self.vram.buf[vram_base .. vram_base + width], 0..) |pal_id, i| { for (self.vram.buf[vram_base .. vram_base + width], 0..) |pal_id, i| {
framebuf[framebuf_base + i] = rgba888(pal_buf[pal_id]); framebuf[framebuf_base + i] = rgba888(pal_buf[pal_id]);
@ -718,8 +718,8 @@ pub const Ppu = struct {
const framebuf_base = width * @as(usize, scanline); const framebuf_base = width * @as(usize, scanline);
// FIXME: @ptrCast between slices changing the length isn't implemented yet // FIXME: @ptrCast between slices changing the length isn't implemented yet
const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf)); const vram_buf: [*]const u16 = @ptrCast(@alignCast(self.vram.buf));
const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator))); const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
for (0..width) |i| { for (0..width) |i| {
const bgr555 = if (scanline < m5_height and i < m5_width) vram_buf[vram_base + i] else self.palette.backdrop(); const bgr555 = if (scanline < m5_height and i < m5_width) vram_buf[vram_base + i] else self.palette.backdrop();
@ -735,7 +735,7 @@ pub const Ppu = struct {
// If there are any nulls present in self.scanline.top() it means that no background drew a pixel there, so draw backdrop // If there are any nulls present in self.scanline.top() it means that no background drew a pixel there, so draw backdrop
// FIXME: @ptrCast between slices changing the length isn't implemented yet // FIXME: @ptrCast between slices changing the length isn't implemented yet
const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator))); const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
for (self.scanline.top(), 0..) |maybe_top, i| { for (self.scanline.top(), 0..) |maybe_top, i| {
const maybe_btm = self.scanline.btm()[i]; const maybe_btm = self.scanline.btm()[i];
@ -1003,7 +1003,7 @@ pub const Ppu = struct {
} }
pub fn onHdrawEnd(self: *Self, cpu: *Arm7tdmi, late: u64) void { pub fn onHdrawEnd(self: *Self, cpu: *Arm7tdmi, late: u64) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
// Transitioning to a Hblank // Transitioning to a Hblank
if (self.dispstat.hblank_irq.read()) { if (self.dispstat.hblank_irq.read()) {
@ -1020,7 +1020,7 @@ pub const Ppu = struct {
} }
pub fn onHblankEnd(self: *Self, cpu: *Arm7tdmi, late: u64) void { pub fn onHblankEnd(self: *Self, cpu: *Arm7tdmi, late: u64) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
// The End of a Hblank (During Draw or Vblank) // The End of a Hblank (During Draw or Vblank)
const old_scanline = self.vcount.scanline.read(); const old_scanline = self.vcount.scanline.read();
@ -1148,18 +1148,18 @@ const Window = struct {
} }
pub fn setH(self: *Self, value: u32) void { pub fn setH(self: *Self, value: u32) void {
self.h[0].raw = @truncate(u16, value); self.h[0].raw = @truncate(value);
self.h[1].raw = @truncate(u16, value >> 16); self.h[1].raw = @truncate(value >> 16);
} }
pub fn setV(self: *Self, value: u32) void { pub fn setV(self: *Self, value: u32) void {
self.v[0].raw = @truncate(u16, value); self.v[0].raw = @truncate(value);
self.v[1].raw = @truncate(u16, value >> 16); self.v[1].raw = @truncate(value >> 16);
} }
pub fn setIo(self: *Self, value: u32) void { pub fn setIo(self: *Self, value: u32) void {
self.in.raw = @truncate(u16, value); self.in.raw = @truncate(value);
self.out.raw = @truncate(u16, value >> 16); self.out.raw = @truncate(value >> 16);
} }
}; };
@ -1222,23 +1222,23 @@ const AffineBackground = struct {
} }
pub fn setX(self: *Self, is_vblank: bool, value: u32) void { pub fn setX(self: *Self, is_vblank: bool, value: u32) void {
self.x = @bitCast(i32, value); self.x = @bitCast(value);
if (!is_vblank) self.x_latch = @bitCast(i32, value); if (!is_vblank) self.x_latch = @bitCast(value);
} }
pub fn setY(self: *Self, is_vblank: bool, value: u32) void { pub fn setY(self: *Self, is_vblank: bool, value: u32) void {
self.y = @bitCast(i32, value); self.y = @bitCast(value);
if (!is_vblank) self.y_latch = @bitCast(i32, value); if (!is_vblank) self.y_latch = @bitCast(value);
} }
pub fn writePaPb(self: *Self, value: u32) void { pub fn writePaPb(self: *Self, value: u32) void {
self.pa = @bitCast(i16, @truncate(u16, value)); self.pa = @bitCast(@as(u16, @truncate(value)));
self.pb = @bitCast(i16, @truncate(u16, value >> 16)); self.pb = @bitCast(@as(u16, @truncate(value >> 16)));
} }
pub fn writePcPd(self: *Self, value: u32) void { pub fn writePcPd(self: *Self, value: u32) void {
self.pc = @bitCast(i16, @truncate(u16, value)); self.pc = @bitCast(@as(u16, @truncate(value)));
self.pd = @bitCast(i16, @truncate(u16, value >> 16)); self.pd = @bitCast(@as(u16, @truncate(value >> 16)));
} }
// Every Vblank BG?X/Y registers are latched // Every Vblank BG?X/Y registers are latched
@ -1447,9 +1447,9 @@ fn alphaBlend(top: u16, btm: u16, bldalpha: io.BldAlpha) u16 {
const btm_g = (btm >> 5) & 0x1F; const btm_g = (btm >> 5) & 0x1F;
const btm_b = (btm >> 10) & 0x1F; const btm_b = (btm >> 10) & 0x1F;
const bld_r = std.math.min(31, (top_r * eva + btm_r * evb) >> 4); const bld_r: u16 = @min(31, (top_r * eva + btm_r * evb) >> 4);
const bld_g = std.math.min(31, (top_g * eva + btm_g * evb) >> 4); const bld_g: u16 = @min(31, (top_g * eva + btm_g * evb) >> 4);
const bld_b = std.math.min(31, (top_b * eva + btm_b * evb) >> 4); const bld_b: u16 = @min(31, (top_b * eva + btm_b * evb) >> 4);
return (bld_b << 10) | (bld_g << 5) | bld_r; return (bld_b << 10) | (bld_g << 5) | bld_r;
} }

4
src/core/scheduler.zig
View File

@ -46,7 +46,7 @@ pub const Scheduler = struct {
const event = self.queue.remove(); const event = self.queue.remove();
const late = self.tick - event.tick; const late = self.tick - event.tick;
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
switch (event.kind) { switch (event.kind) {
.HeatDeath => { .HeatDeath => {
@ -75,7 +75,7 @@ pub const Scheduler = struct {
const device = &bus_ptr.pak.gpio.device; const device = &bus_ptr.pak.gpio.device;
if (device.kind != .Rtc or device.ptr == null) return; if (device.kind != .Rtc or device.ptr == null) return;
const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), device.ptr.?)); const clock: *Clock = @ptrCast(@alignCast(device.ptr.?));
clock.onClockUpdate(late); clock.onClockUpdate(late);
}, },
.FrameSequencer => bus_ptr.apu.onSequencerTick(late), .FrameSequencer => bus_ptr.apu.onSequencerTick(late),

30
src/imgui.zig
View File

@ -72,9 +72,9 @@ pub const State = struct {
pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi) bool { pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi) bool {
const scn_scale = config.config().host.win_scale; const scn_scale = config.config().host.win_scale;
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
zgui.backend.newFrame(@intToFloat(f32, win_dim.width), @intToFloat(f32, win_dim.height)); zgui.backend.newFrame(@floatFromInt(win_dim.width), @floatFromInt(win_dim.height));
{ {
_ = zgui.beginMainMenuBar(); _ = zgui.beginMainMenuBar();
@ -168,14 +168,14 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
} }
{ {
const w = @intToFloat(f32, gba_width * scn_scale); const w: f32 = @floatFromInt(gba_width * scn_scale);
const h = @intToFloat(f32, gba_height * scn_scale); const h: f32 = @floatFromInt(gba_height * scn_scale);
const window_title = std.mem.sliceTo(&state.title, 0); const window_title = std.mem.sliceTo(&state.title, 0);
_ = zgui.begin(window_title, .{ .flags = .{ .no_resize = true, .always_auto_resize = true } }); _ = zgui.begin(window_title, .{ .flags = .{ .no_resize = true, .always_auto_resize = true } });
defer zgui.end(); defer zgui.end();
zgui.image(@intToPtr(*anyopaque, tex_id), .{ .w = w, .h = h, .uv0 = .{ 0, 1 }, .uv1 = .{ 1, 0 } }); zgui.image(@ptrFromInt(tex_id), .{ .w = w, .h = h, .uv0 = .{ 0, 1 }, .uv1 = .{ 1, 0 } });
} }
// TODO: Any other steps to respect the copyright of the libraries I use? // TODO: Any other steps to respect the copyright of the libraries I use?
@ -272,8 +272,8 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
break :blk buf; break :blk buf;
}; };
const y_max = 2 * if (len != 0) @intToFloat(f64, sorted[len - 1]) else emu.frame_rate; const y_max: f64 = 2 * if (len != 0) @as(f64, @floatFromInt(sorted[len - 1])) else emu.frame_rate;
const x_max = @intToFloat(f64, values.len); const x_max: f64 = @floatFromInt(values.len);
const y_args = .{ .flags = .{ .no_grid_lines = true } }; const y_args = .{ .flags = .{ .no_grid_lines = true } };
const x_args = .{ .flags = .{ .no_grid_lines = true, .no_tick_labels = true, .no_tick_marks = true } }; const x_args = .{ .flags = .{ .no_grid_lines = true, .no_tick_labels = true, .no_tick_marks = true } };
@ -294,11 +294,11 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
const stats: struct { u32, u32, u32 } = blk: { const stats: struct { u32, u32, u32 } = blk: {
if (len == 0) break :blk .{ 0, 0, 0 }; if (len == 0) break :blk .{ 0, 0, 0 };
const average = average: { const average: u32 = average: {
var sum: u32 = 0; var sum: u32 = 0;
for (sorted[0..len]) |value| sum += value; for (sorted[0..len]) |value| sum += value;
break :average @intCast(u32, sum / len); break :average @intCast(sum / len);
}; };
const median = sorted[len / 2]; const median = sorted[len / 2];
const low = sorted[len / 100]; // 1% Low const low = sorted[len / 100]; // 1% Low
@ -320,7 +320,7 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
zgui.text("tick: {X:0>16}", .{scheduler.now()}); zgui.text("tick: {X:0>16}", .{scheduler.now()});
zgui.separator(); zgui.separator();
const sched_ptr = @ptrCast(*Scheduler, @alignCast(@alignOf(Scheduler), cpu.sched.ptr)); const sched_ptr: *Scheduler = @ptrCast(@alignCast(cpu.sched.ptr));
const Event = std.meta.Child(@TypeOf(sched_ptr.queue.items)); const Event = std.meta.Child(@TypeOf(sched_ptr.queue.items));
var items: [20]Event = undefined; var items: [20]Event = undefined;
@ -365,7 +365,7 @@ const widgets = struct {
}; };
for (0..0x100) |i| { for (0..0x100) |i| {
const offset = @truncate(u32, i); const offset: u32 = @truncate(i);
const bgr555 = cpu.bus.dbgRead(u16, address + offset * @sizeOf(u16)); const bgr555 = cpu.bus.dbgRead(u16, address + offset * @sizeOf(u16));
widgets.colourSquare(bgr555); widgets.colourSquare(bgr555);
@ -378,11 +378,11 @@ const widgets = struct {
// FIXME: working with the packed struct enum is currently broken :pensive: // FIXME: working with the packed struct enum is currently broken :pensive:
const ImguiColorEditFlags_NoInputs: u32 = 1 << 5; const ImguiColorEditFlags_NoInputs: u32 = 1 << 5;
const ImguiColorEditFlags_NoPicker: u32 = 1 << 2; const ImguiColorEditFlags_NoPicker: u32 = 1 << 2;
const flags = @bitCast(zgui.ColorEditFlags, ImguiColorEditFlags_NoInputs | ImguiColorEditFlags_NoPicker); const flags: zgui.ColorEditFlags = @bitCast(ImguiColorEditFlags_NoInputs | ImguiColorEditFlags_NoPicker);
const b = @intToFloat(f32, bgr555 >> 10 & 0x1f); const b: f32 = @floatFromInt(bgr555 >> 10 & 0x1f);
const g = @intToFloat(f32, bgr555 >> 5 & 0x1F); const g: f32 = @floatFromInt(bgr555 >> 5 & 0x1F);
const r = @intToFloat(f32, bgr555 & 0x1F); const r: f32 = @floatFromInt(bgr555 & 0x1F);
var col = [_]f32{ r / 31.0, g / 31.0, b / 31.0 }; var col = [_]f32{ r / 31.0, g / 31.0, b / 31.0 };

17
src/platform.zig
View File

@ -61,7 +61,7 @@ pub const Gui = struct {
if (SDL.SDL_GL_MakeCurrent(window, ctx) < 0) panic(); if (SDL.SDL_GL_MakeCurrent(window, ctx) < 0) panic();
gl.load(ctx, Self.glGetProcAddress) catch {}; gl.load(ctx, Self.glGetProcAddress) catch {};
if (SDL.SDL_GL_SetSwapInterval(@boolToInt(config.config().host.vsync)) < 0) panic(); if (SDL.SDL_GL_SetSwapInterval(@intFromBool(config.config().host.vsync)) < 0) panic();
zgui.init(allocator); zgui.init(allocator);
zgui.plot.init(); zgui.plot.init();
@ -108,7 +108,7 @@ pub const Gui = struct {
const tracker = opt.tracker; const tracker = opt.tracker;
const ch = opt.ch; const ch = opt.ch;
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr)); const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
const objects = opengl_impl.createObjects(); const objects = opengl_impl.createObjects();
defer gl.deleteBuffers(3, @as(*const [3]GLuint, &.{ objects.vao, objects.vbo, objects.ebo })); defer gl.deleteBuffers(3, @as(*const [3]GLuint, &.{ objects.vao, objects.vbo, objects.ebo }));
@ -183,8 +183,8 @@ pub const Gui = struct {
if (event.window.event == SDL.SDL_WINDOWEVENT_RESIZED) { if (event.window.event == SDL.SDL_WINDOWEVENT_RESIZED) {
log.debug("window resized to: {}x{}", .{ event.window.data1, event.window.data2 }); log.debug("window resized to: {}x{}", .{ event.window.data1, event.window.data2 });
win_dim.width = @intCast(u32, event.window.data1); win_dim.width = @intCast(event.window.data1);
win_dim.height = @intCast(u32, event.window.data2); win_dim.height = @intCast(event.window.data2);
} }
}, },
else => {}, else => {},
@ -268,7 +268,7 @@ pub const Gui = struct {
if (zgui_redraw) { if (zgui_redraw) {
// Background Colour // Background Colour
const size = zgui.io.getDisplaySize(); const size = zgui.io.getDisplaySize();
gl.viewport(0, 0, @floatToInt(GLsizei, size[0]), @floatToInt(GLsizei, size[1])); gl.viewport(0, 0, @intFromFloat(size[0]), @intFromFloat(size[1]));
gl.clearColor(0, 0, 0, 1.0); gl.clearColor(0, 0, 0, 1.0);
gl.clear(gl.COLOR_BUFFER_BIT); gl.clear(gl.COLOR_BUFFER_BIT);
@ -318,8 +318,7 @@ const Audio = struct {
} }
export fn callback(userdata: ?*anyopaque, stream: [*c]u8, len: c_int) void { export fn callback(userdata: ?*anyopaque, stream: [*c]u8, len: c_int) void {
const T = *Apu; const apu: *Apu = @ptrCast(@alignCast(userdata));
const apu = @ptrCast(T, @alignCast(@alignOf(T), userdata));
_ = SDL.SDL_AudioStreamGet(apu.stream, stream, len); _ = SDL.SDL_AudioStreamGet(apu.stream, stream, len);
} }
@ -422,10 +421,10 @@ const opengl_impl = struct {
gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), null); // lmao gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), null); // lmao
gl.enableVertexAttribArray(0); gl.enableVertexAttribArray(0);
// Colour // Colour
gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @intToPtr(?*anyopaque, (3 * @sizeOf(f32)))); gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @ptrFromInt((3 * @sizeOf(f32))));
gl.enableVertexAttribArray(1); gl.enableVertexAttribArray(1);
// Texture Coord // Texture Coord
gl.vertexAttribPointer(2, 2, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @intToPtr(?*anyopaque, (6 * @sizeOf(f32)))); gl.vertexAttribPointer(2, 2, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @ptrFromInt((6 * @sizeOf(f32))));
gl.enableVertexAttribArray(2); gl.enableVertexAttribArray(2);
return .{ .vao = vao_id, .vbo = vbo_id, .ebo = ebo_id }; return .{ .vao = vao_id, .vbo = vbo_id, .ebo = ebo_id };

6
src/util.zig
View File

@ -203,7 +203,7 @@ pub const audio = struct {
/// Sets a quarter (8) of the bits of the u32 `left` to the value of u8 `right` /// Sets a quarter (8) of the bits of the u32 `left` to the value of u8 `right`
pub inline fn setQuart(left: u32, addr: u8, right: u8) u32 { pub inline fn setQuart(left: u32, addr: u8, right: u8) u32 {
const offset = @truncate(u2, addr); const offset: u2 = @truncate(addr);
return switch (offset) { return switch (offset) {
0b00 => (left & 0xFFFF_FF00) | right, 0b00 => (left & 0xFFFF_FF00) | right,
@ -217,11 +217,11 @@ pub inline fn setQuart(left: u32, addr: u8, right: u8) u32 {
/// ///
/// TODO: Support u16 reads of u32 values? /// TODO: Support u16 reads of u32 values?
pub inline fn getHalf(byte: u8) u4 { pub inline fn getHalf(byte: u8) u4 {
return @truncate(u4, byte & 1) << 3; return @as(u4, @truncate(byte & 1)) << 3;
} }
pub inline fn setHalf(comptime T: type, left: T, addr: u8, right: HalfInt(T)) T { pub inline fn setHalf(comptime T: type, left: T, addr: u8, right: HalfInt(T)) T {
const offset = @truncate(u1, addr >> if (T == u32) 1 else 0); const offset: u1 = @truncate(addr >> if (T == u32) 1 else 0);
return switch (T) { return switch (T) {
u32 => switch (offset) { u32 => switch (offset) {