| |
| |
| |
| |
| |
|
|
|
|
| #include "c64.h"
|
| #include "c64_crt.h"
|
| #include "c64_subsys.h"
|
| #include <ctype.h>
|
| #include "init_function.h"
|
| #include "userinterface.h"
|
| #include "u64.h"
|
| #include "c1541.h"
|
| #include "endianness.h"
|
| #if U64 == 2
|
| #include "wifi.h"
|
| #endif
|
|
|
| #define C64_BOOTCRT_DOSYNC 0x014F
|
| #define C64_BOOTCRT_RUNCODE 0x0172
|
| #define C64_BOOTCRT_DRIVENUM 0x0173
|
| #define C64_BOOTCRT_NAMELEN 0x0174
|
| #define C64_BOOTCRT_NAME 0x0175
|
| #define C64_BOOTCRT_HANDSHAKE 0x02
|
| #define C64_BOOTCRT_JUMPADDR 0x00AA
|
|
|
|
|
| extern uint8_t _bootcrt_65_start;
|
| extern uint8_t _bootcrt_65_end;
|
|
|
| static bool contains_path_separator(const char *name)
|
| {
|
| while (*name) {
|
| if ((*name == '/') || (*name == '\\')) {
|
| return true;
|
| }
|
| name++;
|
| }
|
| return false;
|
| }
|
|
|
| static void format_bootcrt_display_name(const char *name, char *display_name)
|
| {
|
| const int kDisplayChars = 16;
|
| const int kTrimmedTailChars = 13;
|
| int length = strlen(name);
|
|
|
| if ((length <= kDisplayChars) || !contains_path_separator(name)) {
|
| strcpy(display_name, name);
|
| return;
|
| }
|
|
|
| memcpy(display_name, "...", 3);
|
| memcpy(display_name + 3, name + length - kTrimmedTailChars, kTrimmedTailChars);
|
| display_name[kDisplayChars] = 0;
|
| }
|
|
|
| cart_def boot_cart;
|
|
|
| static void initBootCart(void *object, void *param)
|
| {
|
| int size = (int)&_bootcrt_65_end - (int)&_bootcrt_65_start;
|
| boot_cart.custom_addr = new uint8_t[8192];
|
| boot_cart.length = size;
|
| boot_cart.type = CART_TYPE_8K;
|
|
|
| memcpy(boot_cart.custom_addr, &_bootcrt_65_start, size);
|
| printf("%d bytes copied into boot_cart.\n", size);
|
| }
|
| InitFunction bootCart_initializer("Boot Cart", initBootCart, NULL, NULL);
|
|
|
| C64_Subsys::C64_Subsys(C64 *machine) : SubSystem(SUBSYSID_C64)
|
| {
|
| taskHandle = 0;
|
| c64 = machine;
|
| fm = FileManager :: getFileManager();
|
| taskHandle = 0;
|
|
|
| taskCategory = TasksCollection :: getCategory("C64 Machine", SORT_ORDER_C64);
|
| }
|
|
|
| C64_Subsys::~C64_Subsys() {
|
| if (taskHandle) {
|
| vTaskDelete(taskHandle);
|
| }
|
|
|
| }
|
|
|
| void C64_Subsys :: create_task_items(void)
|
| {
|
| myActions.reset = new Action("Reset C64", SUBSYSID_C64, MENU_C64_RESET);
|
| myActions.reboot = new Action("Reboot C64", SUBSYSID_C64, MENU_C64_REBOOT);
|
| myActions.clearmem = new Action("Reboot (Clr Mem)", SUBSYSID_C64, MENU_C64_CLEARMEM);
|
| myActions.powercyc = new Action("Power Cycle", SUBSYSID_C64, MENU_C64_POWERCYCLE);
|
| myActions.off = new Action("Power OFF", SUBSYSID_C64, MENU_C64_POWEROFF);
|
| myActions.pause = new Action("Pause", SUBSYSID_C64, MENU_C64_PAUSE);
|
| myActions.resume = new Action("Resume", SUBSYSID_C64, MENU_C64_RESUME);
|
| myActions.savereu = new Action("Save REU Memory", SUBSYSID_C64, MENU_C64_SAVEREU);
|
| myActions.savemem = new Action("Save C64 Memory", SUBSYSID_C64, MENU_U64_SAVERAM);
|
| myActions.save_crt = new Action("Save Cartridge", SUBSYSID_C64, MENU_C64_SAVE_CARTRIDGE);
|
| myActions.savemp3a = new Action("Save MP3 Drv A", SUBSYSID_C64, MENU_C64_SAVE_MP3_DRV_A);
|
| myActions.savemp3b = new Action("Save MP3 Drv B", SUBSYSID_C64, MENU_C64_SAVE_MP3_DRV_B);
|
| myActions.savemp3c = new Action("Save MP3 Drv C", SUBSYSID_C64, MENU_C64_SAVE_MP3_DRV_C);
|
| myActions.savemp3d = new Action("Save MP3 Drv D", SUBSYSID_C64, MENU_C64_SAVE_MP3_DRV_D);
|
| myActions.measure = new Action("Measure Cart Bus", SUBSYSID_C64, MENU_MEASURE_TIMING);
|
|
|
| taskCategory->append(myActions.reset);
|
| taskCategory->append(myActions.reboot);
|
| #if U64
|
| taskCategory->append(myActions.clearmem);
|
| taskCategory->append(myActions.off);
|
| #endif
|
| #if U64 == 2
|
| taskCategory->append(myActions.powercyc);
|
| #endif
|
| #if DEVELOPER > 0
|
| taskCategory->append(myActions.pause);
|
| taskCategory->append(myActions.resume);
|
| taskCategory->append(myActions.measure);
|
| #endif
|
| #if U64
|
| taskCategory->append(myActions.savemem);
|
| #endif
|
| taskCategory->append(myActions.savereu);
|
| taskCategory->append(myActions.save_crt);
|
| taskCategory->append(myActions.savemp3a);
|
| taskCategory->append(myActions.savemp3b);
|
| taskCategory->append(myActions.savemp3c);
|
| taskCategory->append(myActions.savemp3d);
|
| }
|
|
|
| void C64_Subsys :: update_task_items(bool writablePath)
|
| {
|
| if (C64 :: isMP3RamDrive(0) > 0) myActions.savemp3a->show(); else myActions.savemp3a->hide();
|
| if (C64 :: isMP3RamDrive(1) > 0) myActions.savemp3b->show(); else myActions.savemp3b->hide();
|
| if (C64 :: isMP3RamDrive(2) > 0) myActions.savemp3c->show(); else myActions.savemp3c->hide();
|
| if (C64 :: isMP3RamDrive(3) > 0) myActions.savemp3d->show(); else myActions.savemp3d->hide();
|
|
|
| if (C64_CRT :: is_valid()) {
|
| myActions.save_crt->show();
|
| } else {
|
| myActions.save_crt->hide();
|
| }
|
|
|
| if (writablePath) {
|
| #if U64
|
| myActions.savemem ->enable();
|
| #endif
|
| myActions.savereu ->enable();
|
| myActions.save_crt ->enable();
|
| myActions.savemp3a ->enable();
|
| myActions.savemp3b ->enable();
|
| myActions.savemp3c ->enable();
|
| myActions.savemp3d ->enable();
|
| } else {
|
| #if U64
|
| myActions.savemem ->disable();
|
| #endif
|
| myActions.savereu ->disable();
|
| myActions.save_crt ->disable();
|
| myActions.savemp3a ->disable();
|
| myActions.savemp3b ->disable();
|
| myActions.savemp3c ->disable();
|
| myActions.savemp3d ->disable();
|
| }
|
| }
|
|
|
|
|
| void C64_Subsys :: restoreCart(void)
|
| {
|
| for (int i=0; (i<500) && (C64_CARTRIDGE_ACTIVE); i++) {
|
| vTaskDelay(2);
|
| }
|
| if (C64_CARTRIDGE_ACTIVE) {
|
| printf("Error.. cart did not get disabled.\n");
|
| c64->init_cartridge();
|
| } else {
|
| printf("Cart got disabled, now restoring.\n");
|
| c64->set_cartridge(NULL);
|
| C64_CARTRIDGE_KILL = 2;
|
| C64_CARTRIDGE_KILL = 2;
|
| }
|
| }
|
|
|
|
|
| SubsysResultCode_e C64_Subsys::executeCommand(SubsysCommand *cmd)
|
| {
|
| File *f = 0;
|
| FRESULT res;
|
| CachedTreeNode *po;
|
| uint32_t transferred;
|
| int ram_size;
|
| char buffer[64] = "memory";
|
| uint8_t *pb;
|
| SubsysResultCode_e result = SSRET_OK;
|
|
|
| switch (cmd->functionID) {
|
| case C64_PUSH_BUTTON:
|
| c64->setButtonPushed();
|
| break;
|
| case C64_UNFREEZE:
|
| if (c64->client) {
|
| c64->client->release_host();
|
| c64->client = 0;
|
| }
|
| c64->unfreeze();
|
| break;
|
| case MENU_C64_RESET:
|
| if (c64->client) {
|
| c64->client->release_host();
|
| c64->client = 0;
|
| }
|
| c64->unfreeze();
|
| c64->reset();
|
| break;
|
|
|
| case MENU_C64_PAUSE:
|
| c64->stop(false);
|
| break;
|
|
|
| case MENU_C64_RESUME:
|
| c64->resume();
|
| break;
|
|
|
| case MENU_C64_CLEARMEM:
|
| #if U64
|
| if (c64->client) {
|
| c64->client->release_host();
|
| c64->client = 0;
|
| }
|
| c64->clear_ram();
|
| c64->start_cartridge(NULL);
|
| break;
|
| #endif
|
|
|
| case MENU_C64_POWERCYCLE:
|
| #if U64 == 2
|
| wifi_machine_reboot();
|
| #else
|
| result = SSRET_NOT_IMPLEMENTED;
|
| #endif
|
| break;
|
| case MENU_C64_POWEROFF:
|
| #if U64 == 2
|
| wifi_machine_off();
|
| #elif U64 == 1
|
| U64_POWER_REG = 0x2B;
|
| U64_POWER_REG = 0xB2;
|
| U64_POWER_REG = 0x2B;
|
| U64_POWER_REG = 0xB2;
|
| #else
|
| result = SSRET_NOT_IMPLEMENTED;
|
| #endif
|
| break;
|
|
|
| case MENU_C64_REBOOT:
|
| if (c64->client) {
|
| c64->client->release_host();
|
| c64->client = 0;
|
| }
|
| c64->start_cartridge(NULL);
|
| break;
|
|
|
| case C64_START_CART:
|
| if (c64->client) {
|
| c64->client->release_host();
|
| c64->client = 0;
|
| }
|
| c64->start_cartridge((cart_def *)cmd->mode);
|
| break;
|
|
|
| case MENU_C64_SAVEREU:
|
| ram_size = 128 * 1024;
|
| ram_size <<= c64->cfg->get_value(CFG_C64_REU_SIZE);
|
|
|
| if ((cmd->user_interface->string_box("Save REU memory as..", buffer, 22) > 0) && (*buffer)) {
|
| fix_filename(buffer);
|
| set_extension(buffer, ".reu", 32);
|
|
|
| res = create_file_ask_if_exists(fm, cmd->user_interface, cmd->path.c_str(), buffer, &f);
|
| if (res == FR_OK) {
|
| printf("Opened file successfully.\n");
|
|
|
| uint32_t reu_sizes[] =
|
| { 0x20000, 0x40000, 0x80000, 0x100000, 0x200000, 0x400000, 0x800000, 0x1000000 };
|
|
|
| uint32_t current_reu_size = reu_sizes[c64->cfg->get_value(CFG_C64_REU_SIZE)];
|
| uint32_t sectors = (current_reu_size >> 9);
|
| uint32_t secs_per_step = (sectors + 31) >> 5;
|
| uint32_t bytes_per_step = secs_per_step << 9;
|
| uint32_t bytes_written;
|
| uint32_t remain = current_reu_size;
|
| uint8_t *src;
|
| transferred = 0;
|
|
|
| cmd->user_interface->show_progress("Saving REU file..", 32);
|
| src = (uint8_t *)REU_MEMORY_BASE;
|
|
|
| while (remain != 0) {
|
| f->write(src, bytes_per_step, &bytes_written);
|
| transferred += bytes_written;
|
| cmd->user_interface->update_progress(NULL, 1);
|
| remain -= bytes_per_step;
|
| src += bytes_per_step;
|
| }
|
| cmd->user_interface->hide_progress();
|
|
|
| printf("written: %d...", transferred);
|
| sprintf(buffer, "Bytes saved: %d ($%8x)", transferred, transferred);
|
| cmd->user_interface->popup(buffer, BUTTON_OK);
|
|
|
| fm->fclose(f);
|
| } else {
|
| printf("Couldn't open file..\n");
|
| cmd->user_interface->popup(FileSystem::get_error_string(res), BUTTON_OK);
|
| }
|
| }
|
| break;
|
|
|
| case MENU_U64_SAVERAM:
|
| ram_size = 64 * 1024;
|
| if ((cmd->user_interface->string_box("Save RAM as..", buffer, 22) > 0) && (*buffer)) {
|
| fix_filename(buffer);
|
| set_extension(buffer, ".bin", 32);
|
|
|
| res = create_file_ask_if_exists(fm, cmd->user_interface, cmd->path.c_str(), buffer, &f);
|
| if (res == FR_OK) {
|
| printf("Opened file successfully.\n");
|
|
|
| pb = new uint8_t[ram_size];
|
| c64->get_all_memory(pb);
|
|
|
| uint32_t bytes_written;
|
| f->write(pb, ram_size, &bytes_written);
|
|
|
| printf("written: %d...", bytes_written);
|
| sprintf(buffer, "bytes saved: %d ($%8x)", bytes_written, bytes_written);
|
| cmd->user_interface->popup(buffer, BUTTON_OK);
|
|
|
| fm->fclose(f);
|
| delete[] pb;
|
| } else {
|
| printf("Couldn't open file..\n");
|
| cmd->user_interface->popup(FileSystem::get_error_string(res), BUTTON_OK);
|
| }
|
| }
|
| break;
|
|
|
| case MENU_C64_SAVE_CARTRIDGE:
|
| buffer[0] = 0;
|
| if ((cmd->user_interface->string_box("Save Cartridge as..", buffer, 28) > 0) && (*buffer)) {
|
| fix_filename(buffer);
|
| set_extension(buffer, ".crt", 32);
|
|
|
| res = create_file_ask_if_exists(fm, cmd->user_interface, cmd->path.c_str(), buffer, &f);
|
| if (res == FR_OK) {
|
| SubsysResultCode_e retval = C64_CRT::save_crt(f);
|
| fm->fclose(f);
|
| if (retval != SSRET_OK) {
|
| cmd->user_interface->popup(SubsysCommand::error_string(retval), BUTTON_OK);
|
| }
|
| }
|
| }
|
| break;
|
|
|
| case MENU_C64_SAVEFLASH:
|
| res = create_file_ask_if_exists(fm, cmd->user_interface, cmd->path.c_str(), "flash_dump.bin", &f);
|
|
|
| if (res == FR_OK) {
|
| int pages = c64->flash->get_number_of_pages();
|
| int page_size = c64->flash->get_page_size();
|
| uint8_t *page_buf = new uint8_t[page_size];
|
| for (int i = 0; i < pages; i++) {
|
| c64->flash->read_page(i, page_buf);
|
| f->write(page_buf, page_size, &transferred);
|
| }
|
| delete[] page_buf;
|
| fm->fclose(f);
|
| } else {
|
| printf("Couldn't open file..\n");
|
| }
|
| break;
|
|
|
| case MENU_MEASURE_TIMING:
|
| measure_timing(cmd->path.c_str());
|
| break;
|
|
|
| case MENU_MEASURE_TIMING_API:
|
| c64->measure_timing((uint8_t *)cmd->buffer);
|
| break;
|
|
|
| case C64_DMA_LOAD:
|
| res = fm->fopen(cmd->path.c_str(), cmd->filename.c_str(), FA_READ, &f);
|
| if (res == FR_OK) {
|
| dma_load(f, NULL, 0, cmd->filename.c_str(), cmd->mode, c64->cfg->get_value(CFG_C64_DMA_ID));
|
| fm->fclose(f);
|
| } else {
|
| result = SSRET_CANNOT_OPEN_FILE;
|
| }
|
| break;
|
|
|
| #ifndef RECOVERYAPP
|
| case C64_DMA_LOAD_MNT:
|
| res = fm->fopen(cmd->path.c_str(), cmd->filename.c_str(), FA_READ, &f);
|
| if (res == FR_OK) {
|
| dma_load(f, NULL, 0, cmd->filename.c_str(), cmd->mode, c1541_A->get_current_iec_address());
|
| fm->fclose(f);
|
| } else {
|
| result = SSRET_CANNOT_OPEN_FILE;
|
| }
|
| break;
|
| #endif
|
| case C64_DMA_LOAD_RAW:
|
| res = fm->fopen(cmd->path.c_str(), cmd->filename.c_str(), FA_READ, &f);
|
| if (res == FR_OK) {
|
| dma_load_raw(f);
|
| fm->fclose(f);
|
| } else {
|
| result = SSRET_CANNOT_OPEN_FILE;
|
| }
|
| break;
|
| case C64_DRIVE_LOAD:
|
| dma_load(0, NULL, 0, cmd->filename.c_str(), cmd->mode, cmd->path.c_str()[0] & 0x1F);
|
| if (cmd->user_interface) {
|
| cmd->user_interface->menu_response_to_action = MENU_HIDE;
|
| }
|
| break;
|
| case C64_DMA_BUFFER:
|
| dma_load(0, (const uint8_t *)cmd->buffer, cmd->bufferSize, cmd->filename.c_str(), cmd->mode,
|
| c64->cfg->get_value(CFG_C64_DMA_ID));
|
| break;
|
| case C64_DMA_RAW_WRITE:
|
| dma_load_raw_buffer((uint16_t)cmd->mode, (uint8_t *)cmd->buffer, cmd->bufferSize, 0);
|
| break;
|
| case C64_DMA_RAW_READ:
|
| dma_load_raw_buffer((uint16_t)cmd->mode, (uint8_t *)cmd->buffer, cmd->bufferSize, 1);
|
| break;
|
| case C64_STOP_COMMAND:
|
| c64->stop(false);
|
| break;
|
| case MENU_C64_HARD_BOOT:
|
| c64->flash->reboot(0);
|
| break;
|
| case C64_READ_FLASH:
|
| switch (cmd->mode) {
|
| case FLASH_CMD_PAGESIZE:
|
| *(int*)cmd->buffer = c64->flash->get_page_size();
|
| break;
|
| case FLASH_CMD_NOPAGES:
|
| *(int*)cmd->buffer = c64->flash->get_number_of_pages();
|
| break;
|
| default:
|
| if (cmd->bufferSize >= c64->flash->get_page_size())
|
| c64->flash->read_page(cmd->mode - FLASH_CMD_GETPAGE, cmd->buffer);
|
| }
|
| break;
|
| case C64_SET_KERNAL:
|
| c64->enable_kernal((uint8_t*)cmd->buffer);
|
|
|
| break;
|
| case MENU_C64_SAVE_MP3_DRV_A:
|
| case MENU_C64_SAVE_MP3_DRV_B:
|
| case MENU_C64_SAVE_MP3_DRV_C:
|
| case MENU_C64_SAVE_MP3_DRV_D:
|
| {
|
| int devNo = cmd->functionID - MENU_C64_SAVE_MP3_DRV_A;
|
| int ftype = C64::isMP3RamDrive(devNo);
|
| uint8_t* reu = (uint8_t *)(REU_MEMORY_BASE);
|
| int expSize = 1;
|
| const char* extension = 0;
|
|
|
| if (ftype == 1541) {
|
| expSize = 174848;
|
| extension = ".D64";
|
| }
|
| if (ftype == 1571) {
|
| expSize = 2 * 174848;
|
| extension = ".D71";
|
| }
|
| if (ftype == 1581) {
|
| expSize = 819200;
|
| extension = ".D81";
|
| }
|
| if (ftype == DRVTYPE_MP3_DNP) {
|
| expSize = C64::getSizeOfMP3NativeRamdrive(devNo);
|
| extension = ".DNP";
|
| }
|
|
|
| uint8_t ramBase = reu[0x7dc7 + devNo];
|
| uint8_t* srcAddr = reu + (((uint32_t)ramBase) << 16);
|
|
|
| if ((cmd->user_interface->string_box("Save RAMDISK as..", buffer, 22) > 0) && (*buffer)) {
|
| fix_filename(buffer);
|
| set_extension(buffer, extension, 32);
|
|
|
| res = create_file_ask_if_exists(fm, cmd->user_interface, cmd->path.c_str(), buffer, &f);
|
| if (res == FR_OK) {
|
| printf("Opened file successfully.\n");
|
| uint32_t bytes_written;
|
|
|
| if (ftype == 1571) {
|
| f->write(srcAddr, expSize / 2, &bytes_written);
|
| uint32_t tmp;
|
| f->write(srcAddr + 700 * 256, expSize / 2, &tmp);
|
| bytes_written += tmp;
|
| } else {
|
| f->write(srcAddr, expSize, &bytes_written);
|
| }
|
| printf("written: %d...", bytes_written);
|
| sprintf(buffer, "bytes saved: %d ($%8x)", bytes_written, bytes_written);
|
| cmd->user_interface->popup(buffer, BUTTON_OK);
|
|
|
| fm->fclose(f);
|
| } else {
|
| printf("Couldn't open file..\n");
|
| cmd->user_interface->popup(FileSystem::get_error_string(res), BUTTON_OK);
|
| }
|
| }
|
| }
|
| break;
|
|
|
| default:
|
| break;
|
| }
|
|
|
| return result;
|
| }
|
|
|
| int C64_Subsys :: dma_load_raw(File *f)
|
| {
|
| bool i_stopped_it = false;
|
| if (c64->client) {
|
| c64->client->release_host();
|
| c64->release_ownership();
|
| }
|
| if(!c64->isFrozen) {
|
| c64->stop(false);
|
| C64_MODE = MODE_NORMAL;
|
| i_stopped_it = true;
|
| }
|
| int bytes = load_file_dma(f, 0);
|
|
|
| if (i_stopped_it) {
|
| c64->resume();
|
| }
|
| return bytes;
|
| }
|
|
|
| int C64_Subsys :: dma_load_raw_buffer(uint16_t offset, uint8_t *buffer, int length, int rw)
|
| {
|
| bool i_stopped_it = false;
|
| if (c64->client) {
|
| c64->client->release_host();
|
| c64->release_ownership();
|
| }
|
| if(!c64->is_stopped()) {
|
| c64->stop(false);
|
| i_stopped_it = true;
|
| }
|
|
|
| volatile uint8_t *dest = (volatile uint8_t *)(C64_MEMORY_BASE + offset);
|
|
|
| if (rw) {
|
| memcpy(buffer, (void *)dest, length);
|
| } else {
|
| memcpy((void *)dest, buffer, length);
|
| }
|
|
|
| if (i_stopped_it) {
|
| c64->resume();
|
| }
|
| return length;
|
| }
|
|
|
| int C64_Subsys :: dma_load(File *f, const uint8_t *buffer, const int bufferSize,
|
| const char *name, uint8_t run_code, uint8_t drv, uint16_t reloc)
|
| {
|
|
|
| if(c64->client) {
|
| c64->client->release_host();
|
| c64->client = 0;
|
| }
|
| if(!c64->isFrozen) {
|
| c64->stop(false);
|
| }
|
|
|
| C64_POKE(C64_BOOTCRT_RUNCODE, run_code);
|
|
|
| C64_POKE(C64_BOOTCRT_DOSYNC, (c64->cfg->get_value(CFG_C64_DO_SYNC) == 1) ? 1 : 0);
|
|
|
| char display_name[17];
|
| format_bootcrt_display_name(name, display_name);
|
|
|
| CbmFileName cbm;
|
| cbm.init(display_name);
|
| const char *p = cbm.getName();
|
| for(int i=0; i<16; i++) {
|
| C64_POKE(C64_BOOTCRT_NAME+i, p[i]);
|
| }
|
| C64_POKE(C64_BOOTCRT_NAMELEN, strlen(p));
|
|
|
| C64_POKE(C64_BOOTCRT_HANDSHAKE, 0x80);
|
|
|
| boot_cart.custom_addr = (void *)&_bootcrt_65_start;
|
| c64->start_cartridge(&boot_cart);
|
|
|
|
|
| wait_ms(100);
|
|
|
|
|
| c64->stop(false);
|
|
|
| C64_POKE(C64_BOOTCRT_DRIVENUM, drv);
|
|
|
| C64_POKE(C64_BOOTCRT_HANDSHAKE, 0x40);
|
|
|
| if ( !(run_code & RUNCODE_REAL_BIT) ) {
|
| int timeout = 0;
|
| while(C64_PEEK(2) != 0x01) {
|
| c64->resume();
|
| timeout++;
|
| if(timeout == 60) {
|
| c64->init_cartridge();
|
| return -1;
|
| }
|
| wait_ms(25);
|
| printf("_");
|
| c64->stop(false);
|
| }
|
| if (f) {
|
| load_file_dma(f, 0);
|
| } else {
|
|
|
| if (run_code & RUNCODE_JUMP_BIT) {
|
| C64_POKE(C64_BOOTCRT_JUMPADDR, buffer[0]);
|
| C64_POKE(C64_BOOTCRT_JUMPADDR+1, buffer[1]);
|
| load_buffer_dma(buffer+2, bufferSize-2, 0);
|
| } else {
|
| load_buffer_dma(buffer, bufferSize, 0);
|
| }
|
| }
|
|
|
| C64_POKE(C64_BOOTCRT_HANDSHAKE, 0);
|
| C64_POKE(C64_BOOTCRT_RUNCODE, run_code);
|
| C64_POKE(0x00BA, drv);
|
| }
|
|
|
| printf("Resuming..\n");
|
| c64->resume();
|
|
|
| restoreCart();
|
| return 0;
|
| }
|
|
|
| int C64_Subsys :: load_file_dma(File *f, uint16_t reloc)
|
| {
|
| uint32_t dma_load_buffer[128];
|
| uint32_t transferred = 0;
|
| uint16_t load_address = 0;
|
| uint8_t *dma_load_buffer_b;
|
| dma_load_buffer_b = (uint8_t *)dma_load_buffer;
|
|
|
| if (f) {
|
| f->read(&load_address, 2, &transferred);
|
| if(transferred != 2) {
|
| printf("Can't read from file..\n");
|
| return -1;
|
| }
|
| load_address = le2cpu(load_address);
|
| printf("Load address: %4x...", load_address);
|
| }
|
| if(reloc) {
|
| load_address = reloc;
|
| printf(" -> %4x ..", load_address);
|
| }
|
| int max_length = 65536 - int(load_address);
|
| int block = 510;
|
| printf("Now loading...");
|
| volatile uint8_t *dest = (volatile uint8_t *)(C64_MEMORY_BASE + load_address);
|
|
|
|
|
| int total_trans = 0;
|
| while (max_length > 0) {
|
| FRESULT fres = f->read(dma_load_buffer, block, &transferred);
|
| if (fres != FR_OK) {
|
| printf("Error reading from file. %s\n", FileSystem :: get_error_string(fres));
|
| return -1;
|
| }
|
|
|
| total_trans += transferred;
|
| volatile uint8_t *d = dest;
|
| for (int i=0;i<transferred;i++) {
|
| *(d++) = dma_load_buffer_b[i];
|
| }
|
| if (transferred < block) {
|
| break;
|
| }
|
| dest += transferred;
|
| max_length -= transferred;
|
| block = (max_length > 512) ? 512 : max_length;
|
| }
|
| uint16_t end_address = load_address + total_trans;
|
| printf("DMA load complete: $%4x-$%4x\n", load_address, end_address);
|
|
|
|
|
|
|
| C64_POKE(0x002D, end_address);
|
| C64_POKE(0x002E, end_address >> 8);
|
| C64_POKE(0x002F, end_address);
|
| C64_POKE(0x0030, end_address >> 8);
|
| C64_POKE(0x0031, end_address);
|
| C64_POKE(0x0032, end_address >> 8);
|
| C64_POKE(0x00AE, end_address);
|
| C64_POKE(0x00AF, end_address >> 8);
|
|
|
| C64_POKE(0x0090, 0x40);
|
| C64_POKE(0x0035, 0);
|
| C64_POKE(0x0036, 0xA0);
|
|
|
| return total_trans;
|
| }
|
|
|
| int C64_Subsys :: load_buffer_dma(const uint8_t *buffer, const int bufferSize, uint16_t reloc)
|
| {
|
| uint16_t load_address = 0;
|
|
|
| load_address = (uint16_t)buffer[0] | ((uint16_t)buffer[1]) << 8;
|
| printf("Load address: %4x...", load_address);
|
|
|
| if (reloc) {
|
| load_address = reloc;
|
| printf(" -> %4x ..", load_address);
|
| }
|
| volatile uint8_t *dest = (volatile uint8_t *)(C64_MEMORY_BASE + load_address);
|
|
|
| memcpy((void *)dest, buffer + 2, bufferSize - 2);
|
|
|
| uint16_t end_address = load_address + bufferSize - 2;
|
| printf("DMA load complete: $%4x-$%4x\n", load_address, end_address);
|
|
|
|
|
|
|
| C64_POKE(0x002D, end_address);
|
| C64_POKE(0x002E, end_address >> 8);
|
| C64_POKE(0x002F, end_address);
|
| C64_POKE(0x0030, end_address >> 8);
|
| C64_POKE(0x0031, end_address);
|
| C64_POKE(0x0032, end_address >> 8);
|
| C64_POKE(0x00AE, end_address);
|
| C64_POKE(0x00AF, end_address >> 8);
|
|
|
| C64_POKE(0x0090, 0x40);
|
| C64_POKE(0x0035, 0);
|
| C64_POKE(0x0036, 0xA0);
|
|
|
| return bufferSize - 2;
|
| }
|
|
|
| bool C64_Subsys :: write_vic_state(File *f)
|
| {
|
| uint32_t transferred;
|
| uint8_t mode = C64_MODE;
|
| C64_MODE = 0;
|
|
|
|
|
| uint8_t bank = 3 - (c64->cia_backup[1] & 0x03);
|
| uint32_t addr = C64_MEMORY_BASE + (uint32_t(bank) << 14);
|
| if(bank == 0) {
|
| f->write((uint8_t *)C64_MEMORY_BASE, 0x0400, &transferred);
|
| f->write(c64->screen_backup, 0x0400, &transferred);
|
| f->write(c64->ram_backup, 0x0800, &transferred);
|
| f->write((uint8_t *)(C64_MEMORY_BASE + 0x1000), 0x3000, &transferred);
|
| } else {
|
| f->write((uint8_t *)addr, 16384, &transferred);
|
| }
|
| f->write(c64->color_backup, 0x0400, &transferred);
|
| f->write(c64->vic_backup, NUM_VICREGS, &transferred);
|
|
|
| C64_MODE = mode;
|
| return true;
|
| }
|
|
|
| void C64_Subsys :: measure_timing(const char *path)
|
| {
|
| uint8_t *buffer = new uint8_t[64 * 1024];
|
|
|
| c64->measure_timing(buffer);
|
|
|
|
|
| mstring fn(path);
|
| fn += "bus_measurement.bin";
|
| FILE *fo = fopen(fn.c_str(), "wb");
|
| if (fo) {
|
| int t = fwrite(buffer, 2048, 32, fo);
|
| printf("%d blocks written.\n", t);
|
| fclose(fo);
|
| } else {
|
| printf("Couldn't open file %s\n", fn.c_str());
|
| }
|
|
|
| delete[] buffer;
|
| }
|
|
|
