Zorchenhimer
/
INL-retro-progdump
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: Zorchenhimer:master
Branches Tags
Zorchenhimer:master
Zorchenhimer:upstream
..
compare: Zorchenhimer:upstream
Branches Tags
Zorchenhimer:master
Zorchenhimer:upstream

No commits in common. "master" and "upstream" have entirely different histories.
master ... upstream

4 changed files with 0 additions and 1253 deletions
Show Stats Expand all files Collapse all files

1
host/scripts/inlretro2.lua
View File

@ -83,7 +83,6 @@ function nes_exec(process_opts, console_opts)
unrom = require "scripts.nes.unrom",
unrom_tsop = require "scripts.nes.unrom_tsop",
gtrom = require "scripts.nes.gtrom",
nina = require "scripts.nes.nina",
}
--dict.io("IO_RESET")

531
host/scripts/nes/nina.lua
View File

@ -1,531 +0,0 @@
-- create the module's table
local nina = {}
-- import required modules
local dict = require "scripts.app.dict"
local nes = require "scripts.app.nes"
local dump = require "scripts.app.dump"
local swim = require "scripts.app.swim"
local ciccom = require "scripts.app.ciccom"
local buffers = require "scripts.app.buffers"
-- file constants
local mapname = "NINA"
-- local functions
local function create_header( file, prgKB, chrKB )
local mirroring = nes.detect_mapper_mirroring()
--write_header( file, prgKB, chrKB, mapper, mirroring )
nes.write_header( file, prgKB, chrKB, op_buffer[mapname], mirroring)
end
--read PRG-ROM flash ID
local function prgrom_manf_id( debug )
--init_mapper()
if debug then print("reading PRG-ROM manf ID") end
--enter software mode
--ROMSEL controls PRG-ROM /OE which needs to be low for flash writes
--So unlock commands need to be addressed below $8000
--DISCRETE_EXP0_PRGROM_WR doesn't toggle /ROMSEL by definition though, so A15 is unused
-- 15 14 13 12
-- 0x5 = 0b 0 1 0 1 -> $5555
-- 0x2 = 0b 0 0 1 0 -> $2AAA
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x5555, 0xAA)
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x2AAA, 0x55)
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x5555, 0x90)
--read manf ID
local rv = dict.nes("NES_CPU_RD", 0x8000)
if debug then print("attempted read PRG-ROM manf ID:", string.format("%X", rv)) end
--read prod ID
rv = dict.nes("NES_CPU_RD", 0x8001)
if debug then print("attempted read PRG-ROM prod ID:", string.format("%X", rv)) end
--exit software
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x8000, 0xF0)
--verify exited
-- rv = dict.nes("NES_CPU_RD", 0x8001)
-- if debug then print("attempted read PRG-ROM prod ID:", string.format("%X", rv)) end
end
--read CHR-ROM flash ID
local function chrrom_manf_id( debug )
--init_mapper()
if debug then print("reading CHR-ROM manf ID") end
--enter software mode
--NROM has A13 tied to A11, and A14 tied to A12.
--So only A0-12 needs to be valid
--A13 needs to be low to address CHR-ROM
-- 15 14 13 12
-- 0x5 = 0b 0 1 0 1 -> $1555
-- 0x2 = 0b 0 0 1 0 -> $0AAA
dict.nes("NES_PPU_WR", 0x1555, 0xAA)
dict.nes("NES_PPU_WR", 0x0AAA, 0x55)
dict.nes("NES_PPU_WR", 0x1555, 0x90)
--read manf ID
local rv = dict.nes("NES_PPU_RD", 0x0000)
if debug then print("attempted read CHR-ROM manf ID:", string.format("%X", rv)) end
--read prod ID
rv = dict.nes("NES_PPU_RD", 0x0001)
if debug then print("attempted read CHR-ROM prod ID:", string.format("%X", rv)) end
--exit software
dict.nes("NES_PPU_WR", 0x0000, 0xF0)
end
--dump the PRG ROM
local function dump_prgrom( file, rom_size_KB, debug )
--file = io.open("prg.dat", "wb")
for i = 0x00,0x01,1 do
--print(string.format("$4201: %02X", i))
dict.nes("NES_CPU_WR", 0x7FFD, i)
start_addr = 0x8000
stop_addr = 0xFFFF
while (start_addr <= stop_addr) do
rv = dict.nes("NES_CPU_RD", start_addr)
file:write(string.char(rv))
start_addr = start_addr + 1
end
--sb_ram_dump(0x8000, 0xC000, string.format("raw/prg_8000_%02X.dat", i))
end
--file:flush()
--file:close()
--local KB_per_read = 32
---- Handle 16KB nroms.
--if rom_size_KB < KB_per_read then KB_per_read = rom_size_KB end
--local num_reads = rom_size_KB / KB_per_read
--local read_count = 0
--local addr_base = 0x08 -- $8000
--while ( read_count < num_reads ) do
-- if debug then print( "dump PRG part ", read_count, " of ", num_reads) end
-- dump.dumptofile( file, KB_per_read, addr_base, "NESCPU_4KB", false )
-- read_count = read_count + 1
--end
end
--dump the CHR ROM
local function dump_chrrom( file, rom_size_KB, debug )
--CHR-ROM dump all 8KB, most of this code is overkill for NROM.
-- but follows same format as banked mappers
local KB_per_read = 4
local num_reads = rom_size_KB / KB_per_read
local read_count = 0
local addr_base = 0x00 -- $0000
while ( read_count < num_reads ) do
--if debug then print( "dump CHR part ", read_count, " of ", num_reads) end
dict.nes("NES_CPU_WR", 0x7FFE, read_count)
for i = 0x0000,0x0FFF,1 do
val = dict.nes("NES_PPU_RD", i)
file:write(string.char(val))
end
--dump.dumptofile( file, KB_per_read, addr_base, "NESPPU_1KB", false )
read_count = read_count + 1
end
--Zorchenhimer had issues dumping "Popeye no Eigo Asobi" http://bootgod.dyndns.org:7777/profile.php?id=3867
--which appears to have 2 transistors with connections to PPU A12 and CHR-ROM /OE.?
--not sure what's going on there, but slowly dumping one byte at at time instead of 128Byte read bursts
--with normal dumping method above corrected the issue.
--[[
for i = 0x0000,0x1FFF,1 do
val = dict.nes("NES_PPU_RD", i)
file:write(string.char(val))
end
file:flush()
--]]
end
--write a single byte to PRG-ROM flash
local function wr_prg_flash_byte(addr, value, debug)
if (addr < 0x8000 or addr > 0xFFFF) then
print("\n ERROR! flash write to PRG-ROM", string.format("$%X", addr), "must be $8000-FFFF \n\n")
return
end
--send unlock command and write byte
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x5555, 0xAA)
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x2AAA, 0x55)
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x5555, 0xA0)
dict.nes("DISCRETE_EXP0_PRGROM_WR", addr, value)
local rv = dict.nes("NES_CPU_RD", addr)
local i = 0
while ( rv ~= value ) do
rv = dict.nes("NES_CPU_RD", addr)
i = i + 1
end
if debug then print(i, "naks, done writing byte.") end
--TODO handle timeout for problems
--TODO return pass/fail/info
end
--write a single byte to CHR-ROM flash
--PRE: assumes mapper is initialized and bank is selected as prescribed in mapper_init
--REQ: addr must be in the first 2 banks $0000-0FFF
--local function wr_chr_flash_byte(addr, value, debug)
--
-- if (addr < 0x0000 or addr > 0x1FFF) then
-- print("\n ERROR! flash write to CHR-ROM", string.format("$%X", addr), "must be $0000-1FFF \n\n")
-- return
-- end
--
-- --send unlock command and write byte
-- dict.nes("NES_PPU_WR", 0x1555, 0xAA)
-- dict.nes("NES_PPU_WR", 0x0AAA, 0x55)
-- dict.nes("NES_PPU_WR", 0x1555, 0xA0)
-- dict.nes("NES_PPU_WR", addr, value)
--
-- local rv = dict.nes("NES_PPU_RD", addr)
--
-- local i = 0
--
-- while ( rv ~= value ) do
-- rv = dict.nes("NES_PPU_RD", addr)
-- i = i + 1
-- end
-- if debug then print(i, "naks, done writing byte.") end
--
-- --TODO handle timeout for problems
--
-- --TODO return pass/fail/info
--end
--fast host flash one bank at a time...
--this is controlled from the host side one bank at a time
--but requires specific firmware MMC3 flashing functions
--there is super slow version commented out that doesn't require MMC3 specific firmware code
local function flash_prgrom(file, rom_size_KB, debug)
--init_mapper()
--test some bytes
--wr_prg_flash_byte(0x8000, 0xA5, true)
--wr_prg_flash_byte(0xFFFF, 0x5A, true)
print("\nProgramming PRG-ROM flash")
--most of this is overkill for NROM, but it's how we want to handle things for bigger mappers
local base_addr = 0x8000 --writes occur $8000-9FFF
local bank_size = 32*1024 --MMC3 8KByte per PRG bank
local buff_size = 1 --number of bytes to write at a time
local cur_bank = 0
local total_banks = rom_size_KB*1024/bank_size
local byte_num --byte number gets reset for each bank
local byte_str, data, readdata
while cur_bank < total_banks do
if (cur_bank %8 == 0) then
print("writting PRG bank: ", cur_bank, " of ", total_banks-1)
end
--program the entire bank's worth of data
flash.write_file( file, 32, mapname, "PRGROM", false )
cur_bank = cur_bank + 1
end
print("Done Programming PRG-ROM flash")
end
--slow host flash one byte at a time...
--this is controlled from the host side byte by byte making it slow
--but doesn't require specific firmware MMC3 flashing functions
--local function flash_chrrom(file, rom_size_KB, debug)
--
-- --init_mapper()
--
-- --test some bytes
-- --wr_chr_flash_byte(0x0000, 0xC3, true)
-- --wr_chr_flash_byte(0x1FFF, 0x3C, true)
--
-- print("\nProgramming CHR-ROM flash")
-- --most of this is overkill for NROM, but it's how we want to handle things for bigger mappers
--
-- local base_addr = 0x0000
-- local bank_size = 8*1024
-- local buff_size = 1 --number of bytes to write at a time
-- local cur_bank = 0
-- local total_banks = rom_size_KB*1024/bank_size
--
-- local byte_num --byte number gets reset for each bank
-- local byte_str, data, readdata
--
-- while cur_bank < total_banks do
--
-- if (cur_bank %8 == 0) then
-- print("writting CHR bank: ", cur_bank, " of ", total_banks-1)
-- end
--
-- --program the entire bank's worth of data
-- flash.write_file( file, 8, mapname, "CHRROM", false )
--
-- cur_bank = cur_bank + 1
-- end
--
-- print("Done Programming CHR-ROM flash")
--end
--Cart should be in reset state upon calling this function
--this function processes all user requests for this specific board/mapper
local function process(process_opts, console_opts)
--local test = process_opts["test"]
local read = process_opts["read"]
--local erase = process_opts["erase"]
local program = process_opts["program"]
local verify = process_opts["verify"]
local dumpfile = process_opts["dump_filename"]
--local flashfile = process_opts["flash_filename"]
local verifyfile = process_opts["verify_filename"]
local rv = nil
local file
local prg_size = console_opts["prg_rom_size_kb"]
local chr_size = console_opts["chr_rom_size_kb"]
local wram_size = console_opts["wram_size_kb"]
--local mirror = console_opts["mirror"]
local filetype = "nes"
--local filetype = "bin"
--initialize device i/o for NES
dict.io("IO_RESET")
dict.io("NES_INIT")
--test the cart
-- if test then
-- print("Testing ", mapname)
--
-- nes.detect_mapper_mirroring(true)
-- print("EXP0 pull-up test:", dict.io("EXP0_PULLUP_TEST"))
--
-- -- dict.io("SWIM_INIT", "SWIM_ON_A0")
-- -- if swim.start(true) then
--
-- -- swim.read_stack()
--
-- -- else
-- -- print("ERROR trying to read back CIC signature stack data")
-- -- end
-- -- swim.stop_and_reset()
--
-- --nes.read_flashID_prgrom_exp0(true)
-- prgrom_manf_id(true)
-- --nes.read_flashID_chrrom_8K(true)
-- chrrom_manf_id(true)
--
-- end
--change mirroring
-- if mirror then
-- --mirror set to "H" of "V" for desired mirroring
-- print("Setting", mirror, "mirroring via CIC software mirror control")
-- nes.detect_mapper_mirroring(true)
--
-- ciccom.start()
-- ciccom.set_opcode("M")
-- --now send operand "V" (0x56) or "H" (0x48)
-- ciccom.write(mirror)
--
-- dict.io("IO_RESET")
-- ciccom.sleep(0.01) --10msec to be overly safe
--
-- --test reading back CIC version
-- dict.io("SWIM_INIT", "SWIM_ON_A0")
-- --dict.io("SWIM_INIT", "SWIM_ON_EXP0")
-- if swim.start(true) then
--
-- swim.read_stack()
--
-- else
-- print("ERROR trying to read back CIC signature stack data")
-- end
-- swim.stop_and_reset()
--
-- print("done reading STM8 stack on A0\n")
--
-- dict.io("IO_RESET")
-- dict.io("NES_INIT")
-- nes.detect_mapper_mirroring(true)
-- end
--dump the cart to dumpfile
if read then
print("\nDumping PRG & CHR ROMs...")
--init_mapper()
file = assert(io.open(dumpfile, "wb"))
--create header: pass open & empty file & rom sizes
create_header(file, prg_size, chr_size)
--dump cart into file
dump_prgrom(file, prg_size, false)
dump_chrrom(file, chr_size, false)
--close file
assert(file:close())
print("DONE Dumping PRG & CHR ROMs")
end
--erase the cart
if erase then
print("\nErasing ", mapname);
--init_mapper()
print("erasing PRG-ROM");
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x5555, 0xAA)
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x2AAA, 0x55)
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x5555, 0x80)
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x5555, 0xAA)
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x2AAA, 0x55)
dict.nes("DISCRETE_EXP0_PRGROM_WR", 0x5555, 0x10)
rv = dict.nes("NES_CPU_RD", 0x8000)
local i = 0
--TODO create some function to pass the read value
--that's smart enough to figure out if the board is actually erasing or not
while ( rv ~= 0xFF ) do
rv = dict.nes("NES_CPU_RD", 0x8000)
i = i + 1
end
print(i, "naks, done erasing prg.");
print("erasing CHR-ROM");
dict.nes("NES_PPU_WR", 0x1555, 0xAA)
dict.nes("NES_PPU_WR", 0x0AAA, 0x55)
dict.nes("NES_PPU_WR", 0x1555, 0x80)
dict.nes("NES_PPU_WR", 0x1555, 0xAA)
dict.nes("NES_PPU_WR", 0x0AAA, 0x55)
dict.nes("NES_PPU_WR", 0x1555, 0x10)
rv = dict.nes("NES_PPU_RD", 0x0000)
i = 0
while ( rv ~= 0xFF ) do
rv = dict.nes("NES_PPU_RD", 0x0000)
i = i + 1
end
print(i, "naks, done erasing chr.\n");
end
--program flashfile to the cart
if program then
--open file
file = assert(io.open(flashfile, "rb"))
--determine if auto-doubling, deinterleaving, etc,
--needs done to make board compatible with rom
if filetype == "nes" then
--advance past the 16byte header
--TODO set mirroring bit via ciccom
local buffsize = 1
local byte
local count = 1
for byte in file:lines(buffsize) do
local data = string.unpack("B", byte, 1)
--print(string.format("%X", data))
count = count + 1
if count == 17 then break end
end
end
--flash cart
--flash.write_file( file, 32, "NROM", "PRGROM", true )
--flash.write_file( file, 8, "NROM", "CHRROM", true )
flash_prgrom(file, prg_size, true)
flash_chrrom(file, chr_size, true)
--close file
assert(file:close())
end
--verify flashfile is on the cart
if verify then
--for now let's just dump the file and verify manually
print("\nPost dumping PRG & CHR ROMs...")
--init_mapper()
file = assert(io.open(verifyfile, "wb"))
--dump cart into file
dump_prgrom(file, prg_size, false)
dump_chrrom(file, chr_size, false)
--close file
assert(file:close())
print("DONE post dumping PRG & CHR ROMs")
end
dict.io("IO_RESET")
end
-- global variables so other modules can use them
-- call functions desired to run when script is called/imported
-- functions other modules are able to call
nina.process = process
-- return the module's table
return nina

