509 lines
15 KiB
C++
509 lines
15 KiB
C++
//define USE_LOGGING
|
|
//======================================================================
|
|
// This file is part of VCC (Virtual Color Computer).
|
|
// Vcc is Copyright 2015 by Joseph Forgione
|
|
//
|
|
// VCC (Virtual Color Computer) is free software, you can redistribute
|
|
// and/or modify it under the terms of the GNU General Public License
|
|
// as published by the Free Software Foundation, either version 3 of
|
|
// the License, or (at your option) any later version.
|
|
//
|
|
// VCC (Virtual Color Computer) is distributed in the hope that it will
|
|
// be useful, but WITHOUT ANY WARRANTY; without even the implied
|
|
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with VCC (Virtual Color Computer). If not, see
|
|
// <http://www.gnu.org/licenses/>.
|
|
//======================================================================
|
|
//
|
|
// As of VCC version 2.1.10 the MPI cartridge no longer loads DLL and
|
|
// ROM files that represent cartridges. Instead it sends messages to
|
|
// pakinterface with cartridge update requests. An invidible proxy
|
|
// window is used to forward the messages so messaging is not affected
|
|
// by VCC full screen toggles.
|
|
//
|
|
// An array of 5 slots holds the cartridge objects used to keep track of
|
|
// loaded cartridges. Slot 0 is the COCO boot slot and slots 1-4 are
|
|
// mulipak slots.
|
|
//
|
|
//======================================================================
|
|
|
|
#include "defines.h"
|
|
#include "../../src/core/tcc1014mmu.h"
|
|
#include "../../src/core/tcc1014registers.h"
|
|
#include "pakinterface.h"
|
|
#include "config.h"
|
|
#include "Vcc.h"
|
|
#include "../../src/core/mc6821.h"
|
|
#include "resource.h"
|
|
#include "pakrouter.h"
|
|
#include <vcc/bus/null_cartridge.h>
|
|
#include <vcc/bus/cartridge_menu.h>
|
|
#include <vcc/bus/cartridge_messages.h>
|
|
#include <vcc/util/limits.h>
|
|
#include <vcc/util/logger.h>
|
|
#include <vcc/util/FileOps.h>
|
|
#include <vcc/util/DialogOps.h>
|
|
#include <fstream>
|
|
#include <Windows.h>
|
|
#include <commdlg.h>
|
|
|
|
using cartridge_loader_status = VCC::Core::cartridge_loader_status;
|
|
using cartridge_loader_result = VCC::Core::cartridge_loader_result;
|
|
|
|
// Storage for Pak ROMs
|
|
extern SystemState EmuState;
|
|
|
|
static VCC::Util::critical_section gPakMutex;
|
|
static char DllPath[MAX_PATH] = "";
|
|
|
|
void CartMenuCallBack(const char* name, int menu_id, MenuItemType type);
|
|
|
|
// Arrays for holding cartridge slots. Slot 0 is boot slot.
|
|
#define NumCartSlots 5
|
|
using plugin_ptr = cartridge_loader_result::cartridge_ptr_type;
|
|
static std::array<plugin_ptr, NumCartSlots> gCartSlots{
|
|
std::make_unique<VCC::Core::null_cartridge>(),
|
|
std::make_unique<VCC::Core::null_cartridge>(),
|
|
std::make_unique<VCC::Core::null_cartridge>(),
|
|
std::make_unique<VCC::Core::null_cartridge>(),
|
|
std::make_unique<VCC::Core::null_cartridge>()
|
|
};
|
|
|
|
// Router object manages cartridge exports and callbacks
|
|
static VCC::Core::PakRouter gPakRouter(gCartSlots);
|
|
|
|
// A list of smart handles for unloading dll's
|
|
using module_ptr = cartridge_loader_result::dll_module_type;
|
|
static std::array<module_ptr, NumCartSlots> gCartDlls{};
|
|
|
|
void UnloadCartridge(int slot);
|
|
static cartridge_loader_status load_any_cartridge(int slot, const char *filename);
|
|
|
|
//--------------------------------------------------------
|
|
// Define cartridge callbacks for the router
|
|
//--------------------------------------------------------
|
|
|
|
static void write_memory_byte_impl(size_t slot, unsigned char val, unsigned short adr) {
|
|
gPakRouter.cart_write_memory(slot, val, adr);
|
|
}
|
|
|
|
static unsigned char read_memory_byte_impl(size_t slot,unsigned short adr) {
|
|
return gPakRouter.cart_read_memory(slot, adr);
|
|
}
|
|
|
|
static void assert_cart_line_impl(size_t slot,bool state) {
|
|
gPakRouter.cart_assert_line(slot, state);
|
|
}
|
|
|
|
static void assert_interrupt_impl(size_t slot, Interrupt intr, InterruptSource src) {
|
|
gPakRouter.cart_assert_interrupt(slot, intr, src);
|
|
}
|
|
|
|
struct cpak_callbacks slot_callbacks = {
|
|
assert_interrupt_impl,
|
|
assert_cart_line_impl,
|
|
write_memory_byte_impl,
|
|
read_memory_byte_impl
|
|
};
|
|
|
|
//--------------------------------------------------------
|
|
// Define cartridge exports for pakrouter.
|
|
//--------------------------------------------------------
|
|
|
|
// Send hsync to all loaded carts
|
|
void PakTimer()
|
|
{
|
|
VCC::Util::section_locker lock(gPakMutex);
|
|
gPakRouter.horizontal_sync();
|
|
}
|
|
|
|
// Send reset to all loaded carts. This gets called when VCC is reset.
|
|
void ResetBus()
|
|
{
|
|
DLOG_C("\npakinterface ResetBus()\n");
|
|
VCC::Util::section_locker lock(gPakMutex);
|
|
gPakRouter.reset();
|
|
}
|
|
|
|
// Gather status line for all loaded carts
|
|
void GetModuleStatus(SystemState *SMState)
|
|
{
|
|
gPakRouter.plugin_status(SMState->StatusLine,sizeof(SMState->StatusLine));
|
|
}
|
|
|
|
unsigned char PakReadPort (unsigned char port)
|
|
{
|
|
VCC::Util::section_locker lock(gPakMutex);
|
|
return gPakRouter.read_port(port);
|
|
}
|
|
|
|
void PakWritePort(unsigned char Port,unsigned char Data)
|
|
{
|
|
VCC::Util::section_locker lock(gPakMutex);
|
|
gPakRouter.write_port(Port,Data);
|
|
}
|
|
|
|
unsigned char PackMem8Read (unsigned short Address)
|
|
{
|
|
VCC::Util::section_locker lock(gPakMutex);
|
|
return gPakRouter.read_memory_byte(Address&32767);
|
|
}
|
|
|
|
unsigned short PackAudioSample()
|
|
{
|
|
VCC::Util::section_locker lock(gPakMutex);
|
|
return gPakRouter.sample_audio();
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
// Build Plugin dynamic menus
|
|
//--------------------------------------------------------
|
|
void BuildCartMenu()
|
|
{
|
|
//VCC::Util::section_locker lock(gPakMutex);
|
|
using VCC::Bus::gVccCartMenu;
|
|
gVccCartMenu.clear();
|
|
|
|
// Item to remove cart in boot slot.
|
|
if (!gCartSlots[0]->name().empty()) {
|
|
std::string tmp = "&Eject " + gCartSlots[0]->name();
|
|
gVccCartMenu.add(tmp, ControlId(2), MIT_StandAlone);
|
|
}
|
|
|
|
// Items to load the boot slot
|
|
if (gPakRouter.mpi_not_active()) {
|
|
gVccCartMenu.add("Load &MPI", ControlId(3), MIT_StandAlone);
|
|
}
|
|
gVccCartMenu.add("Load &DLL", ControlId(1), MIT_StandAlone);
|
|
gVccCartMenu.add("Load &ROM", ControlId(4), MIT_StandAlone);
|
|
|
|
// Items from loaded plugins
|
|
for (int slot : {0, 4, 3, 2, 1}) {
|
|
auto* cart = gCartSlots[slot].get();
|
|
if (!cart) continue;
|
|
for (int ndx = 0; ndx < MAX_MENU_ITEMS; ndx++) {
|
|
menu_item_entry item;
|
|
if (!cart->get_menu_item(&item, ndx)) break;
|
|
// Bias menu id's for slot location
|
|
if (item.menu_id >= MID_CONTROL)
|
|
item.menu_id += (slot * 50);
|
|
gVccCartMenu.add(item.name,item.menu_id,item.type);
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
// Dialog for loading boot slot plugin
|
|
//--------------------------------------------------------
|
|
void LoadCartridgeDialog(int type)
|
|
{
|
|
char inifile[MAX_PATH];
|
|
GetIniFilePath(inifile);
|
|
|
|
static char cartDir[MAX_PATH] = "";
|
|
FileDialog dlg;
|
|
if (type == 0) {
|
|
dlg.setTitle(TEXT("Load Program Pack"));
|
|
dlg.setFilter("Hardware Packs\0*.dll\0"
|
|
"All Supported Formats (*.dll;*.ccc;*.rom)\0*.dll;*.ccc;*.rom\0\0");
|
|
Setting().read("DefaultPaths", "DLLPath", "", cartDir, MAX_PATH);
|
|
} else {
|
|
dlg.setTitle(TEXT("Load ROM"));
|
|
dlg.setFilter("Rom Packs(*.ccc;*.rom)\0*.ccc;*.rom\0"
|
|
"All Supported Formats (*.dll;*.ccc;*.rom)\0*.dll;*.ccc;*.rom\0\0");
|
|
Setting().read("DefaultPaths", "RomPath", "", cartDir, MAX_PATH);
|
|
}
|
|
dlg.setInitialDir(cartDir);
|
|
dlg.setFlags(OFN_FILEMUSTEXIST);
|
|
if (dlg.show()) {
|
|
auto status = PakLoadCartridge(dlg.path());
|
|
if (status == cartridge_loader_status::success) {
|
|
char filetype[4];
|
|
dlg.getdir(cartDir);
|
|
dlg.gettype(filetype);
|
|
if ((strcmp(filetype,"dll") == 0) | (strcmp(filetype,"DLL") == 0 )) { // DLL?
|
|
Setting().write("DefaultPaths", "DLLPath", cartDir);
|
|
} else {
|
|
Setting().write("DefaultPaths", "RomPath", cartDir);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
// Load cartridge to boot slot
|
|
//--------------------------------------------------------
|
|
|
|
cartridge_loader_status PakLoadCartridge(const char* filename)
|
|
{
|
|
static const std::map<cartridge_loader_status, UINT> string_id_map = {
|
|
{ cartridge_loader_status::already_loaded, IDS_MODULE_ALREADY_LOADED},
|
|
{ cartridge_loader_status::cannot_open, IDS_MODULE_CANNOT_OPEN},
|
|
{ cartridge_loader_status::not_found, IDS_MODULE_NOT_FOUND },
|
|
{ cartridge_loader_status::not_loaded, IDS_MODULE_NOT_LOADED },
|
|
{ cartridge_loader_status::not_rom, IDS_MODULE_NOT_ROM },
|
|
{ cartridge_loader_status::not_expansion, IDS_MODULE_NOT_EXPANSION }
|
|
};
|
|
|
|
const auto result(load_any_cartridge(0, filename));
|
|
if (result == cartridge_loader_status::success)
|
|
{
|
|
Setting().write("Module", "OnBoot", filename);
|
|
return result;
|
|
}
|
|
|
|
// Tell user why load failed
|
|
auto error_string(VCC::Core::cartridge_load_error_string(result));
|
|
error_string += "\n\n";
|
|
error_string += filename;
|
|
MessageBox(EmuState.WindowHandle, error_string.c_str(), "Load Error", MB_OK | MB_ICONERROR);
|
|
|
|
return result;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
// Unload cartridge in slot
|
|
//--------------------------------------------------------
|
|
void UnloadCartridge(int slot)
|
|
{
|
|
DLOG_C("UnloadCartridge in slot %d\n",slot);
|
|
|
|
// If slot 0 is unloaded then all other slots must be
|
|
// unloaded first. MPI no longer does this when stopped.
|
|
// Doing here gets that previous recursion in plain sight
|
|
if (slot == 0) {
|
|
UnloadCartridge(4);
|
|
UnloadCartridge(3);
|
|
UnloadCartridge(2);
|
|
UnloadCartridge(1);
|
|
gPakRouter.set_active_slot(0);
|
|
}
|
|
|
|
// Cartridge teardown must be done carefully to avoid VCC crashes.
|
|
|
|
// Stop the cartridge
|
|
gCartSlots[slot]->stop();
|
|
|
|
// Replace with null cartridge (takes over CoCo CPU traffic)
|
|
gCartSlots[slot] = std::make_unique<VCC::Core::null_cartridge>();
|
|
gCartSlots[slot]->start();
|
|
|
|
// The dll must not be unloaded while there is CPU
|
|
// traffic running from it or VCC will crash. DLL's are
|
|
// responsible for cleanig up threads and traffic when
|
|
// asked to stop. A short pause here gives the exiting
|
|
// DLL a moment to complete those tasks.
|
|
Sleep(5);
|
|
|
|
// Smart pointer reset() now unloads the dll
|
|
gCartDlls[slot].reset();
|
|
|
|
// update menus
|
|
SendMessage(EmuState.WindowHandle,WM_VCC_UPD_MENU,(WPARAM) 0,(LPARAM) 0);
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
// Unload boot cartridge called by Vcc.cpp
|
|
//--------------------------------------------------------
|
|
void UnloadDll()
|
|
{
|
|
UnloadCartridge(0);
|
|
gPakRouter.set_active_slot(0);
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
// Load cartridge
|
|
//--------------------------------------------------------
|
|
static cartridge_loader_status load_any_cartridge(int slot, const char *filename)
|
|
{
|
|
DLOG_C("\npakinterface.load_any_cartridge slot %d %s called\n", slot, filename);
|
|
|
|
slot_id_type SlotId = slot;
|
|
|
|
// DLL plugins need ini file path so they can manage settings
|
|
char iniPath[MAX_PATH]="";
|
|
GetIniFilePath(iniPath);
|
|
|
|
// Load the cartridge
|
|
auto loadedCartridge = VCC::Core::load_cartridge(
|
|
filename,
|
|
SlotId,
|
|
iniPath,
|
|
EmuState.hMsgProxy,
|
|
slot_callbacks);
|
|
|
|
if (loadedCartridge.load_result != cartridge_loader_status::success) {
|
|
DLOG_C("pakinterface.load_any_cartridge slot %d %s failed\n", slot, filename);
|
|
return loadedCartridge.load_result;
|
|
}
|
|
|
|
// Unload current cart in slot
|
|
UnloadCartridge(slot);
|
|
if (slot == 0) gPakRouter.set_active_slot(0);
|
|
|
|
DLOG_C("pakinterface.load_any_cartridge move cart object to slot %d %s\n",slot,filename);
|
|
gCartSlots[slot] = std::move(loadedCartridge.cartridge);
|
|
gCartDlls[slot] = std::move(loadedCartridge.dll_module);
|
|
|
|
DLOG_C("pakinterface.load_any_cartridge start and initialize slot %d\n",slot);
|
|
gCartSlots[slot]->start();
|
|
gCartSlots[slot]->reset();
|
|
|
|
if (slot == 0) { // TODO: also check for active slot here?
|
|
strcpy(DllPath, filename);
|
|
EmuState.ResetPending = 2;
|
|
SendMessage(EmuState.WindowHandle,WM_VCC_UPD_MENU,(WPARAM) 0,(LPARAM) 0);
|
|
}
|
|
|
|
return loadedCartridge.load_result;
|
|
}
|
|
|
|
void GetCurrentModule(char *DefaultModule)
|
|
{
|
|
strcpy(DefaultModule,DllPath);
|
|
return;
|
|
}
|
|
|
|
void UpdateBusPointer()
|
|
{
|
|
// Do nothing for now. What the plan was for this is unknown.
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
// unload bootslot
|
|
//--------------------------------------------------------
|
|
void UnloadPack()
|
|
{
|
|
DLOG_C("pakinterface.UnloadPack\n");
|
|
UnloadCartridge(0);
|
|
|
|
strcpy(DllPath,"");
|
|
SetCart(0);
|
|
|
|
gPakRouter.set_active_slot(0);
|
|
EmuState.ResetPending=2;
|
|
|
|
char inifile[MAX_PATH];
|
|
GetIniFilePath(inifile);
|
|
Setting().delete_key("Module", "OnBoot");
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
// load bootslot. type: 0 program cartridge 1 rom cartridge
|
|
//--------------------------------------------------------
|
|
void LoadPack(int type) {
|
|
LoadCartridgeDialog(type);
|
|
gPakRouter.set_active_slot(0);
|
|
EmuState.ResetPending=2;
|
|
// Assert cart line for ROMs so they can auto run
|
|
if (type) SetCart(1);
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
// CartMenuActivated is called from VCC WndPrc when a
|
|
// cartridge menu item is clicked. MenuID is less than 250
|
|
//--------------------------------------------------------
|
|
void CartMenuActivated(unsigned int MenuID)
|
|
{
|
|
if (MenuID >= 250) return;
|
|
|
|
switch (MenuID)
|
|
{
|
|
case 1:
|
|
LoadPack(0); // Load a CPAK
|
|
break;
|
|
|
|
case 2:
|
|
UnloadPack();
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
char path[MAX_PATH];
|
|
GetModuleFileName(nullptr,path,MAX_PATH);
|
|
PathRemoveFileSpec(path);
|
|
strncat(path,"mpi.dll",MAX_PATH);
|
|
PakLoadCartridge(path);
|
|
break;
|
|
}
|
|
case 4:
|
|
LoadPack(1); // Load a ROM
|
|
break;
|
|
|
|
default:
|
|
// Let pakrouter handle clicks for multipak slots
|
|
gPakRouter.menu_item_clicked(MenuID);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Messages from MPI
|
|
// -------------------------------------------------------------
|
|
|
|
// Set startup slot currenly comes from a radio button in MPI config.
|
|
bool SetActiveSlot(unsigned int startup_slot)
|
|
{
|
|
DLOG_C("Pakinterface SetActiveSlot %d\n",startup_slot);
|
|
// Startup slot is 0-3 One is added to set the active slot.
|
|
gPakRouter.set_active_slot(startup_slot+1);
|
|
return true;
|
|
}
|
|
|
|
// Unload slot contents
|
|
bool UnloadSlot(unsigned int slot)
|
|
{
|
|
DLOG_C("Pakinterface UnloadSlot: %d\n",slot);
|
|
UnloadCartridge(slot);
|
|
return true;
|
|
}
|
|
|
|
// Load multi slot (1-4)
|
|
bool LoadSlot(unsigned int slot, const CartLoadRequest * data)
|
|
{
|
|
DLOG_C("pakinterface LoadSlot %d %s\n",slot,data->pluginPath);
|
|
if (slot < 1 || slot > 4) {
|
|
DLOG_C("Pakinterface LoadSlot bad slot num\n");
|
|
return false;
|
|
}
|
|
|
|
if (data == nullptr) {
|
|
DLOG_C("Pakinterface LoadSlot null data pointer\n");
|
|
return false;
|
|
}
|
|
|
|
load_any_cartridge(slot, data->pluginPath);
|
|
return true;
|
|
}
|
|
|
|
// Gets the name of cart in a slot.
|
|
bool GetSlotCartName(unsigned int slot, CartNameReply* rpy)
|
|
{
|
|
auto* cart = gCartSlots[slot].get();
|
|
if (cart) {
|
|
std::string s = cart->name();
|
|
std::strncpy(rpy->name, s.c_str(), rpy->size);
|
|
rpy->name[rpy->size-1] = '\0';
|
|
return true;
|
|
}
|
|
rpy->name[0] = '\0';
|
|
return false;
|
|
}
|
|
|
|
// Get description of cart a in slot
|
|
bool GetSlotCartDescript(unsigned int slot, CartDescReply* rpy)
|
|
{
|
|
auto* cart = gCartSlots[slot].get();
|
|
if (cart) {
|
|
std::string s = cart->description();
|
|
std::strncpy(rpy->description, s.c_str(), rpy->size);
|
|
rpy->description[rpy->size-1] = '\0';
|
|
return true;
|
|
}
|
|
rpy->description[0] = '\0';
|
|
return false;
|
|
}
|
|
|