383 lines
12 KiB
C
383 lines
12 KiB
C
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <getopt.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include <libusb.h>
|
|
|
|
//uncomment to DEBUG this file alone
|
|
#define DEBUG
|
|
//"make debug" to get DEBUG msgs on entire program
|
|
#include "dbg.h"
|
|
#include "usb_operations.h"
|
|
|
|
//lua libraries
|
|
#include "lua/lua.h"
|
|
#include "lua/lauxlib.h"
|
|
#include "lua/lualib.h"
|
|
|
|
const char *HELP = "Usage: inlretro [options]\n\n"\
|
|
"Options/Flags:\n"\
|
|
" --console=console, -c console\t\t\tConsole port, {GBA,GENESIS,N64,NES}\n"\
|
|
" --dump_filename=filename, -d filename\t\tIf provided, dump cartridge ROMs to this filename\n"\
|
|
" --dump_ram_filename=filename, -a filename\tIf provided write ram to this filename\n"\
|
|
" --help, -h\t\t\t\t\tDisplays this message.\n"\
|
|
" --lua_filename=filename, -s filename\t\tIf provided, use this script for main application logic\n"\
|
|
" --mapper=mapper, -m mapper\t\t\tNES, SNES, GB consoles only, mapper ASIC on cartridge\n"\
|
|
" \t\t\t\t\t\tNES:\t{action53,bnrom,cdream,cninja,cnrom,dualport,easynsf,fme7,\n"\
|
|
" \t\t\t\t\t\t\t mapper30,mmc1,mmc3,mmc4,mmc5,nrom,unrom}\n"\
|
|
" \t\t\t\t\t\tGB:\t{mbc1,romonly}\n"\
|
|
" \t\t\t\t\t\tSNES:\t{lorom,hirom}\n"\
|
|
" --nes_prg_rom_size_kbyte=size, -x size_kbytes\tNES-only, size of PRG-ROM in kilobytes\n"\
|
|
" --nes_chr_rom_size_kbyte=size, -y size_kbytes\tNES-only, size of CHR-ROM in kilobytes\n"\
|
|
" --rom_size_kbyte=size, -k size_kbytes\t\tSize of ROM in kilobytes, non-NES systems.\n"\
|
|
" --rom_size_mbit=size, -z size_mbits\t\tSize of ROM in megabits, non-NES systems.\n"\
|
|
" --verify_filename=filename, -v filename\tIf provided, writeback written rom to this filename\n"\
|
|
" --wram_size_kbyte=size, -w size_kbytes\tNES-only, size of WRAM in kilobytes\n"\
|
|
" --write_filename=filename, -p filename\tIf provided, write this data to cartridge\n"\
|
|
" --write_ram_filename=filename, -b filename\tIf provided write this file's contents to ram\n";
|
|
|
|
// Struct used to control functionality.
|
|
typedef struct {
|
|
char *console_name;
|
|
char *mapper_name;
|
|
int display_help;
|
|
|
|
// NES Functionality
|
|
int chr_rom_size_kb;
|
|
int prg_rom_size_kb;
|
|
int wram_size_kb;
|
|
|
|
// General Functionality
|
|
int rom_size_kbyte;
|
|
char *dump_filename;
|
|
char *program_filename;
|
|
char *ramdump_filename;
|
|
char *ramwrite_filename;
|
|
char *verify_filename;
|
|
|
|
char *lua_filename;
|
|
} INLOptions;
|
|
|
|
// Returns true if given number is a power of 2, and at least minimum size.
|
|
int isValidROMSize(int x, int min) {
|
|
return ((x & (x - 1)) == 0) && x >= min;
|
|
}
|
|
|
|
// Take a mixed-case string and convert to only lowercase.
|
|
void strToLower(char *str) {
|
|
while(*str) {
|
|
*str = tolower(*str);
|
|
str++;
|
|
}
|
|
}
|
|
|
|
// Parse options and flags, create struct to drive program.
|
|
INLOptions* parseOptions(int argc, char *argv[]) {
|
|
|
|
// Declare command line flags/options.
|
|
struct option longopts[] = {
|
|
{"help", optional_argument, NULL, 'h'},
|
|
{"console", required_argument, NULL, 'c'},
|
|
{"mapper", optional_argument, NULL, 'm'},
|
|
{"dump_filename", optional_argument, NULL, 'd'},
|
|
{"dump_ram_filename", optional_argument, NULL, 'a'},
|
|
{"write_filename", optional_argument, NULL, 'p'},
|
|
{"write_ram_filename", optional_argument, NULL, 'b'},
|
|
{"verify_filename", optional_argument, NULL, 'v'},
|
|
{"lua_filename", optional_argument, NULL, 's'},
|
|
{"nes_prg_rom_size_kbyte", optional_argument, NULL, 'x'},
|
|
{"nes_chr_rom_size_kbyte", optional_argument, NULL, 'y'},
|
|
{"wram_size_kbyte", optional_argument, NULL, 'w'},
|
|
{"rom_size_kbyte", optional_argument, NULL, 'k'},
|
|
{"rom_size_mbit", optional_argument, NULL, 'z'},
|
|
{0, 0, 0, 0} // longopts must end in {0, 0, 0, 0}
|
|
};
|
|
|
|
// FLAG_FORMAT must be kept in sync with any short options used in longopts.
|
|
const char *FLAG_FORMAT = "a:b:hc:d:k:m:p:s:v:w:x:y:z:";
|
|
int index = 0;
|
|
int rv = 0;
|
|
int kbyte = 0;
|
|
opterr = 0;
|
|
|
|
// Create options struct.
|
|
INLOptions *opts = calloc(1, sizeof(INLOptions));
|
|
opts->console_name = "";
|
|
opts->ramdump_filename = "";
|
|
opts->ramwrite_filename = "";
|
|
opts->dump_filename = "";
|
|
opts->mapper_name = "";
|
|
opts->program_filename = "";
|
|
opts->lua_filename = "";
|
|
opts->verify_filename = "";
|
|
|
|
//getopt returns args till done then returns -1
|
|
//string of possible args : denotes 1 required additional arg
|
|
//:: denotes optional additional arg follows
|
|
while((rv = getopt_long(argc, argv, FLAG_FORMAT, longopts, NULL)) != -1) {
|
|
|
|
switch(rv) {
|
|
|
|
case 'a': opts->ramdump_filename = optarg; break;
|
|
case 'b': opts->ramwrite_filename = optarg; break;
|
|
case 'h': opts->display_help = 1; break;
|
|
case 'c': opts->console_name = optarg; break;
|
|
case 'd': opts->dump_filename = optarg; break;
|
|
case 'k': opts->rom_size_kbyte = atoi(optarg); break;
|
|
case 'm': opts->mapper_name = optarg; break;
|
|
case 'p': opts->program_filename = optarg; break;
|
|
case 's': opts->lua_filename = optarg; break;
|
|
case 'v': opts->verify_filename = optarg; break;
|
|
case 'w': opts->wram_size_kb = atoi(optarg); break;
|
|
case 'x': opts->prg_rom_size_kb = atoi(optarg); break;
|
|
case 'y': opts->chr_rom_size_kb = atoi(optarg); break;
|
|
case 'z':
|
|
kbyte = atoi(optarg) * 128;
|
|
if (opts->rom_size_kbyte && opts->rom_size_kbyte != kbyte) {
|
|
printf("rom_size_mbit disagrees with rom_size_kbyte! Using %d Kb as rom size.\n", kbyte);
|
|
}
|
|
opts->rom_size_kbyte = kbyte;
|
|
break;
|
|
case '?':
|
|
if(
|
|
( optopt == 'c' )
|
|
|| ( optopt == 'd' )
|
|
|| ( optopt == 'm' )
|
|
|| ( optopt == 'p' )
|
|
|| ( optopt == 's' )
|
|
){
|
|
log_err("Option -%c requires an argument.", optopt);
|
|
return NULL;
|
|
|
|
} else if ( isprint(optopt)) {
|
|
log_err("Unknown option -%c .", optopt);
|
|
return NULL;
|
|
} else {
|
|
log_err("Unknown option character '\\x%x'", optopt);
|
|
return NULL;
|
|
}
|
|
log_err("Improper arguements passed");
|
|
return NULL;
|
|
break;
|
|
default:
|
|
printf("getopt failed to catch all arg cases");
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
for( index = optind; index < argc; index++) {
|
|
log_err("Non-option arguement: %s \n", argv[index]);
|
|
}
|
|
|
|
if (opts->display_help) {
|
|
printf("%s", HELP);
|
|
return NULL;
|
|
}
|
|
|
|
// Handle console, mapper as case-insensitive configuration.
|
|
strToLower(opts->console_name);
|
|
strToLower(opts->mapper_name);
|
|
return opts;
|
|
}
|
|
|
|
void error_lua (lua_State *L, const char *fmt, ...) {
|
|
va_list argp;
|
|
va_start(argp, fmt);
|
|
vfprintf(stderr, fmt, argp);
|
|
va_end(argp);
|
|
lua_close(L);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
int getglobint (lua_State *L, const char *var) {
|
|
int isnum, result;
|
|
lua_getglobal(L, var);
|
|
result = (int)lua_tointegerx(L, -1, &isnum);
|
|
if (!isnum)
|
|
error_lua(L, "'%s' should be a number\n", var);
|
|
lua_pop(L, 1); /* remove result from the stack */
|
|
return result;
|
|
}
|
|
|
|
void load (lua_State *L, const char *fname, int *w, int *h) {
|
|
if (luaL_loadfile(L, fname) || lua_pcall(L, 0, 0, 0))
|
|
error_lua(L, "cannot run config. file: %s", lua_tostring(L, -1));
|
|
*w = getglobint(L, "width");
|
|
*h = getglobint(L, "height");
|
|
}
|
|
|
|
// Setup Lua environment.
|
|
lua_State *lua_init(INLOptions *opts) {
|
|
lua_State *L = luaL_newstate(); //opens Lua
|
|
luaL_openlibs(L); //opens the standard libraries
|
|
|
|
// Register C functions that can be called from Lua.
|
|
lua_pushcfunction(L, lua_usb_vend_xfr);
|
|
lua_setglobal(L, "usb_vend_xfr");
|
|
|
|
// Pass args to Lua
|
|
// TODO: Do this in a less terrible way / don't register a million globals.
|
|
lua_pushstring(L, opts->console_name);
|
|
lua_setglobal(L, "console_name");
|
|
|
|
lua_pushstring(L, opts->mapper_name);
|
|
lua_setglobal(L, "mapper_name");
|
|
|
|
lua_pushstring(L, opts->dump_filename);
|
|
lua_setglobal(L, "dump_filename");
|
|
|
|
lua_pushstring(L, opts->program_filename);
|
|
lua_setglobal(L, "flash_filename");
|
|
|
|
lua_pushstring(L, opts->verify_filename);
|
|
lua_setglobal(L, "verify_filename");
|
|
|
|
lua_pushstring(L, opts->ramdump_filename);
|
|
lua_setglobal(L, "ramdump_filename");
|
|
|
|
lua_pushstring(L, opts->ramwrite_filename);
|
|
lua_setglobal(L, "ramwrite_filename");
|
|
|
|
lua_pushinteger(L, opts->rom_size_kbyte);
|
|
lua_setglobal(L, "rom_size_kbyte");
|
|
|
|
lua_pushinteger(L, opts->wram_size_kb);
|
|
lua_setglobal(L, "nes_wram_size_kb");
|
|
|
|
lua_pushinteger(L, opts->prg_rom_size_kb);
|
|
lua_setglobal(L, "nes_prg_rom_size_kb");
|
|
|
|
lua_pushinteger(L, opts->chr_rom_size_kb);
|
|
lua_setglobal(L, "nes_chr_rom_size_kb");
|
|
return L;
|
|
}
|
|
|
|
// Setup INL USB Device.
|
|
USBtransfer *usb_init_inldevice(libusb_context *context, int libusb_log) {
|
|
// Create USBtransfer struct to hold all transfer info
|
|
USBtransfer *transfer = calloc(1, sizeof(USBtransfer));
|
|
|
|
// Create USB device handle pointer to interact with retro-prog.
|
|
transfer->handle = open_usb_device( context, libusb_log );
|
|
|
|
return transfer;
|
|
}
|
|
|
|
// Close and cleanup INL USB Device.
|
|
void usb_close_inldevice(libusb_context* context, USBtransfer* transfer) {
|
|
if (context && transfer) {
|
|
close_usb(context, transfer->handle);
|
|
}
|
|
if (transfer) {
|
|
free(transfer);
|
|
}
|
|
}
|
|
|
|
// Safely cleanup for exiting program and release resources.
|
|
void cleanup(libusb_context *context, USBtransfer *transfer, lua_State *L) {
|
|
usb_close_inldevice(context, transfer);
|
|
if (L) {
|
|
lua_close(L);
|
|
}
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
// USB variables
|
|
USBtransfer *transfer = NULL;
|
|
// Context set to NULL since only acting as single user of libusb.
|
|
libusb_context *context = NULL;
|
|
|
|
// Default to no libusb logging.
|
|
int libusb_log = LIBUSB_LOG_LEVEL_NONE;
|
|
|
|
// Lua variables.
|
|
lua_State *L = NULL;
|
|
const char *LUA_SCRIPT_USB = "scripts/app/usb_device.lua";
|
|
|
|
// Parse command-line options and flags.
|
|
INLOptions *opts = parseOptions(argc, argv);
|
|
if(!opts) {
|
|
// If unparseable, exit.
|
|
return 1;
|
|
}
|
|
|
|
// Check for sane user input.
|
|
if (strcmp("nes", opts->console_name) == 0) {
|
|
// ROM sizes must be non-zero, power of 2, and greater than 16.
|
|
if (!isValidROMSize(opts->prg_rom_size_kb, 16)) {
|
|
printf("PRG-ROM must be non-zero power of 2, 16kb or greater.\n");
|
|
return 1;
|
|
}
|
|
// Not having CHR-ROM is normal for certain types of carts.
|
|
// TODO: Update these checks with known info about mappers/carts.
|
|
if (!isValidROMSize(opts->chr_rom_size_kb, 8) && opts->chr_rom_size_kb != 0) {
|
|
printf("CHR-ROM must be zero or power of 2, 8kb or greater.\n");
|
|
return 1;
|
|
}
|
|
|
|
// Not having WRAM is very normal.
|
|
if (!isValidROMSize(opts->wram_size_kb, 8) && opts->wram_size_kb != 0) {
|
|
printf("WRAM must be zero or power of 2, 8kb or greater.\n");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if ((strcmp("gba", opts->console_name) == 0) ||
|
|
(strcmp("n64", opts->console_name) == 0)) {
|
|
if (opts->rom_size_kbyte <= 0) {
|
|
printf("ROM size must be greater than 0 kilobytes.\n");
|
|
return 1;
|
|
}
|
|
if (opts->rom_size_kbyte % 128) {
|
|
printf("ROM size for this system must translate into megabits with no kilobyte remainder.\n");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// Start up Lua.
|
|
L = lua_init(opts);
|
|
|
|
// Setup and check connection to USB Device.
|
|
// TODO get usb device settings from usb_device.lua
|
|
|
|
// Lua script arg to set different libusb debugging options.
|
|
check(!(luaL_loadfile(L, LUA_SCRIPT_USB) || lua_pcall(L, 0, 0, 0)),
|
|
"Cannot run config. file: %s", lua_tostring(L, -1));
|
|
|
|
// Any value > 0 for libusb_log also prints debug statements in open_usb_device function.
|
|
libusb_log = getglobint(L, "libusb_log");
|
|
check(((libusb_log >= LIBUSB_LOG_LEVEL_NONE) && (libusb_log <= LIBUSB_LOG_LEVEL_DEBUG)),
|
|
"Invalid LIBUSB_LOG_LEVEL: %d, must be from 0 to 4", libusb_log );
|
|
|
|
transfer = usb_init_inldevice(context, libusb_log);
|
|
check_mem(transfer);
|
|
check(transfer->handle != NULL, "Unable to open INL retro-prog usb device handle.");
|
|
|
|
// USB device is open, pass args and control over to Lua.
|
|
// If lua_filename isn't set from args, use default script.
|
|
char *DEFAULT_SCRIPT = "scripts/inlretro.lua";
|
|
char *script = DEFAULT_SCRIPT;
|
|
if (strlen(opts->lua_filename)) {
|
|
script = opts->lua_filename;
|
|
}
|
|
check(!(luaL_loadfile(L, script) || lua_pcall(L, 0, 0, 0)),
|
|
"cannot run config. file: %s", lua_tostring(L, -1));
|
|
|
|
// Program flow doesn't come back to this point until script call ends/returns.
|
|
cleanup(context, transfer, L);
|
|
return 0;
|
|
|
|
// 'check' macros goto this label if they fail.
|
|
error:
|
|
printf("Fatal error encountered, exiting.\n");
|
|
cleanup(context, transfer, L);
|
|
return 1;
|
|
}
|