720
host/scripts/nes/studybox.lua
View File

@ -1,720 +0,0 @@
math.randomseed(os.time())
-- create the module's table
local studybox = {}
-- import required modules
local nes = require "scripts.app.nes"
local dict = require "scripts.app.dict"
local dump = require "scripts.app.dump"
local flash = require "scripts.app.flash"
local buffers = require "scripts.app.buffers"
-- file constants
local mapname = "SBX"
-- local functions
local function create_header( file, prgKB, chrKB )
--write_header( file, prgKB, chrKB, mapper, mirroring )
nes.write_header( file, prgKB, 0, op_buffer[mapname], 0)
end
--local function wr_flash_byte(addr, value, debug)
--base is the actual NES CPU address, not the rom offset (ie $FFF0, not $7FF0)
--local function wr_bank_table(base, entries)
--Action53 not susceptible to bus conflicts, no banktable needed
local function sb_write_string(start_addr, value, log)
value = string.format("'%s' starting at $%04X", value, start_addr)
print(string.format("Writing %s starting at address $%04X\n", value, start_addr))
for i = 1, #value do
local c = value:sub(i,i)
dict.nes("NES_CPU_WR", start_addr + (i - 1), string.byte(c))
end
end
local function sb_write_and_verify(start_addr, stop_addr, value, log)
log:write(string.format("Writing $%X from address $%X to $%X\n", value, start_addr, stop_addr))
addr = start_addr
while (addr < stop_addr) do
dict.nes("NES_CPU_WR", addr, value)
addr = addr + 1
end
log:write("Verifying data\n")
addr = start_addr
while(addr < stop_addr) do
rv = dict.nes("NES_CPU_RD", addr)
if rv ~= value then
log:write(string.format("$%X not $%X\n", addr, value))
end
addr = addr + 1
end
end
-- Write and verify random values in RAM
local function sb_random_ram(start_addr, stop_addr, log)
log:write(string.format("\nStarting random ram test from address $%04X to address $%04X\n", start_addr, stop_addr))
values = {}
for i = 0, (stop_addr - start_addr) do
val = math.random(0, 255)
values[i] = val
dict.nes("NES_CPU_WR", start_addr + i, val)
end
for i = 0, (stop_addr - start_addr) do
rv = dict.nes("NES_CPU_RD", start_addr + i)
if rv ~= values[i] then
log:write(string.format("$%04X: expected $%02X received $%02X\n", start_addr + i, values[i], rv))
end
end
end
local function sb_write_ram(start_addr, stop_addr, value)
print(string.format("Writing $%02X from $%04X to $%04X", value, start_addr, stop_addr))
while (start_addr < stop_addr) do
dict.nes("NES_CPU_WR", start_addr, value)
start_addr = start_addr + 1
end
end
local function sb_verify_value_ram(start_addr, stop_addr, value, log)
print(string.format("Verifying $%02X from $%04X to $%04X", value, start_addr, stop_addr))
while (start_addr < stop_addr) do
rv = dict.nes("NES_CPU_RD", start_addr)
if rv ~= value then
log:write(string.format("$%04X: expected $%02X received $%02X\n", start_addr, value, rv))
end
start_addr = start_addr + 1
end
end
local function sb_ram_dump(start_addr, stop_addr, filename)
file = io.open(filename, "wb")
while (start_addr < stop_addr) do
rv = dict.nes("NES_CPU_RD", start_addr)
file:write(string.char(rv))
start_addr = start_addr + 1
end
file:flush()
file:close()
end
-- Write data to ram and read it back
local function sb_verify_ram()
logfile = io.open("studybox.log", "w")
print("Starting sb_verify_ram()")
--print("Write/Verify $00")
--sb_write_and_verify(0x4020, 0x8000, 0x00, logfile)
--print("Write/Verify $88")
--sb_write_and_verify(0x4020, 0x8000, 0x88, logfile)
--print("Write/Verify $FF")
--sb_write_and_verify(0x4020, 0x8000, 0xFF, logfile)
--print("Write/Verify random")
--sb_random_ram(0x4020, 0x8000, logfile)
-- Select first bank
--sprint("\n$4200 value of $00")
--dict.nes("NES_CPU_WR", 0x4200, 0x00)
--val = math.random(0, 255)
--sb_write_ram(0x5000, 0x5FFF, val)
--sb_verify_value_ram(0x4400, 0x8000, val, logfile)
--sprint("\n$4200 value of $01")
--sdict.nes("NES_CPU_WR", 0x4200, 0x01)
--sval = math.random(0, 255)
--ssb_write_ram(0x5000, 0x5FFF, val)
--ssb_verify_value_ram(0x4400, 0x8000, val, logfile)
--sprint("\n$4200 value of $00 verify")
--sdict.nes("NES_CPU_WR", 0x4200, 0x00)
--ssb_verify_value_ram(0x4400, 0x5FFF, val, logfile)
--print("\n$4200 value of $00")
--dict.nes("NES_CPU_WR", 0x4200, 0x00)
--val = math.random(0, 255)
--sb_write_ram(0x6000, 0x8000, val)
--sb_verify_value_ram(0x6000, 0x8000, val, logfile)
--logfile:write("\n==== Second verify with $4200 value $40 ====\n")
--print("\n$4200 value of $40")
--dict.nes("NES_CPU_WR", 0x4200, 0x40)
--sb_verify_value_ram(0x6000, 0x8000, val, logfile)
print("Clearing ram")
sb_write_ram(0x4400, 0x8000, 0x00)
--41 b01000001
--82 b10000010
--82 b11000011
dict.nes("NES_CPU_WR", 0x4200, 0x41)
sb_write_ram(0x4400, 0x8000, 0x00)
dict.nes("NES_CPU_WR", 0x4200, 0x82)
sb_write_ram(0x4400, 0x8000, 0x00)
dict.nes("NES_CPU_WR", 0x4200, 0xC3)
sb_write_ram(0x4400, 0x8000, 0x00)
print("Writing strings")
dict.nes("NES_CPU_WR", 0x4200, 0x00)
sb_write_string(0x5400, "|< page $00 >|")
sb_write_string(0x6000, "|< page $00 >|")
dict.nes("NES_CPU_WR", 0x4200, 0x41)
sb_write_string(0x5000, "|< page $01 >|")
sb_write_string(0x6000, "|< page $01 >|")
dict.nes("NES_CPU_WR", 0x4200, 0x82)
sb_write_string(0x5000, "|< page $02 >|")
sb_write_string(0x6000, "|< page $02 >|")
dict.nes("NES_CPU_WR", 0x4200, 0xC3)
sb_write_string(0x5000, "|< page $03 >|")
sb_write_string(0x6000, "|< page $03 >|")
--sb_write_string(0x5000, "|< page $00 at $5000 >|")
print("dumping 4200_00.dmp")
dict.nes("NES_CPU_WR", 0x4200, 0x00)
sb_ram_dump(0x4400, 0x8000, "4200_00.dmp")
print("dumping 4200_01.dmp")
dict.nes("NES_CPU_WR", 0x4200, 0x01)
sb_ram_dump(0x4400, 0x8000, "4200_01.dmp")
print("dumping 4200_01.dmp")
dict.nes("NES_CPU_WR", 0x4200, 0x01)
sb_ram_dump(0x4400, 0x8000, "4200_01.dmp")
--print("\n$4200 value of $01")
--dict.nes("NES_CPU_WR", 0x4200, 0x01)
--sb_ram_dump(0x4400, 0x8000, "4200_01.dmp")
--print("\n$4200 value of $02")
--dict.nes("NES_CPU_WR", 0x4200, 0x02)
--sb_ram_dump(0x4400, 0x8000, "4200_02.dmp")
--print("\n$4200 value of $03")
--dict.nes("NES_CPU_WR", 0x4200, 0x03)
--sb_ram_dump(0x4400, 0x8000, "4200_03.dmp")
--print("\n$4200 value of $40")
--dict.nes("NES_CPU_WR", 0x4200, 0x40)
--sb_ram_dump(0x4400, 0x8000, "4200_40.dmp")
--print("\n$4200 value of $80")
--dict.nes("NES_CPU_WR", 0x4200, 0x80)
--sb_ram_dump(0x4400, 0x8000, "4200_80.dmp")
--print("\n$4200 value of $C0")
--dict.nes("NES_CPU_WR", 0x4200, 0x80)
--sb_ram_dump(0x4400, 0x8000, "4200_C0.dmp")
logfile:flush()
logfile:close()
end
--initialize mapper for dump/flash routines
local function init_mapper( debug )
--//Setup as CNROM, then scroll through outer banks.
--cpu_wr(0x5000, 0x80); //reg select mode
--dict.nes("NES_CPU_WR", 0x5000, 0x80)
--// xxSSPPMM SS-size: 0-32KB, PP-prg mode: 0,1 32KB, MM-mirror
--cpu_wr(0x8000, 0b00000000); //reg value 256KB inner, 32KB banks
--dict.nes("NES_CPU_WR", 0x8000, 0x00)
--cpu_wr(0x5000, 0x81); //outer reg select mode
--dict.nes("NES_CPU_WR", 0x5000, 0x81)
--cpu_wr(0x8000, 0x00); //first 32KB bank
--dict.nes("NES_CPU_WR", 0x8000, 0x00)
--
--cpu_wr(0x5000, 0x01); //inner prg reg select
--dict.nes("NES_CPU_WR", 0x5000, 0x01)
--cpu_wr(0x8000, 0x00); //controls nothing in this size
--dict.nes("NES_CPU_WR", 0x8000, 0x00)
--cpu_wr(0x5000, 0x00); //chr reg select
--dict.nes("NES_CPU_WR", 0x5000, 0x00)
--cpu_wr(0x8000, 0x00); //first chr bank
--dict.nes("NES_CPU_WR", 0x8000, 0x00)
--selecting CNROM means that mapper writes to $8000-FFFF will only change the CHR-RAM bank which
--doesn't affect anything we're concerned about
end
local function sb_dump_rom()
file = io.open("prg.dat", "wb")
for i = 0x00,0x0F,1 do
print(string.format("$4201: %02X", i))
dict.nes("NES_CPU_WR", 0x4201, i)
start_addr = 0x8000
stop_addr = 0xC000
while (start_addr < stop_addr) do
rv = dict.nes("NES_CPU_RD", start_addr)
file:write(string.char(rv))
start_addr = start_addr + 1
end
--sb_ram_dump(0x8000, 0xC000, string.format("raw/prg_8000_%02X.dat", i))
end
file:flush()
file:close()
--dict.nes("NES_CPU_WR", 0x4201, 0x00)
--sb_ram_dump(0x8000, 0xC000, "prg_8000_00.dat")
--sb_ram_dump(0xC000, 0x10000, "prg_C000_00.dat")
--dict.nes("NES_CPU_WR", 0x4201, 0x01)
--sb_ram_dump(0x8000, 0xC000, "prg_8000_01.dat")
--sb_ram_dump(0xC000, 0x10000, "prg_C000_01.dat")
--dict.nes("NES_CPU_WR", 0x4201, 0x02)
--sb_ram_dump(0x8000, 0xC000, "prg_8000_02.dat")
--sb_ram_dump(0xC000, 0x10000, "prg_C000_02.dat")
--dict.nes("NES_CPU_WR", 0x4201, 0x03)
--sb_ram_dump(0x8000, 0xC000, "prg_8000_03.dat")
--sb_ram_dump(0xC000, 0x10000, "prg_C000_03.dat")
end
local function sb_write_save()
print("Clearing ram")
dict.nes("NES_CPU_WR", 0x4200, 0x00)
sb_write_ram(0x600, 0x8000, 0x00)
sb_write_string(0x5400, "|< page $00 >|")
sb_write_string(0x6000, "|< page $00 >|")
end
local function sb_dump_save()
print("Dumping ram")
dict.nes("NES_CPU_WR", 0x4200, 0x00)
sb_ram_dump(0x4400, 0x8000, "raw/ram.dat")
end
local function sb_read_registers()
data = dict.nes("NES_CPU_RD", 0x4202)
print(string.format("$4202: $%02X", data))
end
--read PRG-ROM flash ID
local function prgrom_manf_id( debug )
init_mapper()
if debug then print("reading PRG-ROM manf ID") end
--A0-A14 are all directly addressable in CNROM mode
--and mapper writes don't affect PRG banking
dict.nes("NES_CPU_WR", 0xD555, 0xAA)
dict.nes("NES_CPU_WR", 0xAAAA, 0x55)
dict.nes("NES_CPU_WR", 0xD555, 0x90)
rv = dict.nes("NES_CPU_RD", 0x8000)
if debug then print("attempted read PRG-ROM manf ID:", string.format("%X", rv)) end
rv = dict.nes("NES_CPU_RD", 0x8001)
if debug then print("attempted read PRG-ROM prod ID:", string.format("%X", rv)) end
--exit software
dict.nes("NES_CPU_WR", 0x8000, 0xF0)
end
local function mirror_test( debug )
init_mapper()
end
local function bank0(bank)
dict.nes("NES_CPU_WR", 0x4201, bank)
print("selecting bank: ", bank)
--rv = dict.nes("NES_CPU_RD", 0x8000)
--if debug then print("attempted read PRG-ROM $8000:", string.format("%X", rv)) end
--rv = dict.nes("NES_CPU_RD", 0x8001)
--if debug then print("attempted read PRG-ROM $8001:", string.format("%X", rv)) end
end
local function sb_write_ppu_string(start_addr, value)
value = string.format("'%s' starting at $%04X", value, start_addr)
print(string.format("Writing %s starting at address $%04X\n", value, start_addr))
for i = 1, #value do
local c = value:sub(i,i)
dict.nes("NES_PPU_WR", start_addr + (i - 1), string.byte(c))
end
end
local function sb_ppu_test()
dict.nes("NES_CPU_WR", 0x4200, 0x00)
dict.nes("NES_CPU_WR", 0x4201, 0x00)
dict.nes("NES_CPU_WR", 0x4203, 0x00)
print("Clearing ppu ram")
for i=0x0000,0x2FFF,1 do
dict.nes("NES_PPU_WR", i, 0x00)
end
sb_write_ppu_string(0x0000, "|< chr page $00 >|")
print("Writing nametable 1")
for i=0x2000,0x23FF,1 do
dict.nes("NES_PPU_WR", i, 0x01)
end
print("Writing nametable 2")
for i=0x2400,0x27FF,1 do
dict.nes("NES_PPU_WR", i, 0x02)
end
print("Writing nametable 3")
for i=0x2800,0x2BFF,1 do
dict.nes("NES_PPU_WR", i, 0x03)
end
print("Writing nametable 4")
for i=0x2C00,0x2FFF,1 do
dict.nes("NES_PPU_WR", i, 0x04)
end
print("dumping ppu ram")
dict.nes("NES_CPU_WR", 0x4200, 0xFF)
dict.nes("NES_CPU_WR", 0x4201, 0xFF)
dict.nes("NES_CPU_WR", 0x4203, 0xFF)
file = io.open("raw/ppu.dat", "wb")
for i=0x0000,0x2FFF,1 do
val = dict.nes("NES_PPU_RD", i)
file:write(string.char(val))
end
file:flush()
file:close()
end
local function sb_ppu_high_ram_test()
print("Testing PPU RAM $3000-$3FFF")
file = io.open("raw/ppu_high_init.dmp", "wb")
for i=0x3000,0x3FFF,1 do
val = dict.nes("NES_PPU_RD", i)
file:write(string.char(val))
end
file:flush()
file:close()
print("writing $B1")
for i=0x3000,0x3FFF,1 do
dict.nes("NES_PPU_WR", i, 0xB1)
end
print("dump 2")
file = io.open("raw/ppu_high_post.dmp", "wb")
for i=0x3000,0x3FFF,1 do
val = dict.nes("NES_PPU_RD", i)
file:write(string.char(val))
end
file:flush()
file:close()
print("dump ppu main")
file = io.open("raw/ppu_main.dmp", "wb")
for i=0x0000,0x2FFF,1 do
val = dict.nes("NES_PPU_RD", i)
file:write(string.char(val))
end
file:flush()
file:close()
end
-- Test CPU vs PPU ram
local function sb_ram_full_test()
--print("Clearing ram")
--sb_write_ram(0x4400, 0x8000, 0x00)
--dict.nes("NES_CPU_WR", 0x4200, 0x41)
--sb_write_ram(0x4400, 0x8000, 0x00)
--dict.nes("NES_CPU_WR", 0x4200, 0x82)
--sb_write_ram(0x4400, 0x8000, 0x00)
--dict.nes("NES_CPU_WR", 0x4200, 0xC3)
--sb_write_ram(0x4400, 0x8000, 0x00)
--dict.nes("NES_CPU_WR", 0x4200, 0x00)
--dict.nes("NES_CPU_WR", 0x4201, 0x00)
--dict.nes("NES_CPU_WR", 0x4203, 0x00)
--print("Clearing ppu ram")
--for i=0x0000,0x2FFF,1 do
-- dict.nes("NES_PPU_WR", i, 0x00)
--end
print("Writing values")
-- Only using 0x6000-0x7FFF here because it's
-- the same memory as the first block
dict.nes("NES_CPU_WR", 0x4200, 0x00)
sb_write_ram(0x6000, 0x7FFF, 01)
dict.nes("NES_CPU_WR", 0x4200, 0x40)
sb_write_ram(0x6000, 0x7FFF, 02)
dict.nes("NES_CPU_WR", 0x4200, 0x80)
sb_write_ram(0x6000, 0x7FFF, 03)
dict.nes("NES_CPU_WR", 0x4200, 0xC0)
sb_write_ram(0x6000, 0x7FFF, 04)
--print("Clearing ppu ram")
--for i=0x0000,0x2FFF,1 do
-- dict.nes("NES_PPU_WR", i, 0x00)
--end
-- print("Writing values")
print("Writing nametable 1")
for i=0x2000,0x23FF,1 do
dict.nes("NES_PPU_WR", i, 0xA1)
end
print("Writing nametable 2")
for i=0x2400,0x27FF,1 do
dict.nes("NES_PPU_WR", i, 0xA2)
end
print("Writing nametable 3")
for i=0x2800,0x2BFF,1 do
dict.nes("NES_PPU_WR", i, 0xA3)
end
print("Writing nametable 4")
for i=0x2C00,0x2FFF,1 do
dict.nes("NES_PPU_WR", i, 0xA4)
end
print("writing CHR at 0x0000")
for i=0x0000,0x0FFF,1 do
dict.nes("NES_PPU_WR", i, 0xA5)
end
print("writing CHR at 0x1000")
for i=0x1000,0x1FFF,1 do
dict.nes("NES_PPU_WR", i, 0xA6)
end
print("dumping ppu ram")
--dict.nes("NES_CPU_WR", 0x4200, 0xFF)
--dict.nes("NES_CPU_WR", 0x4201, 0xFF)
--dict.nes("NES_CPU_WR", 0x4203, 0xFF)
file = io.open("raw/cpu-ppu.dmp", "wb")
for i=0x0000,0x2FFF,1 do
val = dict.nes("NES_PPU_RD", i)
file:write(string.char(val))
end
file:flush()
file:close()
print("dumping 4200_00.dmp")
dict.nes("NES_CPU_WR", 0x4200, 0x00)
sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_00.dmp")
print("dumping 4200_40.dmp")
dict.nes("NES_CPU_WR", 0x4200, 0x40)
sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_40.dmp")
print("dumping 4200_80.dmp")
dict.nes("NES_CPU_WR", 0x4200, 0x80)
sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_80.dmp")
print("dumping 4200_C0.dmp")
dict.nes("NES_CPU_WR", 0x4200, 0xC0)
sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_C0.dmp")
end
local function check_ppu_mirror(a, b)
vala = dict.nes("NES_PPU_RD", 0x2800)
valb = dict.nes("NES_PPU_RD", 0x2C00)
if vala ~= a then
print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
end
if valb ~= b then
print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
end
end
local function sb_mirror_test()
dict.nes("NES_PPU_WR", 0x2800, 0xA1)
dict.nes("NES_PPU_WR", 0x2C00, 0xA2)
print("checking $4200")
for i=0xC4,0xFF,4 do
--print(string.format(" %02X", i))
dict.nes("NES_CPU_WR", 0x4200, i)
vala = dict.nes("NES_PPU_RD", 0x2800)
valb = dict.nes("NES_PPU_RD", 0x2C00)
if vala ~= 0xA1 then
print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
end
if valb ~= 0xA2 then
print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
end
end
print("checking $4201")
for i=0x00,0xF0,0x10 do
--print(string.format(" %02X", i))
dict.nes("NES_CPU_WR", 0x4201, i)
vala = dict.nes("NES_PPU_RD", 0x2800)
valb = dict.nes("NES_PPU_RD", 0x2C00)
if vala ~= 0xA1 then
print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
end
if valb ~= 0xA2 then
print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
end
end
print("checking $4202")
dict.nes("NES_CPU_WR", 0x4202, 0x40)
check_ppu_mirror(0xA1, 0xA2)
dict.nes("NES_CPU_WR", 0x4202, 0x08)
check_ppu_mirror(0xA1, 0xA2)
print("checking $4203")
for i=0x00,0xFF,0x01 do
--print(string.format(" %02X", i))
dict.nes("NES_CPU_WR", 0x4203, i)
vala = dict.nes("NES_PPU_RD", 0x2800)
valb = dict.nes("NES_PPU_RD", 0x2C00)
if vala ~= 0xA1 then
print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
end
if valb ~= 0xA2 then
print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
end
end
end
--Cart should be in reset state upon calling this function
--this function processes all user requests for this specific board/mapper
local function process(process_opts, console_opts)
local test = process_opts["test"]
local read = process_opts["read"]
local erase = process_opts["erase"]
local program = process_opts["program"]
local verify = process_opts["verify"]
local dumpfile = process_opts["dump_filename"]
local flashfile = process_opts["flash_filename"]
local verifyfile = process_opts["verify_filename"]
local rv = nil
local file
local prg_size = console_opts["prg_rom_size_kb"]
local chr_size = console_opts["chr_rom_size_kb"]
local wram_size = console_opts["wram_size_kb"]
--initialize device i/o for NES
dict.io("IO_RESET")
dict.io("NES_INIT")
mirror_test(true)
--test cart by reading manf/prod ID
if test then
prgrom_manf_id(true)
end
--sb_verify_ram()
--sb_read_registers()
--sb_dump_rom()
--sb_write_save()
--sb_dump_save()
--sb_ppu_test()
--sb_ram_full_test()
--sb_ppu_high_ram_test()
sb_mirror_test()
dict.io("IO_RESET")
do return end
-- Poke some registers
init_mapper(debug)
dict.nes("NES_CPU_WR", 0x4202, 0x20)
--for i=0, 8, 1 do
-- dict.nes("NES_CPU_WR", 0x4202, 0x10)
-- rv = dict.nes("NES_CPU_RD", 0x4201)
-- print(i, "initial read:", string.format("$%02X", rv))
-- while (rv & 0x40 == 0) do
-- rv = dict.nes("NES_CPU_RD", 0x4201)
-- io.write(".")
-- end
-- print("")
--end
--dump the cart to dumpfile
read = false
if read then
print("Attempting to read StudyBox stuff")
--initialize the mapper for dumping
init_mapper(debug)
rv = dict.nes("NES_CPU_RD", 0x4200)
print("$4200:", string.format("$%X", rv))
rv = dict.nes("NES_CPU_RD", 0x4201)
print("$4201:", string.format("$%X", rv))
rv = dict.nes("NES_CPU_RD", 0x4202)
print("$4202:", string.format("$%X", rv))
rv = dict.nes("NES_CPU_RD", 0x4203)
print("$4203:", string.format("$%X", rv))
file = assert(io.open(dumpfile, "wb"))
--create header: pass open & empty file & rom sizes
--create_header(file, prg_size, chr_size)
for bank=0, 16, 1 do
dict.nes("NES_CPU_WR", 0x4201, bank)
print("dumping bank: ", bank)
rv = dict.nes("NES_CPU_RD", 0x4201)
print("$4201:", string.format("$%X", rv))
--dump cart into file
dump.dumptofile( file, prg_size, "186", "PRGROM", true )
end
--close file
assert(file:close())
end
--verify flashfile is on the cart
verify = false
if verify then
--for now let's just dump the file and verify manually
--initialize the mapper for dumping
init_mapper(debug)
file = assert(io.open(verifyfile, "wb"))
--dump cart into file
dump.dumptofile( file, 512, "A53", "PRGROM", true )
--close file
assert(file:close())
end
dict.io("IO_RESET")
end
-- global variables so other modules can use them
-- call functions desired to run when script is called/imported
-- functions other modules are able to call
studybox.process = process
-- return the module's table
return studybox

1
shared/shared_dict_buffer.h
View File

@ -171,7 +171,6 @@
#define MAP30 30
#define EZNSF 31
#define BxROM 34
#define NINA 34
#define RAMBO 64
#define H3001 65 //IREM mapper
#define GxROM 66