//#define USE_LOGGING
////////////////////////////////////////////////////////////////////////////////
// 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 .
////////////////////////////////////////////////////////////////////////////////
#include "../../src/core/mc6821.h"
#include "../../src/core/MachineDefs.h"
#include "../../src/core/tcc1014registers.h"
#include "../../src/core/tcc1014mmu.h"
#include "pakrouter.h"
#include
#include
#include
#include
#include
#include
//------------------------------------------------------------------------
// pakrouter handles routing and control of the plugin binary interface
// An array of pointers to installed plugin objects is used. The array
// contains five slots, 0 = boot slot, 1..4 are MPI slots, if present.
// binary calls are routed to/from either boot slot or the MPI slots.
// Correct active slot, cts, and scs information is essential for routing.
//------------------------------------------------------------------------
namespace VCC::Core
{
// Set the active slot 0..4 Usually from MPI message.
void PakRouter::set_active_slot(unsigned active_slot)
{
DLOG_C("PakRouter::set_active_slot %d\n",active_slot);
disk_slot_ = active_slot;
active_slot_ = active_slot;
SetCart(line_states_[active_slot]);
}
// reset() is invoked on hard reset or power up.
void PakRouter::reset()
{
DLOG_C("PakRouter::reset\n");
for (int i = 0; i <= 4; i++)
slot_reset(i);
}
// Process external menu item clicks
void PakRouter::menu_item_clicked(unsigned int menu_item) {
DLOG_C("PakRouter::menu_item_clicked %d %d %d\n",menu_item);
// Each slot is allocated 50 menu items
int item = menu_item % 50;
int slot = menu_item / 50;
if (auto& cart = slots_[slot])
cart->menu_item_clicked(item);
}
//-------------------
// Callbacks
//-------------------
// write and read memory are used by carts to do DMA (Hard disk carts do this)
void PakRouter::cart_write_memory(int slot, unsigned char val, unsigned short adr)
{
MemWrite8(val, adr);
};
unsigned char PakRouter::cart_read_memory(int slot,unsigned short adr)
{
return MemRead8(adr);
};
// Assert line is the only callback that is slot sensitive
void PakRouter::cart_assert_line(int slot, bool state)
{
if (slot == active_slot_) SetCart(state);
line_states_[slot] = state;
};
// Cart Assert NMI is used by fd502
void PakRouter::cart_assert_interrupt(int slot, Interrupt intr, InterruptSource src)
{
(void) src; // not used, might be used for state someday...
//----------------------------------------------------------
// Convert PAK interrupt assert to CPU assert or Gime assert.
// FIXME: This is not correct. On a real Coco the CART line
// is used to generate the INT. Both SCS and ACIA do this and
// should be fixed. Also IRQ and FIRQ should comtain state
// so they can be edge triggered.
//----------------------------------------------------------
switch (intr) {
case INT_CART:
GimeAssertCartInterupt(); // Pass state so Gime can edge trigger?
break;
case INT_NMI:
CPUAssertInterupt(IS_NMI, INT_NMI);
break;
}
};
//-------------------
// Routed plugin calls
//-------------------
void PakRouter::horizontal_sync()
{
if (mpi_not_active()) {
slot_hsync(0);
return;
}
for (int i = 4; i > 0; i--)
slot_hsync(i);
}
unsigned short PakRouter::sample_audio()
{
// Cartridge audio is two packed unsigned 8-bit channels. Audio-producing
// cartridges use 0x80 as the midpoint level, while cartridges without
// PakSampleAudio return 0 through the compatibility shim. The old code
// added complete 16-bit packed samples, which allowed the right channel
// to carry into the left channel and made two 0x8080 midpoint samples wrap to
// 0x0100. Mix the channels independently around 0x80 instead.
// ALTERNATE: Return after first cart that supplies a non-zero sample???
int left = 0;
int right = 0;
int mask = 0xFF;
int center = 0x80;
bool have_sample = false;
// if mpi is not loaded return sample from boot slot
if (mpi_not_active()) {
return slot_sample_audio(0);
}
// sum samples for MPI slots
for (int i = 1; i <= 4; i++) {
int sample = slot_sample_audio(i);
if (sample != 0) {
have_sample = true;
left += ((sample >> 8) & mask) - center;
right += (sample & mask) - center;
}
};
if (!have_sample) return 0;
left = std::clamp(left + center, 0, mask);
right = std::clamp(right + center, 0, mask);
return right + (left << 8);
}
unsigned char PakRouter::read_memory_byte(unsigned short address)
{
// Read only active slot memory
return PakRouter::slot_read_memory(active_slot_,address);
}
void PakRouter::write_port(unsigned char port, unsigned char value)
{
// No mpi just write the port. For sure we don't want to
// mess with the pakrouter's idea of what scs and cts are
if (mpi_not_active()) {
if (auto& cart = slots_[0])
cart->write_port(port, value);
return;
}
// Slot-select register (0x7F)
if (port == 0x7F) {
int scs = value & 3;
int cts = (value >> 4) & 3;
disk_slot_ = scs + 1;
active_slot_ = cts + 1;
return;
}
// Disk controller ports (0x40–0x5F) scs slot only
if (is_disk_port(port)) {
PakRouter::slot_write_port(disk_slot_, port, value);
return;
}
// Broadcast other port writes
for (int i = 1; i <= 4; i++) {
PakRouter::slot_write_port(i, port, value);
}
}
unsigned char PakRouter::read_port(unsigned char port)
{
// No mpi just return what ever the port says
if (mpi_not_active()) {
if (auto& cart = slots_[0])
return cart->read_port(port);
return 0;
}
// Slot-select register (0x7F)
if (port == 0x7F) {
int scs = (disk_slot_ -1) & 3;
int cts = (active_slot_ -1) & 3;
return (cts << 4) | scs;
}
// Disk controller ports (0x40–0x5F) scs slot only
if (is_disk_port(port)) {
return PakRouter::slot_read_port(disk_slot_, port);
}
// No MPI slot zero only
if (mpi_not_active()) {
return PakRouter::slot_read_port(0, port);
}
// MPI ports priority scan
for (int i = 1; i <= 4; i++) {
unsigned char data = PakRouter::slot_read_port(i, port);
if (data != 0) return data;
}
return 0;
}
// Build combined status line for loaded carts
void PakRouter::slot_status_(int slot, char* out, size_t maxout)
{
struct Buffer {
char tmp[gMaxSlotStatus*8]; // Well oversized buffer
uint32_t canary;
};
Buffer buf{};
buf.canary = 0xdeadbeef;
PakRouter::slot_get_status(slot, buf.tmp, gMaxSlotStatus);
if (buf.canary != 0xdeadbeef) {
DLOG_C("pakrouter.plugin_status overflow slot %d\n", slot);
out[0] = '\0';
return;
}
std::snprintf(out, maxout, "%.*s", maxout, buf.tmp);
}
void PakRouter::plugin_status(char* txt, size_t len)
{
txt[0] = '\0';
// No MPI or no multislot active
if (mpi_not_active()) {
char tmp[gMaxSlotStatus+1]{};
slot_status_(0, tmp, sizeof(tmp));
if (tmp[0]) {
std::snprintf(txt, len, "%s", tmp);
}
return;
}
// MPI header
std::snprintf(txt, len, "MPI:%d,%d", active_slot_, disk_slot_);
// Append each MPI slot
for (unsigned int i = 1; i <= 4; i++) {
char tmp[32]{};
slot_status_(i, tmp, sizeof(tmp));
if (!tmp[0]) continue;
size_t used = std::strlen(txt);
if (used >= len) break;
std::snprintf(txt + used, len-used, " | %s", tmp);
}
}
}