feat: implement Flash backup cartrige kinds

This commit is contained in:
Rekai Nyangadzayi Musuka 2022-03-28 19:41:22 -03:00
parent bf7b533b3c
commit 29da7b294e
1 changed files with 123 additions and 19 deletions

View File

@ -23,6 +23,9 @@ pub const Backup = struct {
title: [12]u8, title: [12]u8,
save_path: ?[]const u8, save_path: ?[]const u8,
// TODO: Implement EEPROM
flash: Flash,
pub fn init(alloc: Allocator, kind: BackupKind, title: [12]u8, path: ?[]const u8) !Self { pub fn init(alloc: Allocator, kind: BackupKind, title: [12]u8, path: ?[]const u8) !Self {
const buf_len: usize = switch (kind) { const buf_len: usize = switch (kind) {
.Sram => 0x8000, // 32K .Sram => 0x8000, // 32K
@ -40,15 +43,14 @@ pub const Backup = struct {
.kind = kind, .kind = kind,
.title = title, .title = title,
.save_path = path, .save_path = path,
.flash = Flash.init(),
}; };
if (backup.save_path) |p| backup.loadSaveFromDisk(p) catch |e| log.err("Failed to load save: {}", .{e});
if (backup.save_path) |p| backup.loadSaveFromDisk(p) catch |e| log.err("Failed to load save: {}", .{e});
return backup; return backup;
} }
pub fn guessKind(rom: []const u8) ?BackupKind { pub fn guessKind(rom: []const u8) ?BackupKind {
@setRuntimeSafety(false);
for (backup_kinds) |needle| { for (backup_kinds) |needle| {
const needle_len = needle.str.len; const needle_len = needle.str.len;
@ -63,7 +65,6 @@ pub const Backup = struct {
pub fn deinit(self: Self) void { pub fn deinit(self: Self) void {
if (self.save_path) |path| self.writeSaveToDisk(path) catch |e| log.err("Failed to write save: {}", .{e}); if (self.save_path) |path| self.writeSaveToDisk(path) catch |e| log.err("Failed to write save: {}", .{e});
self.alloc.free(self.buf); self.alloc.free(self.buf);
} }
@ -78,7 +79,7 @@ pub const Backup = struct {
defer self.alloc.free(file_buf); defer self.alloc.free(file_buf);
switch (self.kind) { switch (self.kind) {
.Sram => { .Sram, .Flash, .Flash1M => {
std.mem.copy(u8, self.buf, file_buf); std.mem.copy(u8, self.buf, file_buf);
log.info("Loaded Save from {s}", .{file_path}); log.info("Loaded Save from {s}", .{file_path});
}, },
@ -103,37 +104,70 @@ pub const Backup = struct {
defer self.alloc.free(file_path); defer self.alloc.free(file_path);
switch (self.kind) { switch (self.kind) {
.Sram => { .Sram, .Flash, .Flash1M => {
const file = try std.fs.createFileAbsolute(file_path, .{}); const file = try std.fs.createFileAbsolute(file_path, .{});
defer file.close(); defer file.close();
try file.writeAll(self.buf); try file.writeAll(self.buf);
log.info("Dumped SRAM to {s}", .{file_path}); log.info("Wrote Save to {s}", .{file_path});
}, },
else => return SaveError.UnsupportedBackupKind, else => return SaveError.UnsupportedBackupKind,
} }
} }
pub fn get8(self: *const Self, idx: usize) u8 { pub fn get8(self: *const Self, idx: usize) u8 {
// TODO: Implement Flash and EEPROM
switch (self.kind) { switch (self.kind) {
.Flash => return switch (idx) { .Flash => {
0x0000 => 0x32, // Panasonic manufacturer ID switch (idx) {
0x0001 => 0x1B, // Panasonic device ID 0x0000 => if (self.flash.id_mode) return 0x32, // Panasonic manufacturer ID
else => self.buf[idx], 0x0001 => if (self.flash.id_mode) return 0x1B, // Panasonic device ID
else => {},
}
return self.flash.read(self.buf, idx);
}, },
.Flash1M => return switch (idx) { .Flash1M => {
0x0000 => 0x62, // Sanyo manufacturer ID switch (idx) {
0x0001 => 0x13, // Sanyo device ID 0x0000 => if (self.flash.id_mode) return 0x62, // Sanyo manufacturer ID
else => self.buf[idx], 0x0001 => if (self.flash.id_mode) return 0x13, // Sanyo device ID
else => {},
}
return self.flash.read(self.buf, idx);
}, },
.Eeprom => return self.buf[idx], .Eeprom => return self.buf[idx],
.Sram => return self.buf[idx & 0x7FFF], // 32K SRAM chips are repeated .Sram => return self.buf[idx & 0x7FFF], // 32K SRAM chip is mirrored
} }
} }
pub fn set8(self: *Self, idx: usize, byte: u8) void { pub fn set8(self: *Self, idx: usize, byte: u8) void {
self.buf[idx] = byte; switch (self.kind) {
.Flash, .Flash1M => {
if (self.flash.prep_write) return self.flash.write(self.buf, idx, byte);
if (self.flash.shouldEraseSector(idx, byte)) return self.flash.eraseSector(self.buf, idx);
switch (idx) {
0x0000 => if (self.kind == .Flash1M and self.flash.set_bank) {
self.flash.bank = @truncate(u1, byte);
},
0x5555 => {
if (self.flash.state == .Command) {
self.flash.handleCommand(self.buf, byte);
} else if (byte == 0xAA and self.flash.state == .Ready) {
self.flash.state = .Set;
} else if (byte == 0xF0) {
self.flash.state = .Ready;
}
},
0x2AAA => if (byte == 0x55 and self.flash.state == .Set) {
self.flash.state = .Command;
},
else => {},
}
},
.Eeprom => self.buf[idx] = byte,
.Sram => self.buf[idx & 0x7FFF] = byte,
}
} }
}; };
@ -145,10 +179,12 @@ const BackupKind = enum {
}; };
const Needle = struct { const Needle = struct {
const Self = @This();
str: []const u8, str: []const u8,
kind: BackupKind, kind: BackupKind,
fn init(str: []const u8, kind: BackupKind) @This() { fn init(str: []const u8, kind: BackupKind) Self {
return .{ return .{
.str = str, .str = str,
.kind = kind, .kind = kind,
@ -159,3 +195,71 @@ const Needle = struct {
const SaveError = error{ const SaveError = error{
UnsupportedBackupKind, UnsupportedBackupKind,
}; };
const Flash = struct {
const Self = @This();
state: FlashState,
id_mode: bool,
set_bank: bool,
prep_erase: bool,
prep_write: bool,
bank: u1,
fn init() Self {
return .{
.state = .Ready,
.id_mode = false,
.set_bank = false,
.prep_erase = false,
.prep_write = false,
.bank = 0,
};
}
fn handleCommand(self: *Self, buf: []u8, byte: u8) void {
switch (byte) {
0x90 => self.id_mode = true,
0xF0 => self.id_mode = false,
0xB0 => self.set_bank = true,
0x80 => self.prep_erase = true,
0x10 => {
std.mem.set(u8, buf, 0xFF);
self.prep_erase = false;
},
0xA0 => self.prep_write = true,
else => std.debug.panic("Unhandled Flash Command: 0x{X:0>2}", .{byte}),
}
self.state = .Ready;
}
fn shouldEraseSector(self: *const Self, idx: usize, byte: u8) bool {
return self.prep_erase and idx & 0xFFF == 0x000 and byte == 0x30;
}
fn write(self: *Self, buf: []u8, idx: usize, byte: u8) void {
buf[idx + if (self.bank == 1) 0x1000 else @as(usize, 0)] = byte;
self.prep_write = false;
}
fn read(self: *const Self, buf: []u8, idx: usize) u8 {
return buf[idx + if (self.bank == 1) 0x1000 else @as(usize, 0)];
}
fn eraseSector(self: *Self, buf: []u8, idx: usize) void {
const start = (idx & 0xF000) + if (self.bank == 1) 0x1000 else @as(usize, 0);
std.mem.set(u8, buf[start..][0..0x1000], 0xFF);
self.prep_erase = false;
self.state = .Ready;
}
};
const FlashState = enum {
Ready,
Set,
Command,
};