Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,508 @@
|
||||
//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;
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user