jaby
/
jabyengine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Ported CDIOs

This commit is contained in:
Jaby 2023-03-21 20:39:51 +01:00
parent fc47ca7c6a
commit f4cc1c5ea5
5 changed files with 107 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

180
include/PSX/System/IOPorts/cd_io.hpp
View File

@ -31,56 +31,54 @@ namespace JabyEngine {
static constexpr uint8_t Max = 0xFF; static constexpr uint8_t Max = 0xFF;
}; };
typedef struct IndexStatus : public ComplexBitMap<uint8_t> { __declare_io_type(IndexStatus, uint8_t,
static constexpr auto PortIndex = BitRange<Index>::from_to(0, 1); static constexpr auto PortIndex = IOValueSet::from_to(0, 1);
static constexpr auto HasXAFifoData = Bit<uint8_t>(2); static constexpr auto HasXAFifoData = IOBitSet(2);
static constexpr auto IsParameterFifoEmpty = Bit<uint8_t>(3); static constexpr auto IsParameterFifoEmpty = IOBitSet(3);
static constexpr auto HasParameterFifoSpace = Bit<uint8_t>(4); static constexpr auto HasParameterFifoSpace = IOBitSet(4);
static constexpr auto HasResponseFifoData = Bit<uint8_t>(5); static constexpr auto HasResponseFifoData = IOBitSet(5);
static constexpr auto HasDataFifoData = Bit<uint8_t>(6); static constexpr auto HasDataFifoData = IOBitSet(6);
static constexpr auto IsTransmissionBusy = Bit<uint8_t>(7); static constexpr auto IsTransmissionBusy = IOBitSet(7);
} IndexStatus_t; );
struct InterruptEnable : public ComplexBitMap<uint8_t> { __declare_io_type(InterruptEnable, uint8_t,
static constexpr auto InterruptTypValue = BitRange<uint8_t>::from_to(0, 2); static constexpr auto InterruptTypValue = IOValueSet::from_to(0, 2);
static constexpr auto InterruptExtended = BitRange<uint8_t>::from_to(0, 4); static constexpr auto InterruptExtended = IOValueSet::from_to(0, 4);
static constexpr auto UnknownIRQ = Bit<uint8_t>(3); static constexpr auto UnknownIRQ = IOBitSet(3);
static constexpr auto CommandStartIRQ = Bit<uint8_t>(4); static constexpr auto CommandStartIRQ = IOBitSet(4);
}; );
typedef InterruptEnable InterruptFlag; typedef InterruptEnable_v InterruptFlag_v;
struct Request : public ComplexBitMap<uint8_t> { __declare_io_type(Request, uint8_t,
static constexpr auto WantCommandStartIRQ = Bit<uint8_t>(5); static constexpr auto WantCommandStartIRQ = IOBitSet(5);
static constexpr auto WantData = Bit<uint8_t>(7); static constexpr auto WantData = IOBitSet(7);
}; );
struct SoundMapCoding : public ComplexBitMap<uint8_t> { __declare_io_type(SoundMapCoding, uint8_t,
static constexpr auto Stereo = Bit<uint8_t>(0); static constexpr auto Stereo = IOBitSet(0);
static constexpr auto Mono = !Stereo; static constexpr auto Mono = !Stereo;
static constexpr auto SampleRate_18900hz = Bit<uint8_t>(2); static constexpr auto SampleRate_18900hz = IOBitSet(2);
static constexpr auto SampleRate_37800hz = !SampleRate_18900hz; static constexpr auto SampleRate_37800hz = !SampleRate_18900hz;
static constexpr auto BitsPerSample8 = Bit<uint8_t>(4); static constexpr auto BitsPerSample8 = IOBitSet(4);
static constexpr auto BitsPerSample4 = !BitsPerSample8; static constexpr auto BitsPerSample4 = !BitsPerSample8;
static constexpr auto Emphasis = Bit<uint8_t>(6); static constexpr auto Emphasis = IOBitSet(6);
}; );
struct AudioVolumeApply : public ComplexBitMap<uint8_t> { __declare_io_type(AudioVolumeApply, uint8_t,
static constexpr auto Mute = Bit<uint8_t>(0); static constexpr auto Mute = IOBitSet(0);
static constexpr auto ApplyChanges = Bit<uint8_t>(5); static constexpr auto ApplyChanges = IOBitSet(5);
}; );
typedef VolatilePOD<uint8_t> ResponseFifo_t; __declare_io_type(ResponseFifo, uint8_t,);
typedef VolatilePOD<uint8_t> CommandFifo_t; __declare_io_type(CommandFifo, uint8_t,);
typedef VolatilePOD<uint8_t> DataFifo_t; __declare_io_type(DataFifo, uint8_t,);
typedef VolatilePOD<uint16_t> DataFifo16_t; __declare_io_type(DataFifo16, uint16_t,);
typedef VolatilePOD<uint8_t> ParameterFifo_t; __declare_io_type(ParameterFifo, uint8_t,);
typedef VolatilePOD<uint8_t> SoundMapDataOut_t; __declare_io_type(SoundMapDataOut, uint8_t,);
typedef VolatilePOD<CDDAVolume::Type> VolumeRegister_t; __declare_io_type(LeftCD2LeftSPU, CDDAVolume::Type,);
typedef VolatileBitMapPOD<InterruptEnable> InterruptEnableRegister_t; __declare_io_type(LeftCD2RightSPU, CDDAVolume::Type,);
typedef VolatileBitMapPOD<InterruptFlag> InterruptFlagRegister_t; __declare_io_type(RightCD2RightSPU,CDDAVolume::Type,);
typedef VolatileBitMapPOD<Request> RequestRegister_t; __declare_io_type(RightCD2LeftSPU, CDDAVolume::Type,);
typedef VolatileBitMapPOD<SoundMapCoding> SoundMapCodingInfo_t;
typedef VolatileBitMapPOD<AudioVolumeApply> AudioVolumeApplyChange_t;
struct Interrupt { struct Interrupt {
enum Type : uint8_t { enum Type : uint8_t {
@ -92,110 +90,110 @@ namespace JabyEngine {
DiskError = 5 DiskError = 5
}; };
static void enable(InterruptEnableRegister_t& port) { static void enable(InterruptEnable_v& port) {
port.write(InterruptEnable::InterruptTypValue.max()); port.set(InterruptEnable_t::InterruptTypValue.range_max<uint8_t>());
} }
static void enable_extended(InterruptEnableRegister_t& port) { static void enable_extended(InterruptEnable_v& port) {
port.write({InterruptEnable::with(InterruptEnable::InterruptTypValue.max(), InterruptEnable::UnknownIRQ, InterruptEnable::CommandStartIRQ)}); port = *InterruptEnable_t::from(InterruptEnable_t::InterruptTypValue.range_max<uint8_t>(), InterruptEnable_t::UnknownIRQ, InterruptEnable_t::CommandStartIRQ);
} }
static Type get_type(const InterruptFlagRegister_t& port) { static Type get_type(const InterruptFlag_v& port) {
return static_cast<Type>(port.read().get_value(InterruptFlag::InterruptTypValue)); return static_cast<Type>(port.get(InterruptFlag_v::InterruptTypValue));
} }
static void ack(InterruptFlagRegister_t& port) { static void ack(InterruptFlag_v& port) {
port.write(InterruptFlag::InterruptTypValue.max()); port.set(InterruptFlag_v::InterruptTypValue.range_max<uint8_t>());
} }
static void ack_extended(InterruptFlagRegister_t& port) { static void ack_extended(InterruptFlag_v& port) {
port.write({InterruptFlag::with(InterruptFlag::InterruptTypValue.max(), InterruptEnable::UnknownIRQ, InterruptEnable::CommandStartIRQ)}); port = *InterruptFlag_v::from(InterruptFlag_v::InterruptTypValue.range_max<uint8_t>(), InterruptEnable_v::UnknownIRQ, InterruptEnable_v::CommandStartIRQ);
} }
}; };
struct Command { struct Command {
struct Info { struct Desc {
uint8_t id; uint8_t id;
Interrupt::Type complete_irq; Interrupt::Type complete_irq;
}; };
static constexpr Info GetStat{0x01, Interrupt::Type::Acknowledge}; static constexpr Desc GetStat{0x01, Interrupt::Type::Acknowledge};
static constexpr Info SetLoc{0x02, Interrupt::Type::Acknowledge}; static constexpr Desc SetLoc{0x02, Interrupt::Type::Acknowledge};
static constexpr Info ReadN{0x06, Interrupt::Type::DataReady}; static constexpr Desc ReadN{0x06, Interrupt::Type::DataReady};
static constexpr Info Pause{0x09, Interrupt::Type::Complete}; static constexpr Desc Pause{0x09, Interrupt::Type::Complete};
static constexpr Info Init{0x0A, Interrupt::Type::Complete}; static constexpr Desc Init{0x0A, Interrupt::Type::Complete};
static constexpr Info SetMode{0x0E, Interrupt::Type::Acknowledge}; static constexpr Desc SetMode{0x0E, Interrupt::Type::Acknowledge};
}; };
static constexpr auto IORegister1Adr = 0x1F801801; static constexpr auto IORegister1Adr = 0x1F801801;
static constexpr auto IORegister2Adr = 0x1F801802; static constexpr auto IORegister2Adr = 0x1F801802;
static constexpr auto IORegister3Adr = 0x1F801803; static constexpr auto IORegister3Adr = 0x1F801803;
__declare_io_port_global(IndexStatus_t, IndexStatus, 0x1F801800); __declare_new_io_port(IndexStatus, 0x1F801800);
#define __declare_index_io_port(type, name, adr) __cast_io_adr_with_type(inline, type, name, adr) #define __declare_index_io_port(type, name, adr) __cast_io_adr_with_type(inline, type, name, adr)
#define __declare_index_io_port_const(type, name, adr) __cast_io_adr_with_type(const inline, type, name, adr) #define __declare_index_io_port_const(type, name, adr) __cast_io_adr_with_type(const inline, type, name, adr)
struct PortIndex0 { struct PortIndex0 {
__declare_index_io_port_const(ResponseFifo_t, ResponseFifo, IORegister1Adr); __declare_new_const_io_port(ResponseFifo, IORegister1Adr);
__declare_index_io_port( CommandFifo_t, CommandFifo, IORegister1Adr); __declare_new_io_port(CommandFifo, IORegister1Adr);
__declare_index_io_port_const(DataFifo_t, DataFifo, IORegister2Adr); __declare_new_const_io_port(DataFifo, IORegister2Adr);
__declare_index_io_port_const(DataFifo16_t, DataFifo16, IORegister2Adr); __declare_new_const_io_port(DataFifo16, IORegister2Adr);
__declare_index_io_port( ParameterFifo_t, ParameterFifo, IORegister2Adr); __declare_new_io_port(ParameterFifo, IORegister2Adr);
__declare_index_io_port_const(InterruptEnableRegister_t, InterruptEnableRegister, IORegister3Adr); __declare_new_const_io_port(InterruptEnable, IORegister3Adr);
__declare_index_io_port( RequestRegister_t, RequestRegister, IORegister3Adr); __declare_new_io_port(Request, IORegister3Adr);
static void change_to() { static void change_to() {
IndexStatus.write({static_cast<uint8_t>(Index::Index0)}); IndexStatus = Index::Index0;
} }
}; };
struct PortIndex1 { struct PortIndex1 {
__declare_index_io_port_const(ResponseFifo_t, ResponseFifo, IORegister1Adr); __declare_new_const_io_port(ResponseFifo, IORegister1Adr);
__declare_index_io_port( SoundMapDataOut_t, SoundMapDataOut, IORegister1Adr); __declare_new_io_port(SoundMapDataOut, IORegister1Adr);
__declare_index_io_port_const(DataFifo_t, DataFifo, IORegister2Adr); __declare_new_const_io_port(DataFifo, IORegister2Adr);
__declare_index_io_port_const(DataFifo16_t, DataFifo16, IORegister2Adr); __declare_new_const_io_port(DataFifo16, IORegister2Adr);
__declare_index_io_port( InterruptEnableRegister_t, InterruptEnableRegister, IORegister2Adr); __declare_new_io_port(InterruptEnable, IORegister2Adr);
__declare_index_io_port(InterruptFlagRegister_t, InterruptFlagRegister, IORegister3Adr); __declare_new_io_port(InterruptFlag, IORegister3Adr);
static void change_to() { static void change_to() {
IndexStatus.write({static_cast<uint8_t>(Index::Index1)}); IndexStatus = Index::Index1;
} }
}; };
struct PortIndex2 { struct PortIndex2 {
__declare_index_io_port_const(ResponseFifo_t, ResponseFifo, IORegister1Adr); __declare_new_const_io_port(ResponseFifo, IORegister1Adr);
__declare_index_io_port( SoundMapCodingInfo_t, SoundMapCodingInfo, IORegister1Adr); __declare_new_io_port(SoundMapCoding, IORegister1Adr);
__declare_index_io_port_const(DataFifo_t, DataFifo, IORegister2Adr); __declare_new_const_io_port(DataFifo, IORegister2Adr);
__declare_index_io_port_const(DataFifo16_t, DataFifo16, IORegister2Adr); __declare_new_const_io_port(DataFifo16, IORegister2Adr);
__declare_index_io_port( VolumeRegister_t, LeftCD2LeftSPU, IORegister2Adr); __declare_new_io_port(LeftCD2LeftSPU, IORegister2Adr);
__declare_index_io_port_const(InterruptEnableRegister_t, InterruptEnableRegister, IORegister3Adr); __declare_new_const_io_port(InterruptEnable, IORegister3Adr);
__declare_index_io_port( VolumeRegister_t, LeftCD2RightSPU, IORegister3Adr); __declare_new_io_port(LeftCD2RightSPU, IORegister3Adr);
static void change_to() { static void change_to() {
IndexStatus.write({static_cast<uint8_t>(Index::Index2)}); IndexStatus = Index::Index2;
} }
}; };
struct PortIndex3 { struct PortIndex3 {
__declare_index_io_port_const(ResponseFifo_t, ResponseFifo, IORegister1Adr); __declare_new_const_io_port(ResponseFifo, IORegister1Adr);
__declare_index_io_port( VolumeRegister_t, RightCD2RightSPU, IORegister1Adr); __declare_new_io_port(RightCD2RightSPU, IORegister1Adr);
__declare_index_io_port_const(DataFifo_t, DataFifo, IORegister2Adr); __declare_new_const_io_port(DataFifo, IORegister2Adr);
__declare_index_io_port_const(DataFifo16_t, DataFifo16, IORegister2Adr); __declare_new_const_io_port(DataFifo16, IORegister2Adr);
__declare_index_io_port( VolumeRegister_t, RightCD2LeftSPU, IORegister1Adr); __declare_new_io_port(RightCD2LeftSPU, IORegister1Adr);
__declare_index_io_port_const(InterruptFlagRegister_t, InterruptFlagRegister, IORegister3Adr); __declare_new_const_io_port(InterruptFlag, IORegister3Adr);
__declare_index_io_port( AudioVolumeApplyChange_t, AudioVolumeApplyChange, IORegister3Adr); __declare_new_io_port(AudioVolumeApply, IORegister3Adr);
static void change_to() { static void change_to() {
IndexStatus.write({static_cast<uint8_t>(Index::Index3)}); IndexStatus = Index::Index3;
} }
}; };

5
include/PSX/System/IOPorts/ioport.hpp
View File

@ -40,6 +40,11 @@ namespace JabyEngine {
constexpr IOValueSetPair<T> with(T value) const { constexpr IOValueSetPair<T> with(T value) const {
return {*this, value}; return {*this, value};
} }
template<typename T>
constexpr IOValueSetPair<T> range_max() const {
return IOValueSet::with<T>((1 << this->length) - 1);
}
}; };
template<typename T> template<typename T>

14
src/Library/include/CD/cd_internal.hpp
View File

@ -22,26 +22,26 @@ namespace JabyEngine {
} }
template<typename...ARGS> template<typename...ARGS>
static void send(CD_IO::CommandFifo_t& cmd_fifo, CD_IO::ParameterFifo_t& parameter_fifo, CD_IO::Command::Info cmd, ARGS...args) { static void send(CD_IO::CommandFifo_v& cmd_fifo, CD_IO::ParameterFifo_v& parameter_fifo, CD_IO::Command::Desc cmd, ARGS...args) {
while(CD_IO::IndexStatus.read().is_bit_set(CD_IO::IndexStatus::IsTransmissionBusy)); while(CD_IO::IndexStatus.is_set(CD_IO::IndexStatus_t::IsTransmissionBusy));
(parameter_fifo.write(static_cast<uint8_t>(args)), ...); ((parameter_fifo = args),...);
cmd_fifo.write(cmd.id); cmd_fifo = cmd.id;
} }
template<typename T, typename...ARGS> template<typename T, typename...ARGS>
static void send(CD_IO::Command::Info cmd, ARGS...args) { static void send(CD_IO::Command::Desc cmd, ARGS...args) {
send(T::CommandFifo, T::ParameterFifo, cmd, args...); send(T::CommandFifo, T::ParameterFifo, cmd, args...);
} }
template<typename...ARGS> template<typename...ARGS>
static void send_wait(CD_IO::CommandFifo_t& cmd_fifo, CD_IO::ParameterFifo_t& parameter_fifo, CD_IO::Command::Info cmd, ARGS...args) { static void send_wait(CD_IO::CommandFifo_v& cmd_fifo, CD_IO::ParameterFifo_v& parameter_fifo, CD_IO::Command::Desc cmd, ARGS...args) {
send(cmd_fifo, parameter_fifo, cmd, args...); send(cmd_fifo, parameter_fifo, cmd, args...);
wait_until(cmd.complete_irq); wait_until(cmd.complete_irq);
} }
template<typename T, typename...ARGS> template<typename T, typename...ARGS>
static void send_wait(CD_IO::Command::Info cmd, ARGS...args) { static void send_wait(CD_IO::Command::Desc cmd, ARGS...args) {
send_wait(T::CommandFifo, T::ParameterFifo, cmd, args...); send_wait(T::CommandFifo, T::ParameterFifo, cmd, args...);
} }
}; };

