mirror of
https://github.com/TomHarte/CLK.git
synced 2024-08-19 21:29:04 +00:00
210 lines
5.0 KiB
C++
210 lines
5.0 KiB
C++
//
|
|
// PIT.hpp
|
|
// Clock Signal
|
|
//
|
|
// Created by Thomas Harte on 20/11/2023.
|
|
// Copyright © 2023 Thomas Harte. All rights reserved.
|
|
//
|
|
|
|
#ifndef PIT_hpp
|
|
#define PIT_hpp
|
|
|
|
namespace PCCompatible {
|
|
|
|
template <bool is_8254>
|
|
class PIT {
|
|
public:
|
|
template <int channel> uint8_t read() {
|
|
const auto result = channels_[channel].read();
|
|
printf("PIT: read from %d; %02x\n", channel, result);
|
|
return result;
|
|
}
|
|
|
|
template <int channel> void write(uint8_t value) {
|
|
printf("PIT: write to %d\n", channel);
|
|
channels_[channel].write(value);
|
|
}
|
|
|
|
void set_mode(uint8_t value) {
|
|
const int channel_id = (value >> 6) & 3;
|
|
if(channel_id == 3) {
|
|
read_back_ = is_8254;
|
|
|
|
// TODO: decode rest of read-back command.
|
|
return;
|
|
}
|
|
|
|
printf("PIT: set mode on %d\n", channel_id);
|
|
|
|
Channel &channel = channels_[channel_id];
|
|
switch((value >> 4) & 3) {
|
|
default:
|
|
channel.latch_value();
|
|
return;
|
|
|
|
case 1: channel.latch_mode = LatchMode::LowOnly; break;
|
|
case 2: channel.latch_mode = LatchMode::HighOnly; break;
|
|
case 3: channel.latch_mode = LatchMode::LowHigh; break;
|
|
}
|
|
channel.is_bcd = value & 1;
|
|
channel.next_access_high = false;
|
|
|
|
const auto operating_mode = (value >> 1) & 7;
|
|
switch(operating_mode) {
|
|
default: channel.mode = OperatingMode(operating_mode); break;
|
|
case 6: channel.mode = OperatingMode::RateGenerator; break;
|
|
case 7: channel.mode = OperatingMode::SquareWaveGenerator; break;
|
|
}
|
|
|
|
// Set up operating mode.
|
|
switch(channel.mode) {
|
|
default:
|
|
printf("PIT: %d switches to unimplemented mode %d\n", channel_id, int(channel.mode));
|
|
break;
|
|
|
|
case OperatingMode::InterruptOnTerminalCount:
|
|
channel.output = false;
|
|
channel.awaiting_reload = true;
|
|
break;
|
|
|
|
case OperatingMode::RateGenerator:
|
|
channel.output = true;
|
|
channel.awaiting_reload = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void run_for(Cycles cycles) {
|
|
// TODO: be intelligent enough to take ticks outside the loop when appropriate.
|
|
auto ticks = cycles.as<int>();
|
|
while(ticks--) {
|
|
bool output_changed;
|
|
output_changed = channels_[0].advance(1);
|
|
output_changed |= channels_[1].advance(1);
|
|
output_changed |= channels_[2].advance(1);
|
|
}
|
|
}
|
|
|
|
private:
|
|
// Supported only on 8254s.
|
|
bool read_back_ = false;
|
|
|
|
enum class LatchMode {
|
|
LowOnly,
|
|
HighOnly,
|
|
LowHigh,
|
|
};
|
|
|
|
enum class OperatingMode {
|
|
InterruptOnTerminalCount = 0,
|
|
HardwareRetriggerableOneShot = 1,
|
|
RateGenerator = 2,
|
|
SquareWaveGenerator = 3,
|
|
SoftwareTriggeredStrobe = 4,
|
|
HardwareTriggeredStrobe = 5,
|
|
};
|
|
|
|
struct Channel {
|
|
LatchMode latch_mode = LatchMode::LowHigh;
|
|
OperatingMode mode = OperatingMode::InterruptOnTerminalCount;
|
|
bool is_bcd = false;
|
|
|
|
bool gated = false;
|
|
bool awaiting_reload = true;
|
|
|
|
uint16_t counter = 0;
|
|
uint16_t reload = 0;
|
|
uint16_t latch = 0;
|
|
bool output = false;
|
|
|
|
bool next_access_high = false;
|
|
|
|
void latch_value() {
|
|
latch = counter;
|
|
}
|
|
|
|
bool advance(int ticks) {
|
|
if(gated || awaiting_reload) return false;
|
|
|
|
// TODO: BCD mode is completely ignored below. Possibly not too important.
|
|
const bool initial_output = output;
|
|
switch(mode) {
|
|
case OperatingMode::InterruptOnTerminalCount:
|
|
// Output goes permanently high upon a tick from 1 to 0; reload value is not used on wraparound.
|
|
output |= counter <= ticks;
|
|
counter -= ticks;
|
|
break;
|
|
|
|
case OperatingMode::RateGenerator:
|
|
// Output goes low upon a tick from 2 to 1. It goes high again on 1 to 0, and the reload value is used.
|
|
if(counter <= ticks) {
|
|
counter = reload - ticks + counter;
|
|
} else {
|
|
counter -= ticks;
|
|
}
|
|
output = counter != 1;
|
|
break;
|
|
|
|
default:
|
|
// TODO.
|
|
break;
|
|
}
|
|
|
|
return output != initial_output;
|
|
}
|
|
|
|
void write(uint8_t value) {
|
|
switch(latch_mode) {
|
|
case LatchMode::LowOnly:
|
|
reload = (reload & 0xff00) | value;
|
|
break;
|
|
case LatchMode::HighOnly:
|
|
reload = uint16_t((reload & 0x00ff) | (value << 8));
|
|
break;
|
|
case LatchMode::LowHigh:
|
|
next_access_high ^= true;
|
|
if(next_access_high) {
|
|
reload = (reload & 0xff00) | value;
|
|
return;
|
|
}
|
|
|
|
reload = uint16_t((reload & 0x00ff) | (value << 8));
|
|
break;
|
|
}
|
|
|
|
awaiting_reload = false;
|
|
|
|
switch(mode) {
|
|
case OperatingMode::InterruptOnTerminalCount:
|
|
case OperatingMode::RateGenerator:
|
|
counter = reload;
|
|
break;
|
|
}
|
|
}
|
|
|
|
uint8_t read() {
|
|
switch(latch_mode) {
|
|
case LatchMode::LowOnly: return uint8_t(latch);
|
|
case LatchMode::HighOnly: return uint8_t(latch >> 8);
|
|
default:
|
|
case LatchMode::LowHigh:
|
|
next_access_high ^= true;
|
|
return next_access_high ? uint8_t(latch) : uint8_t(latch >> 8);
|
|
break;
|
|
}
|
|
}
|
|
} channels_[3];
|
|
|
|
// TODO:
|
|
//
|
|
// channel 0 is connected to IRQ 0;
|
|
// channel 1 is used for DRAM refresh;
|
|
// channel 2 is gated by a PPI output and feeds into the speaker.
|
|
//
|
|
// RateGenerator: output goes high if gated.
|
|
};
|
|
|
|
}
|
|
|
|
#endif /* PIT_hpp */
|