Files
VCCPlusOSS/platforms/windows/pakrouter.h
T

170 lines
5.0 KiB
C++

////////////////////////////////////////////////////////////////////////////////
// Copyright 2015 by Joseph Forgione
// This file is part of VCC (Virtual Color Computer).
//
// VCC (Virtual Color Computer) is free software: you can redistribute itand/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/>.
////////////////////////////////////////////////////////////////////////////////
#pragma once
#include <vcc/bus/cartridge.h>
// The PakRouter handles routing and control of the plugin binary interface.
// An array of pointers to installed plugin objects is maintained. The array
// contains five slots, 0 = boot slot, 1..4 are MPI slots.
// Correct active slot, cts, and scs information is essential for routing.
#include <vcc/bus/cartridge_loader.h>
#define NumCartSlots 5
namespace VCC::Core
{
using plugin_ptr = typename cartridge_loader_result::cartridge_ptr_type;
class PakRouter
{
public:
// Constructor
PakRouter::PakRouter(std::array<plugin_ptr, NumCartSlots>& slots)
: slots_(slots) {};
// UI driven
void reset();
void set_slots(std::array<cartridge*, 5> slots) {};
void set_active_slot(unsigned int active_slot);
void menu_item_clicked(unsigned int menu_item);
// Exported plugin cpu loop operations
void horizontal_sync();
void write_port(unsigned char port, unsigned char data);
unsigned char read_port(unsigned char port);
unsigned char read_memory_byte(unsigned short address);
unsigned short sample_audio();
// Render loop callbacks
void plugin_status(char * txt, size_t len);
// Plugin cpu loop callbacks
void cart_write_memory(int slot, unsigned char val, unsigned short adr);
unsigned char cart_read_memory(int slot,unsigned short adr);
void cart_assert_line(int slot, bool state); // see line_states_
void cart_assert_interrupt(int slot, Interrupt intr, InterruptSource src);
// Test for inactive MPI
inline bool mpi_not_active() const
{
return active_slot_ == 0;
}
private:
// Important: The following need to be private because only
// the router has the active cart, cts, and scs information to
// determine correct cart routing.
// Test if a disk port
inline bool is_disk_port(int port)
{
return port >= 0x40 && port <= 0x5F;
}
// Slot start is normally called by the UI thread.
// Caution: Start of MPI can cause a cascade that could create a loop.
inline void slot_start(int slot)
{
if (auto& cart = slots_[slot])
cart->start();
}
// Get plugin status text
inline void slot_get_status(int slot, char * buf, size_t len)
{
if (auto& cart = slots_[slot])
cart->status(buf,len);
}
// slot reset
inline void slot_reset(int slot)
{
if (auto& cart = slots_[slot])
cart->reset();
}
// slot hsync
inline void slot_hsync(int slot)
{
if (auto& cart = slots_[slot])
cart->process_horizontal_sync();
}
// get audio sample from slot
inline int slot_sample_audio(int slot)
{
if (auto& cart = slots_[slot])
return cart->sample_audio();
return 0;
}
// Read slot memory
inline unsigned char slot_read_memory(int slot, unsigned short address)
{
if (auto& cart = slots_[slot])
return cart->read_memory_byte(address);
return 0;
}
// Write slot port
inline void slot_write_port(int slot,unsigned char port, unsigned char value)
{
if (auto& cart = slots_[slot])
cart->write_port(port, value);
}
// Read slot port
inline unsigned char slot_read_port(int slot, unsigned char port)
{
if (auto& cart = slots_[slot])
return cart->read_port(port);
return 0;
}
private:
// Helper to limit status output from cartridge
static const int gMaxSlotStatus = 24;
void slot_status_(int slot, char* out, size_t maxout);
private:
// Slots for cartridge objects;
std::array<plugin_ptr, NumCartSlots>& slots_;
// active_slot_ refers to the slot which exposes ROM to
// the cpu. If non-zero a multipak is assumed to be present
int active_slot_ = 0; // (CTS cart pin 32)
// disk_slot_ refers to the slot that can interact with disk
// ports and which slot controls line state (CART signal)
int disk_slot_ = 0; // (SCS cart pin 36)
// Plugins can use the cart line to trigger an IRQ. They use a callback
// to set the control line. The router stores the value in the line
// state array and forwards it to gime code which detects any change.
// Additionally anytime SCS is changed the router forwards the value
// saved for the SCS slot.
std::array<bool,5> line_states_{}; // (CART line state pin 8)
};
}