mirror of
https://github.com/TomHarte/CLK.git
synced 2026-01-23 16:16:16 +00:00
776 lines
22 KiB
C++
776 lines
22 KiB
C++
//
|
|
// Plus4.cpp
|
|
// Clock Signal
|
|
//
|
|
// Created by Thomas Harte on 06/12/2024.
|
|
// Copyright © 2024 Thomas Harte. All rights reserved.
|
|
//
|
|
|
|
#include "Plus4.hpp"
|
|
|
|
#include "Audio.hpp"
|
|
#include "Interrupts.hpp"
|
|
#include "Keyboard.hpp"
|
|
#include "Pager.hpp"
|
|
#include "TapeHandler.hpp"
|
|
#include "Video.hpp"
|
|
|
|
#include "Machines/MachineTypes.hpp"
|
|
#include "Machines/Utility/MemoryFuzzer.hpp"
|
|
#include "Processors/6502Mk2/6502Mk2.hpp"
|
|
#include "Analyser/Static/Commodore/Target.hpp"
|
|
#include "Outputs/Log.hpp"
|
|
#include "Outputs/Speaker/Implementation/LowpassSpeaker.hpp"
|
|
#include "Configurable/StandardOptions.hpp"
|
|
|
|
#include "Analyser/Dynamic/ConfidenceCounter.hpp"
|
|
#include "Analyser/Static/Commodore/Target.hpp"
|
|
|
|
#include "Storage/Tape/Tape.hpp"
|
|
#include "Machines/Commodore/SerialBus.hpp"
|
|
#include "Machines/Commodore/1540/C1540.hpp"
|
|
|
|
#include "Processors/6502Esque/Implementation/LazyFlags.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <vector>
|
|
|
|
using namespace Commodore;
|
|
using namespace Commodore::Plus4;
|
|
|
|
namespace {
|
|
using Logger = Log::Logger<Log::Source::Plus4>;
|
|
|
|
class Joystick: public Inputs::ConcreteJoystick {
|
|
public:
|
|
Joystick() :
|
|
ConcreteJoystick({
|
|
Input(Input::Up),
|
|
Input(Input::Down),
|
|
Input(Input::Left),
|
|
Input(Input::Right),
|
|
Input(Input::Fire)
|
|
}) {}
|
|
|
|
void did_set_input(const Input &digital_input, bool is_active) final {
|
|
const auto apply = [&](uint8_t mask) {
|
|
if(is_active) mask_ &= ~mask; else mask_ |= mask;
|
|
};
|
|
|
|
switch(digital_input.type) {
|
|
default: return;
|
|
case Input::Right: apply(0x08); break;
|
|
case Input::Left: apply(0x04); break;
|
|
case Input::Down: apply(0x02); break;
|
|
case Input::Up: apply(0x01); break;
|
|
case Input::Fire: apply(0xc0); break;
|
|
}
|
|
}
|
|
|
|
uint8_t mask() const {
|
|
return mask_;
|
|
}
|
|
|
|
private:
|
|
uint8_t mask_ = 0xff;
|
|
};
|
|
|
|
class Timers {
|
|
public:
|
|
Timers(Interrupts &interrupts) : interrupts_(interrupts) {}
|
|
|
|
template <int offset>
|
|
void write(const uint8_t value) {
|
|
const auto load_low = [&](uint16_t &target) {
|
|
target = uint16_t((target & 0xff00) | (value << 0));
|
|
};
|
|
const auto load_high = [&](uint16_t &target) {
|
|
target = uint16_t((target & 0x00ff) | (value << 8));
|
|
};
|
|
|
|
static constexpr auto timer = offset >> 1;
|
|
paused_[timer] = ~offset & 1;
|
|
if constexpr (offset & 1) {
|
|
load_high(timers_[timer]);
|
|
if constexpr (!timer) {
|
|
load_high(timer0_reload_);
|
|
}
|
|
} else {
|
|
load_low(timers_[timer]);
|
|
if constexpr (!timer) {
|
|
load_low(timer0_reload_);
|
|
}
|
|
}
|
|
}
|
|
|
|
template <int offset>
|
|
uint8_t read() {
|
|
static constexpr auto timer = offset >> 1;
|
|
if constexpr (offset & 1) {
|
|
return uint8_t(timers_[timer] >> 8);
|
|
} else {
|
|
return uint8_t(timers_[timer] >> 0);
|
|
}
|
|
}
|
|
|
|
void tick(int count) {
|
|
// Quick hack here; do better than stepping through one at a time.
|
|
while(count--) {
|
|
decrement<0>();
|
|
decrement<1>();
|
|
decrement<2>();
|
|
}
|
|
}
|
|
|
|
private:
|
|
template <int timer>
|
|
void decrement() {
|
|
if(paused_[timer]) return;
|
|
|
|
// Check for reload.
|
|
if(!timer && !timers_[timer]) {
|
|
timers_[timer] = timer0_reload_;
|
|
}
|
|
|
|
-- timers_[timer];
|
|
|
|
// Check for interrupt.
|
|
if(!timers_[timer]) {
|
|
switch(timer) {
|
|
case 0: interrupts_.apply(Interrupts::Flag::Timer1); break;
|
|
case 1: interrupts_.apply(Interrupts::Flag::Timer2); break;
|
|
case 2: interrupts_.apply(Interrupts::Flag::Timer3); break;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint16_t timers_[3]{};
|
|
uint16_t timer0_reload_ = 0xffff;
|
|
bool paused_[3]{};
|
|
|
|
Interrupts &interrupts_;
|
|
};
|
|
|
|
class SerialPort: public Serial::Port {
|
|
public:
|
|
void set_input(const Serial::Line line, const Serial::LineLevel value) override {
|
|
levels_[size_t(line)] = value;
|
|
}
|
|
|
|
Serial::LineLevel level(const Serial::Line line) const {
|
|
return levels_[size_t(line)];
|
|
}
|
|
|
|
private:
|
|
Serial::LineLevel levels_[5];
|
|
};
|
|
|
|
class ConcreteMachine:
|
|
public Activity::Source,
|
|
public BusController,
|
|
public Configurable::Device,
|
|
public CPU::MOS6502::BusHandler,
|
|
public MachineTypes::AudioProducer,
|
|
public MachineTypes::JoystickMachine,
|
|
public MachineTypes::MappedKeyboardMachine,
|
|
public MachineTypes::TimedMachine,
|
|
public MachineTypes::ScanProducer,
|
|
public MachineTypes::MediaTarget,
|
|
public Machine,
|
|
public Utility::TypeRecipient<CharacterMapper> {
|
|
public:
|
|
ConcreteMachine(const Analyser::Static::Commodore::Plus4Target &target, const ROMMachine::ROMFetcher &rom_fetcher) :
|
|
m6502_(*this),
|
|
interrupts_(*this),
|
|
timers_(interrupts_),
|
|
video_(video_map_, interrupts_),
|
|
audio_(audio_queue_),
|
|
speaker_(audio_)
|
|
{
|
|
const auto clock = clock_rate(false);
|
|
media_divider_ = Cycles(clock);
|
|
set_clock_rate(clock);
|
|
speaker_.set_input_rate(float(clock));
|
|
|
|
const auto kernel = ROM::Name::Plus4KernelPALv5;
|
|
const auto basic = ROM::Name::Plus4BASIC;
|
|
ROM::Request request = ROM::Request(basic) && ROM::Request(kernel);
|
|
using DiskDrive = Analyser::Static::Commodore::Plus4Target::DiskDrive;
|
|
switch(target.disk_drive) {
|
|
case DiskDrive::C1541:
|
|
request = request && C1540::Machine::rom_request(C1540::Personality::C1541);
|
|
break;
|
|
case DiskDrive::None:
|
|
break;
|
|
case DiskDrive::C1551:
|
|
Logger::error().append("TODO: load 1551 ROM");
|
|
break;
|
|
}
|
|
|
|
auto roms = rom_fetcher(request);
|
|
if(!request.validate(roms)) {
|
|
throw ROMMachine::Error::MissingROMs;
|
|
}
|
|
|
|
kernel_ = roms.find(kernel)->second;
|
|
basic_ = roms.find(basic)->second;
|
|
|
|
Memory::Fuzz(ram_);
|
|
map_.page<PagerSide::ReadWrite, 0, 65536>(ram_.data());
|
|
page_cpu_rom();
|
|
|
|
video_map_.page<PagerSide::ReadWrite, 0, 65536>(ram_.data());
|
|
|
|
switch(target.disk_drive) {
|
|
case DiskDrive::None:
|
|
break;
|
|
case DiskDrive::C1541:
|
|
c1541_ = std::make_unique<C1540::Machine>(C1540::Personality::C1541, roms);
|
|
c1541_->set_serial_bus(serial_bus_);
|
|
Serial::attach(serial_port_, serial_bus_);
|
|
c1541_->run_for(Cycles(2000000));
|
|
break;
|
|
case DiskDrive::C1551:
|
|
Logger::error().append("TODO: install 1551");
|
|
break;
|
|
}
|
|
|
|
tape_handler_.set_clock_rate(clock);
|
|
|
|
joysticks_.emplace_back(std::make_unique<Joystick>());
|
|
joysticks_.emplace_back(std::make_unique<Joystick>());
|
|
|
|
insert_media(target.media);
|
|
if(!target.loading_command.empty()) {
|
|
// Prefix a space as a delaying technique.
|
|
type_string(std::string(" ") + target.loading_command);
|
|
}
|
|
}
|
|
|
|
~ConcreteMachine() {
|
|
audio_queue_.lock_flush();
|
|
}
|
|
|
|
template <CPU::MOS6502Mk2::BusOperation operation, typename AddressT>
|
|
Cycles perform(const AddressT address, CPU::MOS6502Mk2::data_t<operation> value) {
|
|
// Determine from the TED video subsystem the length of this clock cycle as perceived by the 6502,
|
|
// relative to the master clock.
|
|
auto length = video_.cycle_length(operation == CPU::MOS6502Mk2::BusOperation::Ready);
|
|
|
|
// Update other subsystems.
|
|
advance_timers_and_tape(length);
|
|
|
|
// Requiring a non-ready cycle here does two things:
|
|
//
|
|
// (1) avoids a race condition where skip_range_ is populated just before hitting a ready cycle,
|
|
// and thereby the CPU can never escape the ready period; and
|
|
// (2) providing more real time, periodically, during tape loading.
|
|
if(operation != CPU::MOS6502Mk2::BusOperation::Ready && skip_range_) [[unlikely]] {
|
|
if(
|
|
!tape_handler_.apply_accelerated_range() ||
|
|
(
|
|
operation == CPU::MOS6502Mk2::BusOperation::ReadOpcode &&
|
|
(address < skip_range_->low || address >= skip_range_->high)
|
|
)
|
|
) {
|
|
skip_range_ = std::nullopt;
|
|
}
|
|
length = Cycles(0);
|
|
} else {
|
|
video_.run_for(length);
|
|
|
|
if(c1541_) {
|
|
c1541_cycles_ += length * Cycles(1'000'000);
|
|
c1541_->run_for(c1541_cycles_.divide(media_divider_));
|
|
}
|
|
|
|
time_since_audio_update_ += length;
|
|
}
|
|
|
|
if constexpr (operation == CPU::MOS6502Mk2::BusOperation::Ready) {
|
|
return length;
|
|
}
|
|
|
|
// Perform actual access.
|
|
if(address < 0x0002) {
|
|
// 0x0000: data directions for parallel IO; 1 = output.
|
|
// 0x0001:
|
|
// b7 = serial data in;
|
|
// b6 = serial clock in and cassette write;
|
|
// b5 = [unconnected];
|
|
// b4 = cassette read;
|
|
// b3 = cassette motor, 1 = off;
|
|
// b2 = serial ATN out;
|
|
// b1 = serial clock out and cassette write;
|
|
// b0 = serial data out.
|
|
|
|
if constexpr (is_read(operation)) {
|
|
if(!address) {
|
|
value = io_direction_;
|
|
} else {
|
|
value = io_input();
|
|
|
|
if(!skip_range_ && tape_handler_.apply_accelerated_range()) {
|
|
const auto pc = m6502_.registers().pc;
|
|
const auto a = m6502_.registers().a;
|
|
if(a == 0x10) {
|
|
skip_range_ = tape_handler_.accelerated_range(pc.full, m6502_, map_);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if(!address) {
|
|
io_direction_ = value;
|
|
} else {
|
|
io_output_ = value;
|
|
}
|
|
|
|
const auto output = io_output_ | ~io_direction_;
|
|
tape_handler_.set_io(io_output_, io_direction_);
|
|
serial_port_.set_output(Serial::Line::Data, Serial::LineLevel(~output & 0x01));
|
|
serial_port_.set_output(Serial::Line::Clock, Serial::LineLevel(~output & 0x02));
|
|
serial_port_.set_output(Serial::Line::Attention, Serial::LineLevel(~output & 0x04));
|
|
}
|
|
} else if(address < 0xfd00 || address >= 0xff40) {
|
|
if constexpr (is_read(operation)) {
|
|
value = map_.read(address);
|
|
|
|
if(
|
|
operation == CPU::MOS6502Mk2::BusOperation::ReadOpcode &&
|
|
tape_handler_.test_rom_trap() &&
|
|
address == TapeHandler::ROMTrapAddress &&
|
|
tape_handler_.perform_ldcass(m6502_, ram_, video_.timer_cycle_length())
|
|
) [[unlikely]] {
|
|
value = 0x60;
|
|
}
|
|
} else {
|
|
map_.write(address) = value;
|
|
}
|
|
} else if(address < 0xff00) {
|
|
// Miscellaneous hardware.
|
|
if constexpr (is_read(operation)) {
|
|
switch(address & 0xfff0) {
|
|
case 0xfd10:
|
|
tape_handler_.read_parallel_port([&] {
|
|
const uint16_t pc = m6502_.registers().pc.full;
|
|
return std::array<uint8_t, 4>{
|
|
map_.read(pc+0),
|
|
map_.read(pc+1),
|
|
map_.read(pc+2),
|
|
map_.read(pc+3),
|
|
};
|
|
});
|
|
|
|
value = 0xff ^ (tape_handler_.play_button() ? 0x4 :0x0);
|
|
break;
|
|
|
|
case 0xfdd0:
|
|
case 0xfdf0:
|
|
value = uint8_t(address >> 8);
|
|
break;
|
|
|
|
default:
|
|
value = 0xff;
|
|
Logger::info().append("TODO: read @ %04x", address);
|
|
break;
|
|
}
|
|
} else {
|
|
switch(address & 0xfff0) {
|
|
case 0xfd30:
|
|
keyboard_mask_ = value;
|
|
break;
|
|
|
|
case 0xfdd0: {
|
|
// const auto low = address & 3;
|
|
// const auto high = (address >> 2) & 3;
|
|
// TODO: set up ROMs.
|
|
} break;
|
|
|
|
default:
|
|
Logger::info().append("TODO: write of %02x @ %04x", value, address);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
const auto pc = m6502_.registers().pc.full;
|
|
const bool is_from_rom =
|
|
(rom_is_paged_ && pc >= 0x8000) ||
|
|
(pc >= 0x400 && pc < 0x500) ||
|
|
(pc >= 0x700 && pc < 0x800);
|
|
bool is_hit = true;
|
|
|
|
if constexpr (is_read(operation)) {
|
|
switch(address) {
|
|
case 0xff00: value = timers_.read<0>(); break;
|
|
case 0xff01: value = timers_.read<1>(); break;
|
|
case 0xff02: value = timers_.read<2>(); break;
|
|
case 0xff03: value = timers_.read<3>(); break;
|
|
case 0xff04: value = timers_.read<4>(); break;
|
|
case 0xff05: value = timers_.read<5>(); break;
|
|
case 0xff06: value = video_.read<0xff06>(); break;
|
|
case 0xff07: value = video_.read<0xff07>(); break;
|
|
case 0xff08: {
|
|
const uint8_t keyboard_input =
|
|
~(
|
|
((keyboard_mask_ & 0x01) ? 0x00 : key_states_[0]) |
|
|
((keyboard_mask_ & 0x02) ? 0x00 : key_states_[1]) |
|
|
((keyboard_mask_ & 0x04) ? 0x00 : key_states_[2]) |
|
|
((keyboard_mask_ & 0x08) ? 0x00 : key_states_[3]) |
|
|
((keyboard_mask_ & 0x10) ? 0x00 : key_states_[4]) |
|
|
((keyboard_mask_ & 0x20) ? 0x00 : key_states_[5]) |
|
|
((keyboard_mask_ & 0x40) ? 0x00 : key_states_[6]) |
|
|
((keyboard_mask_ & 0x80) ? 0x00 : key_states_[7])
|
|
);
|
|
|
|
const uint8_t joystick_mask =
|
|
0xff &
|
|
((joystick_mask_ & 0x02) ? 0xff : (joystick(0).mask() | 0x40)) &
|
|
((joystick_mask_ & 0x04) ? 0xff : (joystick(1).mask() | 0x80));
|
|
|
|
value = keyboard_input & joystick_mask;
|
|
} break;
|
|
case 0xff09: value = interrupts_.status(); break;
|
|
case 0xff0a:
|
|
value = interrupts_.mask() | video_.read<0xff0a>() | 0xa0;
|
|
break;
|
|
case 0xff0b: value = video_.read<0xff0b>(); break;
|
|
case 0xff0c: value = video_.read<0xff0c>(); break;
|
|
case 0xff0d: value = video_.read<0xff0d>(); break;
|
|
case 0xff0e: value = ff0e_; break;
|
|
case 0xff0f: value = ff0f_; break;
|
|
case 0xff10: value = ff10_ | 0xfc; break;
|
|
case 0xff11: value = ff11_; break;
|
|
case 0xff12: value = ff12_ | 0xc0; break;
|
|
case 0xff13: value = ff13_ | (rom_is_paged_ ? 1 : 0); break;
|
|
case 0xff14: value = video_.read<0xff14>(); break;
|
|
case 0xff15: value = video_.read<0xff15>(); break;
|
|
case 0xff16: value = video_.read<0xff16>(); break;
|
|
case 0xff17: value = video_.read<0xff17>(); break;
|
|
case 0xff18: value = video_.read<0xff18>(); break;
|
|
case 0xff19: value = video_.read<0xff19>(); break;
|
|
case 0xff1a: value = video_.read<0xff1a>(); break;
|
|
case 0xff1b: value = video_.read<0xff1b>(); break;
|
|
case 0xff1c: value = video_.read<0xff1c>(); break;
|
|
case 0xff1d: value = video_.read<0xff1d>(); break;
|
|
case 0xff1e: value = video_.read<0xff1e>(); break;
|
|
case 0xff1f: value = video_.read<0xff1f>(); break;
|
|
|
|
case 0xff3e: value = 0; break;
|
|
case 0xff3f: value = 0; break;
|
|
|
|
default:
|
|
Logger::info().append("TODO: TED read at %04x", address);
|
|
value = 0xff;
|
|
is_hit = false;
|
|
}
|
|
} else {
|
|
switch(address) {
|
|
case 0xff00: timers_.write<0>(value); break;
|
|
case 0xff01: timers_.write<1>(value); break;
|
|
case 0xff02: timers_.write<2>(value); break;
|
|
case 0xff03: timers_.write<3>(value); break;
|
|
case 0xff04: timers_.write<4>(value); break;
|
|
case 0xff05: timers_.write<5>(value); break;
|
|
case 0xff06: video_.write<0xff06>(value); break;
|
|
case 0xff07:
|
|
video_.write<0xff07>(value);
|
|
update_audio();
|
|
audio_.set_divider(value);
|
|
break;
|
|
case 0xff08:
|
|
// Observation here: the kernel posts a 0 to this
|
|
// address upon completing each keyboard scan cycle,
|
|
// once per frame.
|
|
if(typer_ && !value) [[unlikely]] {
|
|
if(!typer_->type_next_character()) {
|
|
clear_all_keys();
|
|
typer_.reset();
|
|
}
|
|
}
|
|
|
|
joystick_mask_ = value;
|
|
break;
|
|
case 0xff09:
|
|
interrupts_.set_status(value);
|
|
break;
|
|
case 0xff0a:
|
|
interrupts_.set_mask(value);
|
|
video_.write<0xff0a>(value);
|
|
break;
|
|
case 0xff0b: video_.write<0xff0b>(value); break;
|
|
case 0xff0c: video_.write<0xff0c>(value); break;
|
|
case 0xff0d: video_.write<0xff0d>(value); break;
|
|
case 0xff0e:
|
|
ff0e_ = value;
|
|
update_audio();
|
|
audio_.set_frequency_low<0>(value);
|
|
break;
|
|
case 0xff0f:
|
|
ff0f_ = value;
|
|
update_audio();
|
|
audio_.set_frequency_low<1>(value);
|
|
break;
|
|
case 0xff10:
|
|
ff10_ = value;
|
|
update_audio();
|
|
audio_.set_frequency_high<1>(value);
|
|
break;
|
|
case 0xff11:
|
|
ff11_ = value;
|
|
update_audio();
|
|
audio_.set_control(value);
|
|
break;
|
|
case 0xff12:
|
|
ff12_ = value & 0x3f;
|
|
video_.write<0xff12>(value);
|
|
|
|
if((value & 4)) {
|
|
page_video_rom();
|
|
} else {
|
|
page_video_ram();
|
|
}
|
|
|
|
update_audio();
|
|
audio_.set_frequency_high<0>(value);
|
|
break;
|
|
case 0xff13:
|
|
ff13_ = value & 0xfe;
|
|
video_.write<0xff13>(value);
|
|
break;
|
|
case 0xff14: video_.write<0xff14>(value); break;
|
|
case 0xff15: video_.write<0xff15>(value); break;
|
|
case 0xff16: video_.write<0xff16>(value); break;
|
|
case 0xff17: video_.write<0xff17>(value); break;
|
|
case 0xff18: video_.write<0xff18>(value); break;
|
|
case 0xff19: video_.write<0xff19>(value); break;
|
|
case 0xff1a: video_.write<0xff1a>(value); break;
|
|
case 0xff1b: video_.write<0xff1b>(value); break;
|
|
case 0xff1c: video_.write<0xff1c>(value); break;
|
|
case 0xff1d: video_.write<0xff1d>(value); break;
|
|
case 0xff1e: video_.write<0xff1e>(value); break;
|
|
case 0xff1f: video_.write<0xff1f>(value); break;
|
|
|
|
case 0xff3e: page_cpu_rom(); break;
|
|
case 0xff3f: page_cpu_ram(); break;
|
|
|
|
default:
|
|
Logger::info().append("TODO: TED write at %04x", address);
|
|
is_hit = false;
|
|
}
|
|
}
|
|
if(!is_from_rom) {
|
|
if(is_hit) confidence_.add_hit(); else confidence_.add_miss();
|
|
}
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
private:
|
|
struct M6502Traits {
|
|
static constexpr auto uses_ready_line = true;
|
|
static constexpr auto pause_precision = CPU::MOS6502Mk2::PausePrecision::BetweenInstructions;
|
|
using BusHandlerT = ConcreteMachine;
|
|
};
|
|
CPU::MOS6502Mk2::Processor<CPU::MOS6502Mk2::Model::M6502, M6502Traits> m6502_;
|
|
|
|
Outputs::Speaker::Speaker *get_speaker() override {
|
|
return &speaker_;
|
|
}
|
|
|
|
void set_activity_observer(Activity::Observer *const observer) final {
|
|
if(c1541_) c1541_->set_activity_observer(observer);
|
|
}
|
|
|
|
void set_irq_line(const bool active) override {
|
|
m6502_.template set<CPU::MOS6502Mk2::Line::IRQ>(active);
|
|
}
|
|
void set_ready_line(const bool active) override {
|
|
m6502_.template set<CPU::MOS6502Mk2::Line::Ready>(active);
|
|
}
|
|
|
|
void page_video_rom() {
|
|
video_map_.page<PagerSide::Read, 0x8000, 16384>(basic_.data());
|
|
video_map_.page<PagerSide::Read, 0xc000, 16384>(kernel_.data());
|
|
}
|
|
void page_video_ram() {
|
|
video_map_.page<PagerSide::Read, 0x8000, 32768>(&ram_[0x8000]);
|
|
}
|
|
|
|
void page_cpu_rom() {
|
|
// TODO: allow other ROM selection. And no ROM?
|
|
map_.page<PagerSide::Read, 0x8000, 16384>(basic_.data());
|
|
map_.page<PagerSide::Read, 0xc000, 16384>(kernel_.data());
|
|
rom_is_paged_ = true;
|
|
tape_handler_.set_rom_is_paged(true);
|
|
}
|
|
void page_cpu_ram() {
|
|
map_.page<PagerSide::Read, 0x8000, 32768>(&ram_[0x8000]);
|
|
rom_is_paged_ = false;
|
|
tape_handler_.set_rom_is_paged(false);
|
|
}
|
|
bool rom_is_paged_ = false;
|
|
|
|
void set_scan_target(Outputs::Display::ScanTarget *const target) final {
|
|
video_.set_scan_target(target);
|
|
}
|
|
|
|
Outputs::Display::ScanStatus get_scaled_scan_status() const final {
|
|
return video_.get_scaled_scan_status();
|
|
}
|
|
|
|
void set_display_type(const Outputs::Display::DisplayType display_type) final {
|
|
video_.set_display_type(display_type);
|
|
}
|
|
|
|
Outputs::Display::DisplayType get_display_type() const final {
|
|
return video_.get_display_type();
|
|
}
|
|
|
|
void run_for(const Cycles cycles) final {
|
|
m6502_.run_for(cycles);
|
|
|
|
// I don't know why.
|
|
update_audio();
|
|
audio_queue_.perform();
|
|
}
|
|
|
|
void flush_output(int outputs) override {
|
|
if(outputs & Output::Audio) {
|
|
update_audio();
|
|
audio_queue_.perform();
|
|
}
|
|
}
|
|
|
|
bool insert_media(const Analyser::Static::Media &media) final {
|
|
if(!media.tapes.empty()) {
|
|
tape_handler_.set_tape(media.tapes[0]);
|
|
}
|
|
|
|
if(!media.disks.empty() && c1541_) {
|
|
c1541_->set_disk(media.disks[0]);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
Plus4::Pager map_;
|
|
Plus4::Pager video_map_;
|
|
std::array<uint8_t, 65536> ram_;
|
|
std::vector<uint8_t> kernel_;
|
|
std::vector<uint8_t> basic_;
|
|
uint8_t ff0e_, ff0f_, ff10_, ff11_, ff12_, ff13_;
|
|
|
|
Interrupts interrupts_;
|
|
Cycles timers_subcycles_;
|
|
Timers timers_;
|
|
Video video_;
|
|
|
|
Concurrency::AsyncTaskQueue<false> audio_queue_;
|
|
Audio audio_;
|
|
Cycles time_since_audio_update_;
|
|
Outputs::Speaker::PullLowpass<Audio> speaker_;
|
|
void update_audio() {
|
|
speaker_.run_for(audio_queue_, time_since_audio_update_.flush<Cycles>());
|
|
}
|
|
|
|
// MARK: - MappedKeyboardMachine.
|
|
MappedKeyboardMachine::KeyboardMapper *get_keyboard_mapper() override {
|
|
static Plus4::KeyboardMapper keyboard_mapper_;
|
|
return &keyboard_mapper_;
|
|
}
|
|
|
|
void type_string(const std::string &string) final {
|
|
Utility::TypeRecipient<CharacterMapper>::add_typer(string);
|
|
}
|
|
|
|
bool can_type(const char c) const final {
|
|
return Utility::TypeRecipient<CharacterMapper>::can_type(c);
|
|
}
|
|
|
|
void set_key_state(uint16_t key, bool is_pressed) override {
|
|
if(is_pressed) {
|
|
key_states_[line(key)] |= mask(key);
|
|
} else {
|
|
key_states_[line(key)] &= ~mask(key);
|
|
}
|
|
}
|
|
|
|
void clear_all_keys() final {
|
|
std::fill(key_states_.begin(), key_states_.end(), 0);
|
|
}
|
|
|
|
std::array<uint8_t, 8> key_states_{};
|
|
uint8_t keyboard_mask_ = 0xff;
|
|
uint8_t joystick_mask_ = 0xff;
|
|
|
|
Cycles media_divider_, c1541_cycles_;
|
|
std::unique_ptr<C1540::Machine> c1541_;
|
|
Serial::Bus serial_bus_;
|
|
SerialPort serial_port_;
|
|
|
|
void advance_timers_and_tape(const Cycles length) {
|
|
timers_subcycles_ += length;
|
|
const auto timers_cycles = timers_subcycles_.divide(video_.timer_cycle_length());
|
|
timers_.tick(timers_cycles.as<int>());
|
|
|
|
tape_handler_.run_for(length);
|
|
}
|
|
TapeHandler tape_handler_;
|
|
std::optional<AcceleratedRange> skip_range_;
|
|
|
|
uint8_t io_direction_ = 0x00, io_output_ = 0x00;
|
|
uint8_t io_input() const {
|
|
const uint8_t all_inputs =
|
|
(tape_handler_.tape_player().input() ? 0x00 : 0x10) |
|
|
(serial_port_.level(Serial::Line::Data) ? 0x80 : 0x00) |
|
|
(serial_port_.level(Serial::Line::Clock) ? 0x40 : 0x00);
|
|
return
|
|
(io_direction_ & io_output_) |
|
|
(~io_direction_ & all_inputs);
|
|
}
|
|
|
|
std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() override {
|
|
return joysticks_;
|
|
}
|
|
Joystick &joystick(size_t index) const {
|
|
return *static_cast<Joystick *>(joysticks_[index].get());
|
|
}
|
|
std::vector<std::unique_ptr<Inputs::Joystick>> joysticks_;
|
|
|
|
// MARK: - Confidence.
|
|
Analyser::Dynamic::ConfidenceCounter confidence_;
|
|
float get_confidence() final { return confidence_.confidence(); }
|
|
std::string debug_type() final {
|
|
return "Plus4";
|
|
}
|
|
|
|
// MARK: - Configuration options.
|
|
std::unique_ptr<Reflection::Struct> get_options() const final {
|
|
auto options = std::make_unique<Options>(Configurable::OptionsType::UserFriendly);
|
|
options->output = get_video_signal_configurable();
|
|
options->quick_load = tape_handler_.allow_accelerated_tape_loading();
|
|
return options;
|
|
}
|
|
|
|
void set_options(const std::unique_ptr<Reflection::Struct> &str) final {
|
|
const auto options = dynamic_cast<Options *>(str.get());
|
|
|
|
set_video_signal_configurable(options->output);
|
|
tape_handler_.set_allow_accelerated_tape_loading(options->quick_load);
|
|
}
|
|
};
|
|
}
|
|
|
|
std::unique_ptr<Machine> Machine::Plus4(
|
|
const Analyser::Static::Target *target,
|
|
const ROMMachine::ROMFetcher &rom_fetcher
|
|
) {
|
|
using Target = Analyser::Static::Commodore::Plus4Target;
|
|
const Target *const commodore_target = dynamic_cast<const Target *>(target);
|
|
return std::make_unique<ConcreteMachine>(*commodore_target, rom_fetcher);
|
|
}
|