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

Fix CD cancelling commands; Cleanup CD code a bit

This commit is contained in:
Jaby 2023-04-03 22:00:39 +02:00
parent 6e99221ab6
commit c37a011b9a
4 changed files with 44 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -31,6 +31,18 @@ namespace JabyEngine {
static constexpr uint8_t Max = 0xFF; static constexpr uint8_t Max = 0xFF;
}; };
__declare_io_type(Mode, uint8_t,
static constexpr auto DoubleSpeed = Bit(7);
static constexpr auto SingleSpeed = !DoubleSpeed;
static constexpr auto XADPCM = Bit(6);
static constexpr auto WholeSector = Bit(5);
static constexpr auto DataSector = !WholeSector;
static constexpr auto UseXAFilter = Bit(3);
static constexpr auto AudioPlayIRQ = Bit(2);
static constexpr auto AutoPauseTrack = Bit(1);
static constexpr auto CDDA = Bit(0);
);
__declare_io_type(IndexStatus, uint8_t, __declare_io_type(IndexStatus, uint8_t,
static constexpr auto PortIndex = BitRange::from_to(0, 1); static constexpr auto PortIndex = BitRange::from_to(0, 1);
static constexpr auto HasXAFifoData = Bit(2); static constexpr auto HasXAFifoData = Bit(2);

24
src/Library/internal-include/CD/cd_internal.hpp
View File

@ -5,20 +5,13 @@
namespace JabyEngine { namespace JabyEngine {
namespace CD { namespace CD {
namespace internal { namespace internal {
extern State current_state;
extern CD_IO::Interrupt::Type last_interrupt; extern CD_IO::Interrupt::Type last_interrupt;
extern State current_state; extern uint8_t cmd_interrupt_bit;
static CD_IO::Interrupt::Type read_last_interrupt() {
return const_cast<volatile CD_IO::Interrupt::Type&>(last_interrupt);
}
static State read_current_state() {
return const_cast<volatile State&>(current_state);
}
struct Command { struct Command {
static void wait_until(CD_IO::Interrupt::Type irq) { static void wait_completed() {
while(read_last_interrupt() != irq); while(const_cast<volatile uint8_t&>(cmd_interrupt_bit) > 0);
} }
template<typename...ARGS> template<typename...ARGS>
@ -26,7 +19,8 @@ namespace JabyEngine {
while(CD_IO::IndexStatus.is_set(CD_IO::IndexStatus_t::IsTransmissionBusy)); while(CD_IO::IndexStatus.is_set(CD_IO::IndexStatus_t::IsTransmissionBusy));
((parameter_fifo = args),...); ((parameter_fifo = args),...);
cmd_fifo = cmd.id; cmd_fifo = cmd.id;
cmd_interrupt_bit = bit::set(0, cmd.complete_irq);
} }
template<typename T, typename...ARGS> template<typename T, typename...ARGS>
@ -37,7 +31,7 @@ namespace JabyEngine {
template<typename...ARGS> template<typename...ARGS>
static void send_wait(CD_IO::CommandFifo_v& cmd_fifo, CD_IO::ParameterFifo_v& parameter_fifo, CD_IO::Command::Desc 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_completed();
} }
template<typename T, typename...ARGS> template<typename T, typename...ARGS>
@ -46,6 +40,10 @@ namespace JabyEngine {
} }
}; };
static State read_current_state() {
return const_cast<volatile State&>(current_state);
}
void read_file(FileInfo file_info, const SectorBufferAllocator& buffer_allocator); void read_file(FileInfo file_info, const SectorBufferAllocator& buffer_allocator);
void continue_reading(); void continue_reading();
} }

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

@ -3,28 +3,26 @@
#include <PSX/System/IOPorts/interrupt_io.hpp> #include <PSX/System/IOPorts/interrupt_io.hpp>
#include <PSX/System/syscalls.h> #include <PSX/System/syscalls.h>
#include <stdio.h>
namespace JabyEngine { namespace JabyEngine {
namespace CD { namespace CD {
namespace internal { namespace internal {
__declare_io_type(Mode, uint8_t, static constexpr auto DataSectorMode = CD_IO::Mode_t::from(CD_IO::Mode_t::DoubleSpeed, CD_IO::Mode_t::DataSector);
static constexpr auto DoubleSpeed = Bit(7);
static constexpr auto SingleSpeed = !DoubleSpeed;
static constexpr auto XADPCM = Bit(6);
static constexpr auto WholeSector = Bit(5);
static constexpr auto DataSector = !WholeSector;
static constexpr auto UseXAFilter = Bit(3);
static constexpr auto AudioPlayIRQ = Bit(2);
static constexpr auto AutoPauseTrack = Bit(1);
static constexpr auto CDDA = Bit(0);
);
static constexpr auto DataSectorMode = Mode_t::from(Mode_t::DoubleSpeed, Mode_t::DataSector);
static InterruptVerifierResult interrupt_verifier();
static void interrupt_handler(uint32_t);
static SectorBufferAllocator sector_allocator; static SectorBufferAllocator sector_allocator;
static uint16_t cur_lba; static uint16_t cur_lba;
static uint16_t dst_lba; static uint16_t dst_lba;
CD_IO::Interrupt::Type last_interrupt = CD_IO::Interrupt::Type::None;
uint8_t cmd_interrupt_bit = 0;
State current_state = State::Free;
InterrupCallback callback = {
.next = nullptr,
.handler_function = reinterpret_cast<InterruptHandler>(interrupt_handler),
.verifier_function = interrupt_verifier
};
static void pause_cd() { static void pause_cd() {
CD_IO::PortIndex0::change_to(); CD_IO::PortIndex0::change_to();
@ -33,13 +31,11 @@ namespace JabyEngine {
// Requires Index0 // Requires Index0
static void read_cd(uint16_t lba) { static void read_cd(uint16_t lba) {
const auto loc = CDTimeStamp::from(lba); const auto loc = CDTimeStamp::from(lba);
Command::send_wait<CD_IO::PortIndex0>(CD_IO::Command::SetLoc, loc.get_min_cd(), loc.get_sec_cd(), loc.get_sector_cd()); Command::send_wait<CD_IO::PortIndex0>(CD_IO::Command::SetLoc, loc.get_min_cd(), loc.get_sec_cd(), loc.get_sector_cd());
Command::send<CD_IO::PortIndex0>(CD_IO::Command::ReadN); Command::send<CD_IO::PortIndex0>(CD_IO::Command::ReadN);
current_state = State::Reading; current_state = State::Reading;
printf("Now reading: %i(%i:%i:%i)\n", lba, loc.get_min_cd(), loc.get_sec_cd(), loc.get_sector_cd());
} }
static void read_sector_dma(CD_IO::DataSector& sector) { static void read_sector_dma(CD_IO::DataSector& sector) {
@ -81,6 +77,7 @@ namespace JabyEngine {
last_interrupt = cur_irq; last_interrupt = cur_irq;
CD_IO::Interrupt::ack(CD_IO::PortIndex1::InterruptFlag); CD_IO::Interrupt::ack(CD_IO::PortIndex1::InterruptFlag);
cmd_interrupt_bit = bit::clear(cmd_interrupt_bit, cur_irq);
if(cur_irq == CD_IO::Interrupt::DataReady) { if(cur_irq == CD_IO::Interrupt::DataReady) {
// Obtain sector content here // Obtain sector content here
auto* sector = sector_allocator.allocate_sector(); auto* sector = sector_allocator.allocate_sector();
@ -120,19 +117,12 @@ namespace JabyEngine {
__syscall_ReturnFromException(); __syscall_ReturnFromException();
} }
CD_IO::Interrupt::Type last_interrupt = CD_IO::Interrupt::Type::None;
State current_state = State::Free;
InterrupCallback callback = {
.next = nullptr,
.handler_function = reinterpret_cast<InterruptHandler>(interrupt_handler),
.verifier_function = interrupt_verifier
};
void read_file(FileInfo file_info, const SectorBufferAllocator& buffer_allocator) { void read_file(FileInfo file_info, const SectorBufferAllocator& buffer_allocator) {
cur_lba = file_info.lba; cur_lba = file_info.lba;
dst_lba = file_info.lba + file_info.sectors; dst_lba = file_info.lba + file_info.sectors;
sector_allocator = buffer_allocator; sector_allocator = buffer_allocator;
Command::wait_completed();
CD_IO::PortIndex0::change_to(); CD_IO::PortIndex0::change_to();
Command::send_wait<CD_IO::PortIndex0>(CD_IO::Command::SetMode, DataSectorMode); Command::send_wait<CD_IO::PortIndex0>(CD_IO::Command::SetMode, DataSectorMode);
@ -141,6 +131,7 @@ namespace JabyEngine {
void continue_reading() { void continue_reading() {
if(current_state == State::BufferFull) { if(current_state == State::BufferFull) {
Command::wait_completed();
read_cd(cur_lba); read_cd(cur_lba);
} }
} }

5
src/Library/src/File/Processor/cd_file_processor.cpp
View File

@ -78,13 +78,16 @@ namespace JabyEngine {
} }
Progress CDFileProcessor :: process() { Progress CDFileProcessor :: process() {
const auto cur_state = CD::internal::read_current_state();
CDFileProcessor::process_data(); CDFileProcessor::process_data();
switch(CD::internal::read_current_state()) { switch(cur_state) {
case CD::internal::State::Done: case CD::internal::State::Done:
/* /*
We are done now! We are done now!
The user decides if he wants the next value The user decides if he wants the next value
*/ */
//while(this->file_state.process(0) != Progress::Done);
return Progress::Done; return Progress::Done;
case CD::internal::State::BufferFull: case CD::internal::State::BufferFull: