mirror of
https://github.com/TomHarte/CLK.git
synced 2024-08-16 16:28:59 +00:00
190 lines
5.5 KiB
C++
190 lines
5.5 KiB
C++
//
|
|
// 6532.hpp
|
|
// Clock Signal
|
|
//
|
|
// Created by Thomas Harte on 19/06/2016.
|
|
// Copyright © 2016 Thomas Harte. All rights reserved.
|
|
//
|
|
|
|
#ifndef _532_hpp
|
|
#define _532_hpp
|
|
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
|
|
namespace MOS {
|
|
|
|
/*!
|
|
Implements a template for emulation of the MOS 6532 RAM-I/O-Timer ('RIOT').
|
|
|
|
The RIOT provides:
|
|
* 128 bytes of static RAM;
|
|
* an interval timer; and
|
|
* two digital input/output ports.
|
|
|
|
Consumers should derive their own curiously-recurring-template-pattern subclass,
|
|
implementing bus communications as required.
|
|
*/
|
|
template <class T> class MOS6532 {
|
|
public:
|
|
inline void set_ram(uint16_t address, uint8_t value) { ram_[address&0x7f] = value; }
|
|
inline uint8_t get_ram(uint16_t address) { return ram_[address & 0x7f]; }
|
|
|
|
inline void set_register(int address, uint8_t value) {
|
|
const uint8_t decodedAddress = address & 0x07;
|
|
switch(decodedAddress) {
|
|
// Port output
|
|
case 0x00: case 0x02:
|
|
port_[decodedAddress / 2].output = value;
|
|
static_cast<T *>(this)->set_port_output(decodedAddress / 2, port_[decodedAddress/2].output, port_[decodedAddress / 2].output_mask);
|
|
set_port_did_change(decodedAddress / 2);
|
|
break;
|
|
case 0x01: case 0x03:
|
|
port_[decodedAddress / 2].output_mask = value;
|
|
static_cast<T *>(this)->set_port_output(decodedAddress / 2, port_[decodedAddress/2].output, port_[decodedAddress / 2].output_mask);
|
|
set_port_did_change(decodedAddress / 2);
|
|
break;
|
|
|
|
// The timer and edge detect control
|
|
case 0x04: case 0x05: case 0x06: case 0x07:
|
|
if(address & 0x10) {
|
|
timer_.writtenShift = timer_.activeShift = (decodedAddress - 0x04) * 3 + (decodedAddress / 0x07); // i.e. 0, 3, 6, 10
|
|
timer_.value = ((unsigned int)value << timer_.activeShift) ;
|
|
timer_.interrupt_enabled = !!(address&0x08);
|
|
interrupt_status_ &= ~InterruptFlag::Timer;
|
|
evaluate_interrupts();
|
|
} else {
|
|
a7_interrupt_.enabled = !!(address&0x2);
|
|
a7_interrupt_.active_on_positive = !!(address & 0x01);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
inline uint8_t get_register(int address) {
|
|
const uint8_t decodedAddress = address & 0x7;
|
|
switch(decodedAddress) {
|
|
// Port input
|
|
case 0x00: case 0x02: {
|
|
const int port = decodedAddress / 2;
|
|
uint8_t input = static_cast<T *>(this)->get_port_input(port);
|
|
return (input & ~port_[port].output_mask) | (port_[port].output & port_[port].output_mask);
|
|
}
|
|
break;
|
|
case 0x01: case 0x03:
|
|
return port_[decodedAddress / 2].output_mask;
|
|
break;
|
|
|
|
// Timer and interrupt control
|
|
case 0x04: case 0x06: {
|
|
uint8_t value = (uint8_t)(timer_.value >> timer_.activeShift);
|
|
timer_.interrupt_enabled = !!(address&0x08);
|
|
interrupt_status_ &= ~InterruptFlag::Timer;
|
|
evaluate_interrupts();
|
|
|
|
if(timer_.activeShift != timer_.writtenShift) {
|
|
unsigned int shift = timer_.writtenShift - timer_.activeShift;
|
|
timer_.value = (timer_.value << shift) | ((1 << shift) - 1);
|
|
timer_.activeShift = timer_.writtenShift;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
break;
|
|
|
|
case 0x05: case 0x07: {
|
|
uint8_t value = interrupt_status_;
|
|
interrupt_status_ &= ~InterruptFlag::PA7;
|
|
evaluate_interrupts();
|
|
return value;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0xff;
|
|
}
|
|
|
|
inline void run_for_cycles(unsigned int number_of_cycles) {
|
|
// permit counting _to_ zero; counting _through_ zero initiates the other behaviour
|
|
if(timer_.value >= number_of_cycles) {
|
|
timer_.value -= number_of_cycles;
|
|
} else {
|
|
number_of_cycles -= timer_.value;
|
|
timer_.value = (0x100 - number_of_cycles) & 0xff;
|
|
timer_.activeShift = 0;
|
|
interrupt_status_ |= InterruptFlag::Timer;
|
|
evaluate_interrupts();
|
|
}
|
|
}
|
|
|
|
MOS6532() :
|
|
interrupt_status_(0),
|
|
port_{{.output_mask = 0, .output = 0}, {.output_mask = 0, .output = 0}},
|
|
a7_interrupt_({.last_port_value = 0, .enabled = false}),
|
|
interrupt_line_(false),
|
|
timer_{.value = (unsigned int)((rand() & 0xff) << 10), .activeShift = 10, .writtenShift = 10, .interrupt_enabled = false} {}
|
|
|
|
inline void set_port_did_change(int port) {
|
|
if(!port) {
|
|
uint8_t new_port_a_value = (get_port_input(0) & ~port_[0].output_mask) | (port_[0].output & port_[0].output_mask);
|
|
uint8_t difference = new_port_a_value ^ a7_interrupt_.last_port_value;
|
|
a7_interrupt_.last_port_value = new_port_a_value;
|
|
if(difference&0x80) {
|
|
if(
|
|
((new_port_a_value&0x80) && a7_interrupt_.active_on_positive) ||
|
|
(!(new_port_a_value&0x80) && !a7_interrupt_.active_on_positive)
|
|
) {
|
|
interrupt_status_ |= InterruptFlag::PA7;
|
|
evaluate_interrupts();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inline bool get_inerrupt_line() {
|
|
return interrupt_line_;
|
|
}
|
|
|
|
private:
|
|
uint8_t ram_[128];
|
|
|
|
struct {
|
|
unsigned int value;
|
|
unsigned int activeShift, writtenShift;
|
|
bool interrupt_enabled;
|
|
} timer_;
|
|
|
|
struct {
|
|
bool enabled;
|
|
bool active_on_positive;
|
|
uint8_t last_port_value;
|
|
} a7_interrupt_;
|
|
|
|
struct {
|
|
uint8_t output_mask, output;
|
|
} port_[2];
|
|
|
|
uint8_t interrupt_status_;
|
|
enum InterruptFlag: uint8_t {
|
|
Timer = 0x80,
|
|
PA7 = 0x40
|
|
};
|
|
bool interrupt_line_;
|
|
|
|
// expected to be overridden
|
|
uint8_t get_port_input(int port) { return 0xff; }
|
|
void set_port_output(int port, uint8_t value, uint8_t output_mask) {}
|
|
void set_irq_line(bool new_value) {}
|
|
|
|
inline void evaluate_interrupts() {
|
|
interrupt_line_ =
|
|
((interrupt_status_&InterruptFlag::Timer) && timer_.interrupt_enabled) ||
|
|
((interrupt_status_&InterruptFlag::PA7) && a7_interrupt_.enabled);
|
|
set_irq_line(interrupt_line_);
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
#endif /* _532_hpp */
|