4
src/Library/src/BootLoader/cd_boot.cpp
View File

@ -22,8 +22,8 @@ namespace JabyEngine {
__syscall_SysEnqIntRP(CdromIoIrq, &::JabyEngine::CD::internal::callback); __syscall_SysEnqIntRP(CdromIoIrq, &::JabyEngine::CD::internal::callback);
CD_IO::PortIndex1::change_to(); CD_IO::PortIndex1::change_to();
CD_IO::Interrupt::ack_extended(CD_IO::PortIndex1::InterruptFlagRegister); CD_IO::Interrupt::ack_extended(CD_IO::PortIndex1::InterruptFlag);
CD_IO::Interrupt::enable(CD_IO::PortIndex1::InterruptEnableRegister); CD_IO::Interrupt::enable(CD_IO::PortIndex1::InterruptEnable);
Interrupt::ack_irq(Interrupt::CDROM); Interrupt::ack_irq(Interrupt::CDROM);
Interrupt::enable_irq(Interrupt::CDROM); Interrupt::enable_irq(Interrupt::CDROM);

8
src/Library/src/CD/cd.cpp
View File

@ -31,12 +31,12 @@ namespace JabyEngine {
}; };
if(Interrupt::is_irq(Interrupt::CDROM)) { if(Interrupt::is_irq(Interrupt::CDROM)) {
const uint8_t old_idx = (CD_IO::IndexStatus.read() & 0x3); const uint8_t old_idx = (*CD_IO::IndexStatus & 0x3);
CD_IO::PortIndex1::change_to(); CD_IO::PortIndex1::change_to();
const auto cur_irq = CD_IO::Interrupt::get_type(CD_IO::PortIndex1::InterruptFlagRegister); const auto cur_irq = CD_IO::Interrupt::get_type(CD_IO::PortIndex1::InterruptFlag);
last_interrupt = cur_irq; last_interrupt = cur_irq;
CD_IO::Interrupt::ack(CD_IO::PortIndex1::InterruptFlagRegister); CD_IO::Interrupt::ack(CD_IO::PortIndex1::InterruptFlag);
if(cur_irq == CD_IO::Interrupt::DataReady) { if(cur_irq == CD_IO::Interrupt::DataReady) {
//Obtain sector content here //Obtain sector content here
@ -67,7 +67,7 @@ namespace JabyEngine {
current_state = State::Error; current_state = State::Error;
} }
CD_IO::IndexStatus.write({old_idx}); CD_IO::IndexStatus = old_idx;
return InterruptVerifierResult::ExecuteHandler; return InterruptVerifierResult::ExecuteHandler;
} }