diff --git a/firmware/source/buffer.c b/firmware/source/buffer.c index dacf040..d177240 100644 --- a/firmware/source/buffer.c +++ b/firmware/source/buffer.c @@ -166,6 +166,7 @@ uint8_t * buffer_usb_call( setup_packet *spacket, uint8_t *rv, uint8_t *rlen) break; //opcodes which include designation of which buffer is being called in lower bits of opcode + //TODO get rid of these opcodes, and just always put buffer number in miscdata!! case BUFF_OPCODE_BUFN_MIN ... BUFF_OPCODE_BUFN_MAX: //mask out last three bits to detect buffer being called based on opcode number switch ( (spacket->opcode) & 0x07) { @@ -298,13 +299,11 @@ uint8_t * buffer_payload( setup_packet *spacket, buffer *buff, uint8_t hostsetbu //now only thing left to do is stuff 2 bytes from setup packet into the buffer if designated by the opcode if ( (cur_buff->status == USB_LOADING) && ((spacket->opcode == BUFF_OUT_PAYLOAD_2B_INSP)||(spacket->opcode == BUFF_OUT_PAYLOADN_2B_INSP)) ) { - //operandMSB:LSB actually contains first 2 bytes + //operandLSB:MSB actually contains first 2 bytes //these two bytes don't count as part of transfer OUT byte count //but they do count as part of buffer's byte count. -// cur_usb_load_buff->data[0] = spacket->operandMSB; - cur_usb_load_buff->data[0] = (spacket->operand)>>8; -// cur_usb_load_buff->data[1] = spacket->operandLSB; - cur_usb_load_buff->data[1] = spacket->operand; + cur_usb_load_buff->data[0] = spacket->operand; + cur_usb_load_buff->data[1] = (spacket->operand)>>8; cur_usb_load_buff->cur_byte += 2; } @@ -670,7 +669,7 @@ void update_buffers() last_buff->status = FLASHING; //last_buff->cur_byte = 0; -//TODO CALL FLASHBUFF result = flash_buff( last_buff ); + result = flash_buff( last_buff ); if (result != SUCCESS) { last_buff->status = result; } else { diff --git a/firmware/source/buffer.h b/firmware/source/buffer.h index dd2f0da..bbf99c0 100644 --- a/firmware/source/buffer.h +++ b/firmware/source/buffer.h @@ -8,8 +8,7 @@ #include "operation.h" #include "usb.h" #include "dump.h" - -//#include "flash.h" +#include "flash.h" #define FALSE 0x00 //TODO remove this junk! diff --git a/firmware/source/flash.c b/firmware/source/flash.c new file mode 100644 index 0000000..9b86c41 --- /dev/null +++ b/firmware/source/flash.c @@ -0,0 +1,109 @@ +#include "flash.h" + + +uint8_t write_page( uint8_t bank, uint8_t addrH, buffer *buff, write_funcptr wr_func, read_funcptr rd_func ) +{ + uint16_t cur = buff->cur_byte; + uint8_t n = buff->cur_byte; + uint8_t read; +// extern operation_info *oper_info; + + while ( cur <= buff->last_idx ) { + //write unlock sequence + //need to make address and unlock data variable + //best for host to communcate these values + //actual value is part mapper dependent and part flash dependent + //mapper controlled address bits dictate where split is + //32KB banking A14-0 NES ctl, A15+ mapper ctl "bank" NROM, BNROM, ANROM + //addrH_dmask = 0b0111 1111 directly addressable addrH bits + //page2bankshft = A14->A8 = 7 shifts (equal to number of set bits in addrH_mask + //16KB banking A13-0 NES ctl, A14+ mapper ctl "bank" UxROM, MMC1 + //addrH_dmask = 0b0011 1111 + //page2bankshft = A13->A8 = 6 shifts + // 8KB banking A12-0 NES ctl, A13+ mapper ctl "bank" MMC3, FME7 + //addrH_dmask = 0b0001 1111 + //page2bankshft = A12->A8 = 5 shifts + // 4KB banking A11-0 NES ctl, A12+ mapper ctl "bank" ezNSF + //addrH_dmask = 0b0000 1111 + //page2bankshft = A11->A8 = 4 shifts + wr_func( 0x5555, 0xAA ); +// wr_func( oper_info->unlock1_AH, oper_info->unlock1_AL, oper_info->unlock1_data ); + wr_func( 0x2AAA, 0x55 ); +// wr_func( oper_info->unlock2_AH, oper_info->unlock2_AL, oper_info->unlock2_data ); + wr_func( 0x5555, 0xA0 ); +// wr_func( oper_info->command_AH, oper_info->command_AL, oper_info->command1_data ); + wr_func( ((addrH<<8)| n), buff->data[n] ); + + do { + usbPoll(); + read = rd_func((addrH<<8)|n); + + } while( read != rd_func((addrH<<8)|n) ); + //TODO verify byte is value that was trying to be flashed + //move on to next byte + n++; + cur++; + + } + + buff->cur_byte = n; + + return SUCCESS; + +} + +/* Desc:Flash buffer contents on to cartridge memory + * Pre: buffer elements must be updated to designate how/where to flash + * buffer's cur_byte must be cleared or set to where to start flashing + * mapper registers must be initialized + * Post:buffer page flashed/programmed to memory. + * Rtn: SUCCESS or ERROR# depending on if there were errors. + */ +uint8_t flash_buff( buffer *buff ) { + + uint8_t addrH = buff->page_num; //A15:8 while accessing page + + //First need to initialize mapper register bits + //Perhaps this only needs to be done on first buffer though..? + //Actually think this is best handled from buffer.c in operation == STARTFLASH + + //TODO use mapper to set mapper controlled address bits + + //need to calculate current bank and addrH + + //TODO set unlock addresses based on what works for that mapper and how it's banks are initialized + + //use mem_type to set addrH/X as needed for dump loop + //also use to get read function pointer + switch ( buff->mem_type ) { + case PRGROM: //$8000 + write_page( 0, (0x80 | addrH), buff, discrete_exp0_prgrom_wr, nes_cpu_rd ); + break; + case CHRROM: //$0000 + //TODO write_page( 0, addrH, buff, nes_ppu_wr, nes_ppu_rd ); + break; + case PRGRAM: + //addrH |= 0x60; //$6000 + //buff->cur_byte = nes_cpu_page_wr_poll( buff->data, addrH, buff->id, + // buff->last_idx, ~FALSE ); + break; + case SNESROM: + case SNESRAM: +//warn addrX = ((buff->page_num)>>8); + break; + default: + return ERR_BUFF_UNSUP_MEM_TYPE; + } + + + //lets start just reading first page of PRG-ROM then get fancy +// while (buff->cur_byte < buff->last_idx) { +// +// //might be faster to put some of these in new pointers, but not sure.. +// buff->data[buff->cur_byte] = nes_cpu_rd( addrH, buff->cur_byte ); +// buff->cur_byte++; +// } + + return SUCCESS; +} + diff --git a/firmware/source/flash.h b/firmware/source/flash.h new file mode 100644 index 0000000..bb1dd63 --- /dev/null +++ b/firmware/source/flash.h @@ -0,0 +1,12 @@ +#ifndef _flash_h +#define _flash_h + +#include "pinport.h" +#include "types.h" +#include "nes.h" +#include "shared_dictionaries.h" +#include "shared_errors.h" + +uint8_t flash_buff( buffer *buff ) ; + +#endif diff --git a/firmware/source/types.h b/firmware/source/types.h index e5022c1..0e2e009 100644 --- a/firmware/source/types.h +++ b/firmware/source/types.h @@ -12,8 +12,10 @@ typedef struct setup_packet{ //write function pointers -typedef void (*write_funcptr) ( uint8_t addrH, uint8_t addrL, uint8_t data ); -typedef uint8_t (*read_funcptr) ( uint8_t addrH, uint8_t addrL ); +//typedef void (*write_funcptr) ( uint8_t addrH, uint8_t addrL, uint8_t data ); +//typedef uint8_t (*read_funcptr) ( uint8_t addrH, uint8_t addrL ); +typedef void (*write_funcptr) ( uint16_t addr, uint8_t data ); +typedef uint8_t (*read_funcptr) ( uint16_t addr ); //~16 bytes per buffer... diff --git a/firmware/source/usb.c b/firmware/source/usb.c index 2f04338..afa9255 100644 --- a/firmware/source/usb.c +++ b/firmware/source/usb.c @@ -215,7 +215,7 @@ uint16_t usbFunctionSetup(uint8_t data[8]) { // w/o checks: 512KByte = 17.9sec = 28.5KBps // w/o checks: using 8bit rlen = 17.5sec = 29.2KBps // with checks: using 8bit rlen = 18sec = 28.3KBps -//#define MAKECHECKS 0 +//#define MAKECHECKS #ifdef AVR_CORE USB_PUBLIC uchar usbFunctionWrite(uchar *data, uchar len) { @@ -224,7 +224,6 @@ USB_PUBLIC uchar usbFunctionWrite(uchar *data, uchar len) { uint8_t usbFunctionWrite(uint8_t *data, uint8_t len) { #endif -/* //defined and controled by buffer.c extern buffer *cur_usb_load_buff; extern uint8_t incoming_bytes_remain; @@ -280,7 +279,5 @@ uint8_t usbFunctionWrite(uint8_t *data, uint8_t len) { return NOT_DONE; } - */ - return 0; } diff --git a/host/scripts/app/dict.lua b/host/scripts/app/dict.lua index 669938c..ee5d5f9 100644 --- a/host/scripts/app/dict.lua +++ b/host/scripts/app/dict.lua @@ -342,6 +342,45 @@ local function buffer_payload_in( wLength, buff_num ) end +local function buffer_payload_out( num_bytes, data, buff_num ) + + local opcode = nil + + local wLength = 0 + if num_bytes == 256 then + --2B in setup packet + operand = string.unpack("B", data ,1) | (string.unpack("B", data ,2)<<8) +-- print(string.format("%04X ", operand)) + --operand = string.sub(data, 1, 2) + wLength = 254 + if not buff_num then + opcode = op_buffer["BUFF_OUT_PAYLOAD_2B_INSP"] + buff_num = 0 + else + opcode = op_buffer["BUFF_OUT_PAYLOADN_2B_INSP"] + end + else --don't stuff data in setup packet + wLength = num_bytes + operand = 0 + if not buff_num then + opcode = op_buffer["BUFF_PAYLOAD"] + buff_num = 0 + else + opcode = op_buffer["BUFF_PAYLOAD0"] + buff_num + buff_num = 0 --these opcodes don't put buff num in miscdata, but should update them to do so. + end + end + + local count + count, data = usb_vend_xfr( + USB_OUT, ((buff_num<<8) | dict["DICT_BUFFER"]), opcode, operand, wLength, data:sub(3,-1)) + + assert ( (count == wLength ), ("ERROR!!! host only sent:"..count.."bytes, expecting:"..wLength)) + + return + +end + -- external call for buffer dictionary local function buffer( opcode, operand, misc, data ) @@ -478,6 +517,7 @@ dict.io = io dict.nes = nes dict.buffer = buffer dict.buffer_payload_in = buffer_payload_in +dict.buffer_payload_out = buffer_payload_out dict.operation = operation -- return the module's table diff --git a/host/scripts/app/erase.lua b/host/scripts/app/erase.lua new file mode 100644 index 0000000..80b3d4a --- /dev/null +++ b/host/scripts/app/erase.lua @@ -0,0 +1,67 @@ + +-- create the module's table +local erase = {} + +-- import required modules +local dict = require "scripts.app.dict" + +-- file constants + +-- local functions +local function erase_nes() + + local rv = nil + + print("erasing_nrom"); + + dict.io("IO_RESET") + dict.io("NES_INIT") + + 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 + + while ( rv ~= 0xFF ) do + rv = dict.nes("NES_CPU_RD", 0x8000) + i = i + 1 + end + print(i, " done erasing prg.\n"); + + 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) + + local i = 0 + + while ( rv ~= 0xFF ) do + rv = dict.nes("NES_PPU_RD", 0x0000) + i = i + 1 + end + print(i, " done erasing chr.\n"); + +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 +erase.erase_nes = erase_nes + +-- return the module's table +return erase diff --git a/host/scripts/app/flash.lua b/host/scripts/app/flash.lua new file mode 100644 index 0000000..b7b54e1 --- /dev/null +++ b/host/scripts/app/flash.lua @@ -0,0 +1,268 @@ + +-- create the module's table +local flash = {} + +-- import required modules +local dict = require "scripts.app.dict" +local buffers = require "scripts.app.buffers" + +-- file constants + +-- local functions +local function flash_nes( file, debug ) +--{ +-- //make some checks to ensure rom is compatible with cart +-- +-- //first do some checks like ensuring proper areas or sectors are blank +-- +-- //erase sectors or chip as needed +-- +-- //reset, allocate, and initialize device buffers +-- +-- //initialize mapper registers as needed for memory being programmed +-- +-- //set device operation to STARTFLASH +-- +-- //send payload data +-- +-- //run checksums to verify successful flash operation +-- + local buff0 = 0 + local buff1 = 1 + local cur_buff_status = 0 + local data = nil --lua stores data in strings + + if debug then print("flashing cart") end +-- +-- //TODO provide user arg to force all these checks passed +-- //first check if any provided args differ from what was detected +-- check( (cart->console != UNKNOWN), "cartridge not detected, must provide console if autodetection is off"); +-- +-- if ( rom->console != UNKNOWN ) { +-- check( rom->console == cart->console, +-- "request system dump doesn't match detected cartridge"); +-- } +-- if ( (cart->mapper != UNKNOWN) && (rom->mapper != UNKNOWN) ) { +-- check( rom->mapper == cart->mapper, +-- "request mapper dump doesn't match detected mapper"); +-- } +-- +-- //start with reset and init + dict.io("IO_RESET") + dict.io("NES_INIT") +-- +-- //start operation at reset +-- check(! set_operation( transfer, RESET ), "Unable to set buffer operation"); +-- +-- //setup buffers and manager +-- //reset buffers first + dict.buffer("RAW_BUFFER_RESET") +-- //need to allocate some buffers for flashing +-- //2x 256Byte buffers + local num_buffers = 2 + local buff_size = 256 + print("allocating buffers") + assert(buffers.allocate( num_buffers, buff_size ), "fail to allocate buffers") +-- +-- //tell buffers what function to use for flashing +-- //load operation elements into buff0 and then copy buff0 to oper_info +-- load_oper_info_elements( transfer, cart ); +-- get_oper_info_elements( transfer ); +-- +-- //setup buffers and manager +-- //reset buffers first +-- check(! reset_buffers( transfer ), "Unable to reset device buffers"); +-- //need to allocate some buffers for flashing +-- //2x 256Byte buffers +-- check(! allocate_buffers( transfer, num_buffers, buff_size ), "Unable to allocate buffers"); +-- +-- //set mem_type and part_num to designate how to get/write data + print("setting map n part") + dict.buffer("SET_MEM_N_PART", (op_buffer["PRGROM"]<<8 | op_buffer["MASKROM"]), buff0 ) + dict.buffer("SET_MEM_N_PART", (op_buffer["PRGROM"]<<8 | op_buffer["MASKROM"]), buff1 ) +-- //set multiple and add_mult only when flashing +-- //TODO +-- //set mapper, map_var, and function to designate read/write algo +-- +-- //just dump visible NROM memory to start + print("setting map n mapvar") + dict.buffer("SET_MAP_N_MAPVAR", (op_buffer["NROM"]<<8 | op_buffer["NOVAR"]), buff0 ) + dict.buffer("SET_MAP_N_MAPVAR", (op_buffer["NROM"]<<8 | op_buffer["NOVAR"]), buff1 ) +-- +-- //debugging print out buffer elements + print("\nget operation:") + dict.operation("GET_OPERATION" ) + print("\n\ngetting cur_buff status") + dict.buffer("GET_CUR_BUFF_STATUS" ) + print("\n\ngetting elements") + print(dict.buffer("GET_PRI_ELEMENTS", nil, buff0 )) + print(dict.buffer("GET_PRI_ELEMENTS", nil, buff1 )) + print(dict.buffer("GET_SEC_ELEMENTS", nil, buff0 )) + print(dict.buffer("GET_SEC_ELEMENTS", nil, buff1 )) + print(dict.buffer("GET_PAGE_NUM", nil, buff0 ) ) + print(dict.buffer("GET_PAGE_NUM", nil, buff1 ) ) + + print("\n\nsetting operation STARTFLASH"); +-- //inform buffer manager to start dumping operation now that buffers are initialized + dict.operation("SET_OPERATION", op_buffer["STARTFLASH"] ) + +-- clock_t tstart, tstop; +-- tstart = clock(); +-- +-- //now just need to call series of payload IN transfers to retrieve data +-- +-- for( i=0; i<(32*KByte/buff_size); i++) { + local i = 1 + local nak = 0 + for bytes in file:lines(buff_size) do + dict.buffer_payload_out( buff_size, bytes ) + --for i = 1, #bytes do + -- local b = string.unpack("B", bytes, i) + -- io.write(string.format("%02X ", b)) + --end +-- io.write(string.rep(" ", blocksize - #bytes)) +-- bytes = string.gsub(bytes, "%c", ".") +-- io.write(" ", bytes, "\n") +-- break +-- while (cur_buff_status != EMPTY ) { +-- //debug("cur_buff->status: %x ", cur_buff_status); +-- check(! get_cur_buff_status( transfer, &cur_buff_status ), "Error retrieving cur_buff->status"); +-- } + cur_buff_status = dict.buffer("GET_CUR_BUFF_STATUS") + while (cur_buff_status ~= op_buffer["EMPTY"]) do + nak = nak +1 + --print(nak, "cur_buff->status: ", cur_buff_status) + cur_buff_status = dict.buffer("GET_CUR_BUFF_STATUS") +-- check(! get_cur_buff_status( transfer, &cur_buff_status ), "Error retrieving cur_buff->status"); +-- } + end + if ( i == 32*1024/buff_size) then break end + i = i + 1 + end + print("number of naks", nak) +-- +-- //The device doesn't have a good way to respond if the last buffer is flashing +-- //and the current one is full. We can only send a payload if the current buffer +-- //is empty. +-- waste some time for now.. + print(dict.buffer("GET_PRI_ELEMENTS", nil, buff0 )) + print(dict.buffer("GET_PRI_ELEMENTS", nil, buff1 )) + print(dict.buffer("GET_SEC_ELEMENTS", nil, buff0 )) + print(dict.buffer("GET_SEC_ELEMENTS", nil, buff1 )) + print(dict.buffer("GET_PAGE_NUM", nil, buff0 ) ) + print(dict.buffer("GET_PAGE_NUM", nil, buff1 ) ) +-- +-- //Read next chunk from file +-- check(! read_from_file( rom, data, buff_size ), "Error with file read"); +-- +-- //ensure cur_buff is EMPTY prior to sending data +-- check(! get_cur_buff_status( transfer, &cur_buff_status ), "Error retrieving cur_buff->status"); +-- while (cur_buff_status != EMPTY ) { +-- //debug("cur_buff->status: %x ", cur_buff_status); +-- check(! get_cur_buff_status( transfer, &cur_buff_status ), "Error retrieving cur_buff->status"); +-- } +-- +-- //send data +-- check(! payload_out( transfer, data, buff_size ), "Error with payload OUT"); +-- //if ( i % 256 == 0 ) debug("payload in #%d", i); +-- if ( i % 32 == 0 ) debug("payload out #%d", i); +-- } +-- check(! get_cur_buff_status( transfer, &cur_buff_status ), "Error retrieving cur_buff->status"); +-- //debug("\n\n\ncur_buff->status: %x\n", cur_buff_status); +-- +-- //add check to ensure both buffers are done and operation is okay +-- //need to get status of buff1 and make sure it's flashed +-- while (cur_buff_status != FLASHED ) { +-- check(! get_buff_element_value( transfer, buff1, GET_PRI_ELEMENTS, BUFF_STATUS, &cur_buff_status ), +-- "Error retrieving buffer status post flashing"); +-- // debug("\n\n\ncur_buff->status: %x\n", cur_buff_status); +-- } +-- +-- debug("payload done"); +-- +-- //end operation at reset +-- check(! set_operation( transfer, RESET ), "Unable to set buffer operation"); +-- +-- tstop = clock(); +-- float timediff = ( (float)(tstop-tstart) / CLOCKS_PER_SEC); +-- printf("total time: %fsec, speed: %fKBps\n", timediff, (32/timediff)); +-- //TODO flush file from time to time..? +-- +-- +-- //tell buffer manager when to stop +-- // or not..? just reset buffers and start next memory or quit +-- //reset buffers and setup to dump CHR-ROM +-- +-- //load operation elements into buff0 and then copy buff0 to oper_info +-- load_oper_info_elements_chr( transfer, cart ); +-- get_oper_info_elements( transfer ); +-- +-- check(! reset_buffers( transfer ), "Unable to reset device buffers"); +-- check(! allocate_buffers( transfer, num_buffers, buff_size ), "Unable to allocate buffers"); +-- check(! set_mem_n_part( transfer, buff0, CHRROM, SST_MANF_ID ), "Unable to set mem_type and part"); +-- check(! set_mem_n_part( transfer, buff1, CHRROM, SST_MANF_ID ), "Unable to set mem_type and part"); +-- check(! set_map_n_mapvar( transfer, buff0, NROM, NILL ), "Unable to set mapper and map_var"); +-- check(! set_map_n_mapvar( transfer, buff1, NROM, NILL ), "Unable to set mapper and map_var"); +-- +-- debug("\n\nsetting operation STARTFLASH"); +-- //inform buffer manager to start dumping operation now that buffers are initialized +-- check(! set_operation( transfer, STARTFLASH ), "Unable to set buffer operation"); +-- +-- +-- tstart = clock(); +-- +-- //now just need to call series of payload IN transfers to retrieve data +-- +-- for( i=0; i<(8*KByte/buff_size); i++) { +-- +-- //Read next chunk from file +-- check(! read_from_file( rom, data, buff_size ), "Error with file read"); +-- +-- //ensure cur_buff is EMPTY prior to sending data +-- check(! get_cur_buff_status( transfer, &cur_buff_status ), "Error retrieving cur_buff->status"); +-- while (cur_buff_status != EMPTY ) { +-- //debug("cur_buff->status: %x ", cur_buff_status); +-- check(! get_cur_buff_status( transfer, &cur_buff_status ), "Error retrieving cur_buff->status"); +-- } +-- +-- //send data +-- check(! payload_out( transfer, data, buff_size ), "Error with payload OUT"); +-- //if ( i % 256 == 0 ) debug("payload in #%d", i); +-- if ( i % 32 == 0 ) debug("payload out #%d", i); +-- } +-- check(! get_cur_buff_status( transfer, &cur_buff_status ), "Error retrieving cur_buff->status"); +-- //debug("\n\n\ncur_buff->status: %x\n", cur_buff_status); +-- +-- //check to ensure both buffers are done and operation is okay before resetting +-- //need to get status of buff1 and make sure it's flashed +-- while (cur_buff_status != FLASHED ) { +-- check(! get_buff_element_value( transfer, buff1, GET_PRI_ELEMENTS, BUFF_STATUS, &cur_buff_status ), +-- "Error retrieving buffer status post flashing"); +-- // debug("\n\n\ncur_buff->status: %x\n", cur_buff_status); +-- } +-- +-- debug("payload done"); +-- //close file in main +-- +-- //end operation at reset +-- check(! set_operation( transfer, RESET ), "Unable to set buffer operation"); +-- +-- //reset io at end +-- io_reset( transfer ); +-- +-- return SUCCESS; + +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 +flash.flash_nes = flash_nes + +-- return the module's table +return flash diff --git a/host/scripts/inlretro.lua b/host/scripts/inlretro.lua index 718204b..8c4b9c7 100644 --- a/host/scripts/inlretro.lua +++ b/host/scripts/inlretro.lua @@ -9,6 +9,8 @@ function main () local cart = require "scripts.app.cart" local nes = require "scripts.app.nes" local dump = require "scripts.app.dump" + local erase = require "scripts.app.erase" + local flash = require "scripts.app.flash" local rv -- rv = dict.pinport( "CTL_ENABLE" ) @@ -61,6 +63,20 @@ function main () --set rom types and sizes --perform desired operation + + --FLASHING: + --erase cart + erase.erase_nes( true ) + --open file + local file + file = assert(io.open("flash.bin", "rb")) + --determine if auto-doubling, deinterleaving, etc, + --needs done to make board compatible with rom + --flash cart + flash.flash_nes( file, true ) + --close file + assert(file:close()) + --DUMPING: --create new file local file @@ -71,15 +87,6 @@ function main () --close file assert(file:close()) - --FLASHING: - --open file - --erase cart - --determine if auto-doubling, deinterleaving, etc, - --needs done to make board compatible with rom - --flash cart - --close file - - dict.io("IO_RESET")