567 lines
17 KiB
Zig
567 lines
17 KiB
Zig
const std = @import("std");
|
|
const Allocator = std.mem.Allocator;
|
|
const log = std.log.scoped(.Backup);
|
|
|
|
const escape = @import("../../util.zig").escape;
|
|
const span = @import("../../util.zig").span;
|
|
|
|
const backup_kinds = [6]Needle{
|
|
.{ .str = "EEPROM_V", .kind = .Eeprom },
|
|
.{ .str = "SRAM_V", .kind = .Sram },
|
|
.{ .str = "SRAM_F_V", .kind = .Sram },
|
|
.{ .str = "FLASH_V", .kind = .Flash },
|
|
.{ .str = "FLASH512_V", .kind = .Flash },
|
|
.{ .str = "FLASH1M_V", .kind = .Flash1M },
|
|
};
|
|
|
|
pub const Backup = struct {
|
|
const Self = @This();
|
|
|
|
buf: []u8,
|
|
allocator: Allocator,
|
|
kind: Kind,
|
|
|
|
title: [12]u8,
|
|
save_path: ?[]const u8,
|
|
|
|
flash: Flash,
|
|
eeprom: Eeprom,
|
|
|
|
const Kind = enum {
|
|
Eeprom,
|
|
Sram,
|
|
Flash,
|
|
Flash1M,
|
|
None,
|
|
};
|
|
|
|
pub fn init(allocator: Allocator, kind: Kind, title: [12]u8, path: ?[]const u8) !Self {
|
|
log.info("Kind: {}", .{kind});
|
|
|
|
const buf_size: usize = switch (kind) {
|
|
.Sram => 0x8000, // 32K
|
|
.Flash => 0x10000, // 64K
|
|
.Flash1M => 0x20000, // 128K
|
|
.None, .Eeprom => 0, // EEPROM is handled upon first Read Request to it
|
|
};
|
|
|
|
const buf = try allocator.alloc(u8, buf_size);
|
|
std.mem.set(u8, buf, 0xFF);
|
|
|
|
var backup = Self{
|
|
.buf = buf,
|
|
.allocator = allocator,
|
|
.kind = kind,
|
|
.title = title,
|
|
.save_path = path,
|
|
.flash = Flash.init(),
|
|
.eeprom = Eeprom.init(allocator),
|
|
};
|
|
|
|
if (backup.save_path) |p| backup.loadSaveFromDisk(allocator, p) catch |e| log.err("Failed to load save: {}", .{e});
|
|
return backup;
|
|
}
|
|
|
|
pub fn guessKind(rom: []const u8) Kind {
|
|
for (backup_kinds) |needle| {
|
|
const needle_len = needle.str.len;
|
|
|
|
var i: usize = 0;
|
|
while ((i + needle_len) < rom.len) : (i += 1) {
|
|
if (std.mem.eql(u8, needle.str, rom[i..][0..needle_len])) return needle.kind;
|
|
}
|
|
}
|
|
|
|
return .None;
|
|
}
|
|
|
|
pub fn deinit(self: *Self) void {
|
|
if (self.save_path) |path| self.writeSaveToDisk(self.allocator, path) catch |e| log.err("Failed to write save: {}", .{e});
|
|
self.allocator.free(self.buf);
|
|
self.* = undefined;
|
|
}
|
|
|
|
fn loadSaveFromDisk(self: *Self, allocator: Allocator, path: []const u8) !void {
|
|
const file_path = try self.getSaveFilePath(allocator, path);
|
|
defer allocator.free(file_path);
|
|
|
|
// FIXME: Don't rely on this lol
|
|
if (std.mem.eql(u8, file_path[file_path.len - 12 .. file_path.len], "untitled.sav")) {
|
|
return log.err("ROM header lacks title, no save loaded", .{});
|
|
}
|
|
|
|
const file: std.fs.File = try std.fs.openFileAbsolute(file_path, .{});
|
|
const file_buf = try file.readToEndAlloc(allocator, try file.getEndPos());
|
|
defer allocator.free(file_buf);
|
|
|
|
switch (self.kind) {
|
|
.Sram, .Flash, .Flash1M => {
|
|
if (self.buf.len == file_buf.len) {
|
|
std.mem.copy(u8, self.buf, file_buf);
|
|
return log.info("Loaded Save from {s}", .{file_path});
|
|
}
|
|
|
|
log.err("{s} is {} bytes, but we expected {} bytes", .{ file_path, file_buf.len, self.buf.len });
|
|
},
|
|
.Eeprom => {
|
|
if (file_buf.len == 0x200 or file_buf.len == 0x2000) {
|
|
self.eeprom.kind = if (file_buf.len == 0x200) .Small else .Large;
|
|
|
|
self.buf = try allocator.alloc(u8, file_buf.len);
|
|
std.mem.copy(u8, self.buf, file_buf);
|
|
return log.info("Loaded Save from {s}", .{file_path});
|
|
}
|
|
|
|
log.err("EEPROM can either be 0x200 bytes or 0x2000 byes, but {s} was {X:} bytes", .{
|
|
file_path,
|
|
file_buf.len,
|
|
});
|
|
},
|
|
.None => return SaveError.UnsupportedBackupKind,
|
|
}
|
|
}
|
|
|
|
fn getSaveFilePath(self: *const Self, allocator: Allocator, path: []const u8) ![]const u8 {
|
|
const filename = try self.getSaveFilename(allocator);
|
|
defer allocator.free(filename);
|
|
|
|
return try std.fs.path.join(allocator, &[_][]const u8{ path, filename });
|
|
}
|
|
|
|
fn getSaveFilename(self: *const Self, allocator: Allocator) ![]const u8 {
|
|
const title_str = span(&escape(self.title));
|
|
const name = if (title_str.len != 0) title_str else "untitled";
|
|
|
|
return try std.mem.concat(allocator, u8, &[_][]const u8{ name, ".sav" });
|
|
}
|
|
|
|
fn writeSaveToDisk(self: Self, allocator: Allocator, path: []const u8) !void {
|
|
const file_path = try self.getSaveFilePath(allocator, path);
|
|
defer allocator.free(file_path);
|
|
|
|
switch (self.kind) {
|
|
.Sram, .Flash, .Flash1M, .Eeprom => {
|
|
const file = try std.fs.createFileAbsolute(file_path, .{});
|
|
defer file.close();
|
|
|
|
try file.writeAll(self.buf);
|
|
log.info("Wrote Save to {s}", .{file_path});
|
|
},
|
|
else => return SaveError.UnsupportedBackupKind,
|
|
}
|
|
}
|
|
|
|
pub fn read(self: *const Self, address: usize) u8 {
|
|
const addr = address & 0xFFFF;
|
|
|
|
switch (self.kind) {
|
|
.Flash => {
|
|
switch (addr) {
|
|
0x0000 => if (self.flash.id_mode) return 0x32, // Panasonic manufacturer ID
|
|
0x0001 => if (self.flash.id_mode) return 0x1B, // Panasonic device ID
|
|
else => {},
|
|
}
|
|
|
|
return self.flash.read(self.buf, addr);
|
|
},
|
|
.Flash1M => {
|
|
switch (addr) {
|
|
0x0000 => if (self.flash.id_mode) return 0x62, // Sanyo manufacturer ID
|
|
0x0001 => if (self.flash.id_mode) return 0x13, // Sanyo device ID
|
|
else => {},
|
|
}
|
|
|
|
return self.flash.read(self.buf, addr);
|
|
},
|
|
.Sram => return self.buf[addr & 0x7FFF], // 32K SRAM chip is mirrored
|
|
.None, .Eeprom => return 0xFF,
|
|
}
|
|
}
|
|
|
|
pub fn write(self: *Self, address: usize, byte: u8) void {
|
|
const addr = address & 0xFFFF;
|
|
|
|
switch (self.kind) {
|
|
.Flash, .Flash1M => {
|
|
if (self.flash.prep_write) return self.flash.write(self.buf, addr, byte);
|
|
if (self.flash.shouldEraseSector(addr, byte)) return self.flash.eraseSector(self.buf, addr);
|
|
|
|
switch (addr) {
|
|
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 => {},
|
|
}
|
|
},
|
|
.Sram => self.buf[addr & 0x7FFF] = byte,
|
|
.None, .Eeprom => {},
|
|
}
|
|
}
|
|
};
|
|
|
|
const Needle = struct {
|
|
const Self = @This();
|
|
|
|
str: []const u8,
|
|
kind: Backup.Kind,
|
|
|
|
fn init(str: []const u8, kind: Backup.Kind) Self {
|
|
return .{
|
|
.str = str,
|
|
.kind = kind,
|
|
};
|
|
}
|
|
};
|
|
|
|
const SaveError = error{
|
|
UnsupportedBackupKind,
|
|
};
|
|
|
|
const Flash = struct {
|
|
const Self = @This();
|
|
|
|
state: State,
|
|
|
|
id_mode: bool,
|
|
set_bank: bool,
|
|
prep_erase: bool,
|
|
prep_write: bool,
|
|
|
|
bank: u1,
|
|
|
|
const State = enum {
|
|
Ready,
|
|
Set,
|
|
Command,
|
|
};
|
|
|
|
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, addr: usize, byte: u8) bool {
|
|
return self.state == .Command and self.prep_erase and byte == 0x30 and addr & 0xFFF == 0x000;
|
|
}
|
|
|
|
fn write(self: *Self, buf: []u8, idx: usize, byte: u8) void {
|
|
buf[self.baseAddress() + idx] = byte;
|
|
self.prep_write = false;
|
|
}
|
|
|
|
fn read(self: *const Self, buf: []u8, idx: usize) u8 {
|
|
return buf[self.baseAddress() + idx];
|
|
}
|
|
|
|
fn eraseSector(self: *Self, buf: []u8, idx: usize) void {
|
|
const start = self.baseAddress() + (idx & 0xF000);
|
|
|
|
std.mem.set(u8, buf[start..][0..0x1000], 0xFF);
|
|
self.prep_erase = false;
|
|
self.state = .Ready;
|
|
}
|
|
|
|
inline fn baseAddress(self: *const Self) usize {
|
|
return if (self.bank == 1) 0x10000 else @as(usize, 0);
|
|
}
|
|
};
|
|
|
|
const Eeprom = struct {
|
|
const Self = @This();
|
|
|
|
addr: u14,
|
|
|
|
kind: Kind,
|
|
state: State,
|
|
writer: Writer,
|
|
reader: Reader,
|
|
|
|
allocator: Allocator,
|
|
|
|
const Kind = enum {
|
|
Unknown,
|
|
Small, // 512B
|
|
Large, // 8KB
|
|
};
|
|
|
|
const State = enum {
|
|
Ready,
|
|
Read,
|
|
Write,
|
|
WriteTransfer,
|
|
RequestEnd,
|
|
};
|
|
|
|
fn init(allocator: Allocator) Self {
|
|
return .{
|
|
.kind = .Unknown,
|
|
.state = .Ready,
|
|
.writer = Writer.init(),
|
|
.reader = Reader.init(),
|
|
.addr = 0,
|
|
.allocator = allocator,
|
|
};
|
|
}
|
|
|
|
pub fn read(self: *Self) u1 {
|
|
return self.reader.read();
|
|
}
|
|
|
|
pub fn dbgRead(self: *const Self) u1 {
|
|
return self.reader.dbgRead();
|
|
}
|
|
|
|
pub fn write(self: *Self, word_count: u16, buf: *[]u8, bit: u1) void {
|
|
if (self.guessKind(word_count)) |found| {
|
|
log.info("EEPROM Kind: {}", .{found});
|
|
self.kind = found;
|
|
|
|
// buf.len will not equal zero when a save file was found and loaded.
|
|
// Right now, we assume that the save file is of the correct size which
|
|
// isn't necessarily true, since we can't trust anything a user can influence
|
|
// TODO: use ?[]u8 instead of a 0-sized slice?
|
|
if (buf.len == 0) {
|
|
const len: usize = switch (found) {
|
|
.Small => 0x200,
|
|
.Large => 0x2000,
|
|
else => unreachable,
|
|
};
|
|
|
|
buf.* = self.allocator.alloc(u8, len) catch |e| {
|
|
log.err("Failed to resize EEPROM buf to {} bytes", .{len});
|
|
std.debug.panic("EEPROM entered irrecoverable state {}", .{e});
|
|
};
|
|
std.mem.set(u8, buf.*, 0xFF);
|
|
}
|
|
}
|
|
|
|
if (self.state == .RequestEnd) {
|
|
if (bit != 0) log.debug("EEPROM Request did not end in 0u1. TODO: is this ok?", .{});
|
|
self.state = .Ready;
|
|
return;
|
|
}
|
|
|
|
switch (self.state) {
|
|
.Ready => self.writer.requestWrite(bit),
|
|
.Read, .Write => self.writer.addressWrite(self.kind, bit),
|
|
.WriteTransfer => self.writer.dataWrite(bit),
|
|
.RequestEnd => unreachable, // We return early just above this block
|
|
}
|
|
|
|
self.tick(buf.*);
|
|
}
|
|
|
|
fn guessKind(self: *const Self, word_count: u16) ?Kind {
|
|
if (self.kind != .Unknown or self.state != .Read) return null;
|
|
|
|
return switch (word_count) {
|
|
17 => .Large,
|
|
9 => .Small,
|
|
else => blk: {
|
|
log.err("Unexpected length of DMA3 Transfer upon initial EEPROM read: {}", .{word_count});
|
|
break :blk null;
|
|
},
|
|
};
|
|
}
|
|
|
|
fn tick(self: *Self, buf: []u8) void {
|
|
switch (self.state) {
|
|
.Ready => {
|
|
if (self.writer.len() == 2) {
|
|
const req = @intCast(u2, self.writer.finish());
|
|
switch (req) {
|
|
0b11 => self.state = .Read,
|
|
0b10 => self.state = .Write,
|
|
else => log.err("Unknown EEPROM Request 0b{b:0>2}", .{req}),
|
|
}
|
|
}
|
|
},
|
|
.Read => {
|
|
switch (self.kind) {
|
|
.Large => {
|
|
if (self.writer.len() == 14) {
|
|
const addr = @intCast(u10, self.writer.finish());
|
|
const value = std.mem.readIntSliceLittle(u64, buf[@as(u13, addr) * 8 ..][0..8]);
|
|
|
|
self.reader.configure(value);
|
|
self.state = .RequestEnd;
|
|
}
|
|
},
|
|
.Small => {
|
|
if (self.writer.len() == 6) {
|
|
// FIXME: Duplicated code from above
|
|
const addr = @intCast(u6, self.writer.finish());
|
|
const value = std.mem.readIntSliceLittle(u64, buf[@as(u13, addr) * 8 ..][0..8]);
|
|
|
|
self.reader.configure(value);
|
|
self.state = .RequestEnd;
|
|
}
|
|
},
|
|
else => log.err("Unable to calculate EEPROM read address. EEPROM size UNKNOWN", .{}),
|
|
}
|
|
},
|
|
.Write => {
|
|
switch (self.kind) {
|
|
.Large => {
|
|
if (self.writer.len() == 14) {
|
|
self.addr = @intCast(u10, self.writer.finish());
|
|
self.state = .WriteTransfer;
|
|
}
|
|
},
|
|
.Small => {
|
|
if (self.writer.len() == 6) {
|
|
self.addr = @intCast(u6, self.writer.finish());
|
|
self.state = .WriteTransfer;
|
|
}
|
|
},
|
|
else => log.err("Unable to calculate EEPROM write address. EEPROM size UNKNOWN", .{}),
|
|
}
|
|
},
|
|
.WriteTransfer => {
|
|
if (self.writer.len() == 64) {
|
|
std.mem.writeIntSliceLittle(u64, buf[self.addr * 8 ..][0..8], self.writer.finish());
|
|
self.state = .RequestEnd;
|
|
}
|
|
},
|
|
.RequestEnd => unreachable, // We return early in write() if state is .RequestEnd
|
|
}
|
|
}
|
|
|
|
const Reader = struct {
|
|
const This = @This();
|
|
|
|
data: u64,
|
|
i: u8,
|
|
enabled: bool,
|
|
|
|
fn init() This {
|
|
return .{
|
|
.data = 0,
|
|
.i = 0,
|
|
.enabled = false,
|
|
};
|
|
}
|
|
|
|
fn configure(self: *This, value: u64) void {
|
|
self.data = value;
|
|
self.i = 0;
|
|
self.enabled = true;
|
|
}
|
|
|
|
fn read(self: *This) u1 {
|
|
if (!self.enabled) return 1;
|
|
|
|
const bit = if (self.i < 4) blk: {
|
|
break :blk 0;
|
|
} else blk: {
|
|
const idx = @intCast(u6, 63 - (self.i - 4));
|
|
break :blk @truncate(u1, self.data >> idx);
|
|
};
|
|
|
|
self.i = (self.i + 1) % (64 + 4);
|
|
if (self.i == 0) self.enabled = false;
|
|
|
|
return bit;
|
|
}
|
|
|
|
fn dbgRead(self: *const This) u1 {
|
|
if (!self.enabled) return 1;
|
|
|
|
const bit = if (self.i < 4) blk: {
|
|
break :blk 0;
|
|
} else blk: {
|
|
const idx = @intCast(u6, 63 - (self.i - 4));
|
|
break :blk @truncate(u1, self.data >> idx);
|
|
};
|
|
|
|
return bit;
|
|
}
|
|
};
|
|
|
|
const Writer = struct {
|
|
const This = @This();
|
|
|
|
data: u64,
|
|
i: u8,
|
|
|
|
fn init() This {
|
|
return .{ .data = 0, .i = 0 };
|
|
}
|
|
|
|
fn requestWrite(self: *This, bit: u1) void {
|
|
const idx = @intCast(u1, 1 - self.i);
|
|
self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
|
|
self.i += 1;
|
|
}
|
|
|
|
fn addressWrite(self: *This, kind: Eeprom.Kind, bit: u1) void {
|
|
if (kind == .Unknown) return;
|
|
|
|
const size: u4 = switch (kind) {
|
|
.Large => 13,
|
|
.Small => 5,
|
|
.Unknown => unreachable,
|
|
};
|
|
|
|
const idx = @intCast(u4, size - self.i);
|
|
self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
|
|
self.i += 1;
|
|
}
|
|
|
|
fn dataWrite(self: *This, bit: u1) void {
|
|
const idx = @intCast(u6, 63 - self.i);
|
|
self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
|
|
self.i += 1;
|
|
}
|
|
|
|
fn len(self: *const This) u8 {
|
|
return self.i;
|
|
}
|
|
|
|
fn finish(self: *This) u64 {
|
|
defer self.reset();
|
|
return self.data;
|
|
}
|
|
|
|
fn reset(self: *This) void {
|
|
self.i = 0;
|
|
self.data = 0;
|
|
}
|
|
};
|
|
};
|