6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2025-01-11 08:30:55 +00:00
Code Issues Projects Releases Wiki Activity

Corrects enough of the 6522 and Keyboard to get an initial command seemingly working.

Browse Source
This commit is contained in:
Thomas Harte 2019-06-10 09:28:27 -04:00
parent 0e16c67805
commit 9230969f43
4 changed files with 68 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Components/6522/6522.hpp
View File

@ -133,7 +133,8 @@ template <class T> class MOS6522: public MOS6522Storage {
/// Sets the current intended output value for the port and line;
/// if this affects the visible output, it will be passed to the handler.
void set_control_line_output(Port port, Line line, bool value, bool was_output = true);
void set_control_line_output(Port port, Line line, LineState value);
void evaluate_cb2_output();
};
}

90
Components/6522/Implementation/6522Implementation.hpp
View File

@ -16,7 +16,7 @@ template <typename T> void MOS6522<T>::access(int address) {
case 0x0:
// In both handshake and pulse modes, CB2 goes low on any read or write of Port B.
if(handshake_modes_[1] != HandshakeMode::None) {
set_control_line_output(Port::B, Line::Two, false);
set_control_line_output(Port::B, Line::Two, LineState::Off);
}
break;
@ -24,7 +24,7 @@ template <typename T> void MOS6522<T>::access(int address) {
case 0x1:
// In both handshake and pulse modes, CA2 goes low on any read or write of Port A.
if(handshake_modes_[0] != HandshakeMode::None) {
set_control_line_output(Port::A, Line::Two, false);
set_control_line_output(Port::A, Line::Two, LineState::Off);
}
break;
}
@ -52,7 +52,7 @@ template <typename T> void MOS6522<T>::set_register(int address, uint8_t value)
bus_handler_.set_port_output(Port::A, value, registers_.data_direction[0]);
if(handshake_modes_[1] != HandshakeMode::None) {
set_control_line_output(Port::A, Line::Two, false);
set_control_line_output(Port::A, Line::Two, LineState::Off);
}
registers_.interrupt_flags &= ~(InterruptFlag::CA1ActiveEdge | ((registers_.peripheral_control&0x02) ? 0 : InterruptFlag::CB2ActiveEdge));
@ -96,12 +96,7 @@ template <typename T> void MOS6522<T>::set_register(int address, uint8_t value)
// Control
case 0xb: {
registers_.auxiliary_control = value;
// TODO: what happens if the peripheral control register is doing something with CB2 also?
if(value & 0x10) {
// One of the shift out modes is activated, so set CB2 output appropriately.
set_control_line_output(Port::B, Line::Two, !!(registers_.shift & 0x80), false);
}
evaluate_cb2_output();
} break;
case 0xc: {
// const auto old_peripheral_control = registers_.peripheral_control;
@ -117,22 +112,25 @@ template <typename T> void MOS6522<T>::set_register(int address, uint8_t value)
case 0x02: // Independent negative interrupt input; set Cx2 interrupt on negative transition, don't clear automatically.
case 0x04: // Positive interrupt input; set Cx2 interrupt on positive Cx2 transition, clear on access to Port x register.
case 0x06: // Independent positive interrupt input; set Cx2 interrupt on positive transition, don't clear automatically.
set_control_line_output(Port(port), Line::Two, LineState::Input);
break;
case 0x08: // Handshake: set Cx2 to low on any read or write of Port x; set to high on an active transition of Cx1.
handshake_modes_[port] = HandshakeMode::Handshake;
set_control_line_output(Port(port), Line::Two, LineState::Off); // At a guess.
break;
case 0x0a: // Pulse output: Cx2 is low for one cycle following a read or write of Port x.
handshake_modes_[port] = HandshakeMode::Pulse;
set_control_line_output(Port(port), Line::Two, LineState::On);
break;
case 0x0c: // Manual output: Cx2 low.
set_control_line_output(Port(port), Line::Two, false);
set_control_line_output(Port(port), Line::Two, LineState::Off);
break;
case 0x0e: // Manual output: Cx2 high.
set_control_line_output(Port(port), Line::Two, true);
set_control_line_output(Port(port), Line::Two, LineState::On);
break;
}
@ -226,10 +224,10 @@ template <typename T> void MOS6522<T>::reevaluate_interrupts() {
template <typename T> void MOS6522<T>::set_control_line_input(Port port, Line line, bool value) {
switch(line) {
case Line::One:
if( value != control_inputs_[port].lines[line]) {
if(value != control_inputs_[port].lines[line]) {
// In handshake mode, any transition on C[A/B]1 sets output high on C[A/B]2.
if(handshake_modes_[port] == HandshakeMode::Handshake) {
set_control_line_output(port, Line::Two, true);
set_control_line_output(port, Line::Two, LineState::On);
}
// Set the proper transition interrupt bit if enabled.
@ -238,14 +236,13 @@ template <typename T> void MOS6522<T>::set_control_line_input(Port port, Line li
reevaluate_interrupts();
}
// If this is a low-to-high transition, consider updating the shift register.
// If this is a transition on CB1, consider updating the shift register.
// TODO: and at least one full clock since the shift register was written?
if(port == Port::B) {
if(value) {
switch((registers_.auxiliary_control >> 2)&7) {
default: break;
case 3: shift_in(); break;
case 7: shift_out(); break;
}
switch((registers_.auxiliary_control >> 2)&7) {
default: break;
case 3: if(value) shift_in(); break; // Shifts in are captured on a low-to-high transition.
case 7: if(!value) shift_out(); break; // Shifts out are updated on a high-to-low transition.
}
}
}
@ -290,10 +287,10 @@ template <typename T> void MOS6522<T>::do_phase2() {
// In pulse modes, CA2 and CB2 go high again on the next clock edge.
if(handshake_modes_[1] == HandshakeMode::Pulse) {
set_control_line_output(Port::B, Line::Two, true);
set_control_line_output(Port::B, Line::Two, LineState::On);
}
if(handshake_modes_[0] == HandshakeMode::Pulse) {
set_control_line_output(Port::A, Line::Two, true);
set_control_line_output(Port::A, Line::Two, LineState::On);
}
}
@ -386,18 +383,41 @@ template <typename T> bool MOS6522<T>::get_interrupt_line() {
return !!interrupt_status;
}
template <typename T> void MOS6522<T>::set_control_line_output(Port port, Line line, bool value, bool was_output) {
// Don't announce an unchanged value.
if(control_outputs_[port].lines[line] == value && was_output)
return;
template <typename T> void MOS6522<T>::evaluate_cb2_output() {
// CB2 is a special case, being both the line the shift register can output to,
// and one that can be used as an input or handshaking output according to the
// peripheral control register.
// Store the value as the intended output, announce it only if this
// control line is actually in output mode, or if this is CB2 and
// the shift register is in output mode.
control_outputs_[port].lines[line] = value;
if(registers_.peripheral_control & (0x08 << (port * 4)) || (port == Port::B && line == Line::Two && registers_.auxiliary_control&0x10)) {
bus_handler_.run_for(time_since_bus_handler_call_.flush());
bus_handler_.set_control_line_output(port, line, value);
// My guess: other CB2 functions work only if the shift register is disabled (?).
if((registers_.auxiliary_control >> 2)&7) {
// Shift register is enabled, one way or the other; but announce only output.
if(registers_.auxiliary_control & 0x10) {
bus_handler_.set_control_line_output(Port::B, Line::Two, !!(registers_.shift & 0x80));
} else {
bus_handler_.set_control_line_output(Port::B, Line::Two, true);
}
} else {
// Shift register is disabled.
bus_handler_.set_control_line_output(Port::B, Line::Two, control_outputs_[1].lines[1] != LineState::Off);
}
}
template <typename T> void MOS6522<T>::set_control_line_output(Port port, Line line, LineState value) {
if(port == Port::B && line == Line::Two) {
control_outputs_[port].lines[line] = value;
evaluate_cb2_output();
} else {
// Do nothing if unchanged.
if(value == control_outputs_[port].lines[line]) {
return;
}
control_outputs_[port].lines[line] = value;
if(value != LineState::Input) {
bus_handler_.run_for(time_since_bus_handler_call_.flush());
bus_handler_.set_control_line_output(port, line, value != LineState::Off);
}
}
}
@ -411,10 +431,10 @@ template <typename T> void MOS6522<T>::shift_in() {
}
template <typename T> void MOS6522<T>::shift_out() {
set_control_line_output(Port::B, Line::Two, registers_.shift & 0x80);
// When shifting out, the shift register rotates rather than strictly shifts.
// TODO: is that true for all modes?
registers_.shift = uint8_t((registers_.shift << 1) | (registers_.shift >> 7));
evaluate_cb2_output();
--shift_bits_remaining_;
if(!shift_bits_remaining_) {

11
Components/6522/Implementation/6522Storage.hpp
View File

@ -37,10 +37,17 @@ class MOS6522Storage {
bool timer_needs_reload = false;
} registers_;
// control state
// Control state.
struct {
bool lines[2] = {false, false};
} control_inputs_[2], control_outputs_[2];
} control_inputs_[2];
enum class LineState {
On, Off, Input
};
struct {
LineState lines[2] = {LineState::Input, LineState::Input};
} control_outputs_[2];
enum class HandshakeMode {
None,

2
Machines/Apple/Macintosh/Keyboard.hpp
View File

@ -87,6 +87,7 @@ class Keyboard {
if(phase_ == 8*40) {
mode_ = Mode::AwaitingEndOfCommand;
phase_ = 0;
clock_output_ = false;
}
} break;
@ -117,6 +118,7 @@ class Keyboard {
++phase_;
if(phase_ == 8*33) {
clock_output_ = false;
mode_ = Mode::Waiting;
phase_ = 0;
}