CFLAGS = -g -O0 -Wall -Werror -I.. -I$(LIBUSB)/include -I$(SQUIRREL)/include -DDEBUG=1 -DANAGO=1
LDFLAG = -L. -L$(LIBUSB)/lib/gcc -L$(SQUIRREL)/lib
CC = gcc
-OBJ = anago.o header.o crc32.o file.o script_flash.o script_dump.o \
+OBJ = anago.o header.o crc32.o file.o \
+ script_flash.o script_dump.o script_common.o \
progress.o flash_device.o \
reader_dummy.o reader_kazzo.o usb_device.o squirrel_wrap.o memory_manage.o
clean:
mega <- 0x20000;
function dump(d, mappernum, increase_cpu, increase_ppu)
{
+ local vram = board.vram_mirrorfind == true ? 1 : 0;
if(mappernum == -1){
mappernum = board.mappernum;
}
cpu_dump(d, board.cpu_romsize * increase_cpu / board.cpu_banksize, board.cpu_banksize);
if(board.ppu_ramfind == true){
if(ppu_ramfind(d) == true){
- nesfile_save(d, mappernum);
+ nesfile_save(d, mappernum, vram);
return;
}
}
if(board.ppu_romsize != 0){
ppu_dump(d, board.ppu_romsize * increase_ppu / board.ppu_banksize, board.ppu_banksize);
}
- nesfile_save(d, mappernum);
+ nesfile_save(d, mappernum, vram);
return;
}
s[0] = 0x01;
s[1] = 0xa4;
}
+static uint8_t dummy_vram_connection(void)
+{
+ return 0x05;
+}
const struct reader_driver DRIVER_DUMMY = {
.name = "tester",
.open_or_close = dummy_open_close,
.init = dummy_init,
.cpu_read = dummy_cpu_read, .ppu_read = dummy_ppu_read,
.cpu_write_6502 = dummy_cpu_write_6502,
- .flash_support = OK,
+ .flash_support = true,
.ppu_write = dummy_ppu_write,
.cpu_flash_config = dummy_cpu_flash_config,
.cpu_flash_erase = dummy_cpu_flash_erase,
.ppu_flash_erase = dummy_ppu_flash_erase,
.ppu_flash_program = dummy_ppu_flash_program,
.ppu_flash_device_get = dummy_flash_device_get,
- .flash_status = dummy_flash_status
+ .flash_status = dummy_flash_status,
+ .vram_connection = dummy_vram_connection
};
--- /dev/null
+#include <assert.h>
+#include <stdio.h>
+#include <squirrel.h>
+#include <sqstdio.h>
+#include <sqstdaux.h>
+#include "type.h"
+#include "squirrel_wrap.h"
+#include "script_common.h"
+
+SQInteger script_nop(HSQUIRRELVM v)
+{
+ return 0;
+}
+
+SQInteger range_check(HSQUIRRELVM v, const char *name, long target, const struct range *range)
+{
+ if((target < range->start) || (target > range->end)){
+ printf("%s range must be 0x%06x to 0x%06x", name, (int) range->start, (int) range->end);
+ return sq_throwerror(v, "script logical error");
+ }
+ return 0;
+}
+
+SQInteger cpu_write_check(HSQUIRRELVM v)
+{
+ static const struct range range_address = {0x4000, 0x10000};
+ static const struct range range_data = {0x0, 0xff};
+ long address, data;
+ SQRESULT r = qr_argument_get(v, 2, &address, &data);
+ if(SQ_FAILED(r)){
+ return r;
+ }
+ r = range_check(v, "address", address, &range_address);
+ if(SQ_FAILED(r)){
+ return r;
+ }
+ return range_check(v, "data", data, &range_data);
+}
--- /dev/null
+#ifndef _SCRIPT_COMMON_H_
+#define _SCRIPT_COMMON_H_
+struct range{
+ long start, end;
+};
+SQInteger script_nop(HSQUIRRELVM v);
+SQInteger range_check(HSQUIRRELVM v, const char *name, long target, const struct range *range);
+SQInteger cpu_write_check(HSQUIRRELVM v);
+#endif
#include "memory_manage.h"
#include "reader_master.h"
#include "squirrel_wrap.h"
+#include "script_common.h"
#include "script_dump.h"
struct dump_driver{
void (*const write)(long address, long length, const uint8_t *data);
void (*const read)(long address, long length, u8 *data);
}cpu, ppu;
+ uint8_t (*const vram_connection)(void);
bool progress;
};
static SQInteger write(HSQUIRRELVM v, struct memory_driver *t)
return r;
}
struct romimage image;
- r = qr_argument_get(v, 1, &image.mappernum);
+ long mirrorfind;
+ r = qr_argument_get(v, 2, &image.mappernum, &mirrorfind);
if(SQ_FAILED(r)){
return r;
}
image.cpu_ram.data = NULL;
image.ppu_rom = d->ppu.memory;
image.mirror = MIRROR_PROGRAMABLE;
+ if(mirrorfind == 1){
+ if(d->vram_connection() == 0x05){
+ image.mirror = MIRROR_VERTICAL;
+ }else{
+ image.mirror = MIRROR_HORIZONAL;
+ }
+ }
image.backupram = 0;
nesfile_create(&image, d->target);
nesbuffer_free(&image, 0); //0 is MODE_xxx_xxxx
}
return r;
}
-static SQInteger script_nop(HSQUIRRELVM v)
-{
- return 0;
-}
-struct range{
- long start, end;
-};
-static SQInteger range_check(HSQUIRRELVM v, const char *name, long target, const struct range *range)
-{
- if((target < range->start) || (target > range->end)){
- printf("%s range must be 0x%06x to 0x%06x", name, (int) range->start, (int) range->end);
- return sq_throwerror(v, "script logical error");
- }
- return 0;
-}
static SQInteger read_count(HSQUIRRELVM v, struct memory_driver *t, const struct range *range_address, const struct range *range_length)
{
long address, length;
return read_count(v, &d->ppu, &range_address, &range_length);
}
-static SQInteger cpu_write_check(HSQUIRRELVM v)
-{
- static const struct range range_address = {0x4000, 0x10000};
- static const struct range range_data = {0x0, 0xff};
- long address, data;
- SQRESULT r = qr_argument_get(v, 2, &address, &data);
- if(SQ_FAILED(r)){
- return r;
- }
- r = range_check(v, "address", address, &range_address);
- if(SQ_FAILED(r)){
- return r;
- }
- return range_check(v, "data", data, &range_data);
-}
static bool script_execute(HSQUIRRELVM v, struct config_dump *c, struct dump_driver *d)
{
bool ret = true;
.write = c->reader->ppu_write,
.read = c->reader->ppu_read
},
+ .vram_connection = c->reader->vram_connection,
.target = c->target,
.progress = c->progress
};
#include "squirrel_wrap.h"
#include "flash_device.h"
#include "progress.h"
+#include "script_common.h"
#include "script_flash.h"
struct anago_driver{
printf("erasing %s memory...\n", region);
fflush(stdout);
}
- return 0; //sq_suspendvm(v);
+ return 0;
}
static SQInteger cpu_erase(HSQUIRRELVM v)
{
return 0;
}
-static SQInteger script_nop(HSQUIRRELVM v)
-{
- return 0;
-}
-
-static SQInteger program_count(HSQUIRRELVM v, struct anago_flash_order *t)
+static SQInteger program_count(HSQUIRRELVM v, struct anago_flash_order *t, const struct range *range_address, const struct range *range_length)
{
SQRESULT r = qr_argument_get(v, 2, &t->address, &t->length);
if(SQ_FAILED(r)){
return r;
}
+ r = range_check(v, "length", t->length, range_length);
+ if(SQ_FAILED(r)){
+ return r;
+ }
+ if((t->address < range_address->start) || ((t->address + t->length) > range_address->end)){
+ printf("address range must be 0x%06x to 0x%06x", (int) range_address->start, (int) range_address->end);
+ return sq_throwerror(v, "script logical error");;
+ }
t->program_count += t->length;
return 0;
}
static SQInteger cpu_program_count(HSQUIRRELVM v)
{
+ static const struct range range_address = {0x8000, 0x10000};
+ static const struct range range_length = {0x0100, 0x4000};
struct anago_driver *d;
SQRESULT r = qr_userpointer_get(v, (SQUserPointer *) &d);
if(SQ_FAILED(r)){
return r;
}
- return program_count(v, &d->order_cpu);
+ return program_count(v, &d->order_cpu, &range_address, &range_length);
}
static SQInteger ppu_program_count(HSQUIRRELVM v)
{
+ static const struct range range_address = {0x0000, 0x2000};
+ static const struct range range_length = {0x0100, 0x2000};
struct anago_driver *d;
SQRESULT r = qr_userpointer_get(v, (SQUserPointer *) &d);
if(SQ_FAILED(r)){
return r;
}
- return program_count(v, &d->order_ppu);
+ return program_count(v, &d->order_ppu, &range_address, &range_length);
}
-static bool script_testrun(struct config_flash *c, struct anago_driver *d)
+static bool script_execute(HSQUIRRELVM v, struct config_flash *c, struct anago_driver *d)
{
- static const char *functionname[] = {
- "cpu_write", "cpu_erase", "cpu_command",
- "ppu_write", "ppu_erase", "ppu_command",
- "erase_wait", "program_main"
- };
- HSQUIRRELVM v = qr_open();
- int i;
- for(i = 0; i < sizeof(functionname)/sizeof(char *); i++){
- qr_function_register_global(v, functionname[i], script_nop);
- }
- qr_function_register_global(v, "cpu_program", cpu_program_count);
- qr_function_register_global(v, "ppu_program", ppu_program_count);
-
bool ret = true;
if(SQ_FAILED(sqstd_dofile(v, _SC("flashcore.nut"), SQFalse, SQTrue))){
printf("flash core script error\n");
printf("%s open error\n", c->script);
ret = false;
}else{
- qr_call(
+ SQRESULT r = qr_call(
v, "program", (SQUserPointer) d, true,
5, c->rom.mappernum,
d->order_cpu.memory->transtype, d->order_cpu.memory->size,
d->order_ppu.memory->transtype, d->order_ppu.memory->size
);
+ if(SQ_FAILED(r)){
+ ret = false;
+ }
}
-
- qr_close(v);
return ret;
}
+
void script_flash_execute(struct config_flash *c)
{
struct anago_driver d = {
},
.flash_status = c->reader->flash_status
};
- if(script_testrun(c, &d) == false){
- return;
+ {
+ static const char *functionname[] = {
+ "cpu_erase", "ppu_erase",
+ "erase_wait", "program_main"
+ };
+ HSQUIRRELVM v = qr_open();
+ int i;
+ for(i = 0; i < sizeof(functionname)/sizeof(char *); i++){
+ qr_function_register_global(v, functionname[i], script_nop);
+ }
+ qr_function_register_global(v, "cpu_write", cpu_write_check);
+ qr_function_register_global(v, "cpu_command", cpu_command);
+ qr_function_register_global(v, "cpu_program", cpu_program_count);
+
+ qr_function_register_global(v, "ppu_program", ppu_program_count);
+ qr_function_register_global(v, "ppu_command", ppu_command);
+
+ if(script_execute(v, c, &d) == false){
+ qr_close(v);
+ return;
+ }
+ qr_close(v);
}
-
- HSQUIRRELVM v = qr_open();
- qr_function_register_global(v, "cpu_write", cpu_write);
- qr_function_register_global(v, "cpu_erase", cpu_erase);
- qr_function_register_global(v, "cpu_program", cpu_program_memory);
- qr_function_register_global(v, "cpu_command", cpu_command);
- qr_function_register_global(v, "ppu_erase", ppu_erase);
- qr_function_register_global(v, "ppu_program", ppu_program_memory);
- qr_function_register_global(v, "ppu_command", ppu_command);
- qr_function_register_global(v, "program_main", program_main);
- qr_function_register_global(v, "erase_wait", erase_wait);
-
- if(SQ_FAILED(sqstd_dofile(v, _SC("flashcore.nut"), SQFalse, SQTrue))){
- printf("flash core script error\n");
- }else if(SQ_FAILED(sqstd_dofile(v, _SC(c->script), SQFalse, SQTrue))){
- printf("%s open error\n", c->script);
- }else{
- qr_call(
- v, "program", (SQUserPointer) &d, true,
- 5, c->rom.mappernum,
- d.order_cpu.memory->transtype, d.order_cpu.memory->size,
- d.order_ppu.memory->transtype, d.order_ppu.memory->size
- );
+ d.order_cpu.command_change = true;
+ d.order_ppu.command_change = true;
+ {
+ HSQUIRRELVM v = qr_open();
+ qr_function_register_global(v, "cpu_write", cpu_write);
+ qr_function_register_global(v, "cpu_erase", cpu_erase);
+ qr_function_register_global(v, "cpu_program", cpu_program_memory);
+ qr_function_register_global(v, "cpu_command", cpu_command);
+ qr_function_register_global(v, "ppu_erase", ppu_erase);
+ qr_function_register_global(v, "ppu_program", ppu_program_memory);
+ qr_function_register_global(v, "ppu_command", ppu_command);
+ qr_function_register_global(v, "program_main", program_main);
+ qr_function_register_global(v, "erase_wait", erase_wait);
+ script_execute(v, c, &d);
+ qr_close(v);
}
-
- qr_close(v);
}
{
read_main(REQUEST_PPU_FLASH_DEVICE, 0, 2, s);
}
+static uint8_t kazzo_vram_connection(void)
+{
+ uint8_t s;
+ read_main(REQUEST_VRAM_CONNECTION, 0, 1, &s);
+ return s;
+}
const struct reader_driver DRIVER_KAZZO = {
.name = "kazzo",
.open_or_close = kazzo_open_close,
.init = kazzo_init,
.cpu_read = kazzo_cpu_read, .ppu_read = kazzo_ppu_read,
.cpu_write_6502 = kazzo_cpu_write_6502,
- .flash_support = OK,
+ .flash_support = true,
.ppu_write = kazzo_ppu_write,
.cpu_flash_config = kazzo_cpu_flash_config,
.cpu_flash_erase = kazzo_cpu_flash_erase,
.ppu_flash_erase = kazzo_ppu_flash_erase,
.ppu_flash_program = kazzo_ppu_flash_program,
.ppu_flash_device_get = kazzo_ppu_flash_device_get,
- .flash_status = kazzo_flash_status
+ .flash_status = kazzo_flash_status,
+ .vram_connection = kazzo_vram_connection
};
void (*cpu_write_6502)(long address, long length, const uint8_t *data);
void (*ppu_read)(long address, long length, uint8_t *data);
void (*ppu_write)(long address, long length, const uint8_t *data);
- int flash_support;
+ bool flash_support;
void (*cpu_flash_config)(long c000x, long c2aaa, long c5555, long unit);
void (*cpu_flash_erase)(long address, bool wait);
long (*cpu_flash_program)(long address, long length, const uint8_t *data, bool wait);
long (*ppu_flash_program)(long address, long length, const uint8_t *data, bool wait);
void (*ppu_flash_device_get)(uint8_t s[2]);
void (*flash_status)(uint8_t s[2]);
+ uint8_t (*vram_connection)(void);
};
int paralellport_open_or_close(enum reader_control oc);
const struct reader_driver *reader_driver_get(const char *name);
OSDN Git Service
