piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-11-14 13:27:45 -07:00
Code Issues Actions Packages Projects Releases Wiki Activity

HW/DVDInterface: Refactor to class.

Browse Source
This commit is contained in:
Admiral H. Curtiss 2023-03-09 21:43:03 +01:00
parent 3ec32c5aa5
commit eb25c46a91
No known key found for this signature in database
GPG Key ID: F051B4C4044F33FB
18 changed files with 578 additions and 607 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Source/Android/jni/MainAndroid.cpp
View File

@ -44,6 +44,7 @@
#include "Core/PowerPC/PowerPC.h"
#include "Core/PowerPC/Profiler.h"
#include "Core/State.h"
#include "Core/System.h"
#include "DiscIO/Blob.h"
#include "DiscIO/Enums.h"
@ -648,7 +649,7 @@ JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_ChangeDisc(J
{
const std::string path = GetJString(env, jFile);
__android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Change Disc: %s", path.c_str());
Core::RunAsCPUThread([&path] { DVDInterface::ChangeDisc(path); });
Core::RunAsCPUThread([&path] { Core::System::GetInstance().GetDVDInterface().ChangeDisc(path); });
}
JNIEXPORT jobject JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetLogTypeNames(JNIEnv* env,

4
Source/Core/Core/Boot/Boot.cpp
View File

@ -317,7 +317,7 @@ static const DiscIO::VolumeDisc* SetDisc(std::unique_ptr<DiscIO::VolumeDisc> dis
std::vector<std::string> auto_disc_change_paths = {})
{
const DiscIO::VolumeDisc* pointer = disc.get();
DVDInterface::SetDisc(std::move(disc), auto_disc_change_paths);
Core::System::GetInstance().GetDVDInterface().SetDisc(std::move(disc), auto_disc_change_paths);
return pointer;
}
@ -344,7 +344,7 @@ bool CBoot::DVDReadDiscID(Core::System& system, const DiscIO::VolumeDisc& disc,
// Transition out of the DiscIdNotRead state (which the drive should be in at this point,
// on the assumption that this is only used for the first read)
DVDInterface::SetDriveState(DVDInterface::DriveState::ReadyNoReadsMade);
system.GetDVDInterface().SetDriveState(DVDInterface::DriveState::ReadyNoReadsMade);
return true;
}

4
Source/Core/Core/Boot/Boot_BS2Emu.cpp
View File

@ -295,11 +295,11 @@ bool CBoot::EmulatedBS2_GC(Core::System& system, const Core::CPUThreadGuard& gua
// No known game uses a size other than the default.
if (streaming_size == 0)
streaming_size = 10;
DVDInterface::AudioBufferConfig(true, streaming_size);
system.GetDVDInterface().AudioBufferConfig(true, streaming_size);
}
else
{
DVDInterface::AudioBufferConfig(false, 0);
system.GetDVDInterface().AudioBufferConfig(false, 0);
}
const bool ntsc = DiscIO::IsNTSC(SConfig::GetInstance().m_region);

2
Source/Core/Core/ConfigManager.cpp
View File

@ -126,7 +126,7 @@ void SConfig::SetRunningGameMetadata(const IOS::ES::TMDReader& tmd, DiscIO::Plat
// (IOS HLE ES calls us with a TMDReader rather than a volume when launching
// a disc game, because ES has no reason to be accessing the disc directly.)
if (platform == DiscIO::Platform::WiiWAD ||
!DVDInterface::UpdateRunningGameMetadata(tmd_title_id))
!Core::System::GetInstance().GetDVDInterface().UpdateRunningGameMetadata(tmd_title_id))
{
// If not launching a disc game, just read everything from the TMD.
SetRunningGameMetadata(tmd.GetGameID(), tmd.GetGameTDBID(), tmd_title_id, tmd.GetTitleVersion(),

832
Source/Core/Core/HW/DVD/DVDInterface.cpp
View File

File diff suppressed because it is too large Load Diff

234
Source/Core/Core/HW/DVD/DVDInterface.h
View File

@ -3,14 +3,26 @@
#pragma once
#include <array>
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "Common/BitField.h"
#include "Common/CommonTypes.h"
#include "Core/HW/StreamADPCM.h"
class PointerWrap;
namespace Core
{
class System;
}
namespace CoreTiming
{
struct EventType;
}
namespace DiscIO
{
class VolumeDisc;
@ -23,23 +35,6 @@ class Mapping;
namespace DVDInterface
{
class DVDInterfaceState
{
public:
DVDInterfaceState();
DVDInterfaceState(const DVDInterfaceState&) = delete;
DVDInterfaceState(DVDInterfaceState&&) = delete;
DVDInterfaceState& operator=(const DVDInterfaceState&) = delete;
DVDInterfaceState& operator=(DVDInterfaceState&&) = delete;
~DVDInterfaceState();
struct Data;
Data& GetData() { return *m_data; }
private:
std::unique_ptr<Data> m_data;
};
enum class DICommand : u8
{
Inquiry = 0x12,
@ -125,48 +120,185 @@ enum class EjectCause
Software,
};
void Init();
void ResetDrive(bool spinup);
void Shutdown();
void DoState(PointerWrap& p);
class DVDInterfaceManager
{
public:
explicit DVDInterfaceManager(Core::System& system);
DVDInterfaceManager(const DVDInterfaceManager&) = delete;
DVDInterfaceManager(DVDInterfaceManager&&) = delete;
DVDInterfaceManager& operator=(const DVDInterfaceManager&) = delete;
DVDInterfaceManager& operator=(DVDInterfaceManager&&) = delete;
~DVDInterfaceManager();
void RegisterMMIO(MMIO::Mapping* mmio, u32 base, bool is_wii);
void Init();
void ResetDrive(bool spinup);
void Shutdown();
void DoState(PointerWrap& p);
void SetDisc(std::unique_ptr<DiscIO::VolumeDisc> disc,
std::optional<std::vector<std::string>> auto_disc_change_paths);
bool IsDiscInside();
void EjectDisc(EjectCause cause); // Must only be called on the CPU thread
void ChangeDisc(const std::vector<std::string>& paths); // Must only be called on the CPU thread
void ChangeDisc(const std::string& new_path); // Must only be called on the CPU thread
bool AutoChangeDisc(); // Must only be called on the CPU thread
void RegisterMMIO(MMIO::Mapping* mmio, u32 base, bool is_wii);
// This function returns true and calls SConfig::SetRunningGameMetadata(Volume&, Partition&)
// if both of the following conditions are true:
// - A disc is inserted
// - The title_id argument doesn't contain a value, or its value matches the disc's title ID
bool UpdateRunningGameMetadata(std::optional<u64> title_id = {});
void SetDisc(std::unique_ptr<DiscIO::VolumeDisc> disc,
std::optional<std::vector<std::string>> auto_disc_change_paths);
bool IsDiscInside() const;
void EjectDisc(EjectCause cause); // Must only be called on the CPU thread
void ChangeDisc(const std::vector<std::string>& paths); // Must only be called on the CPU thread
void ChangeDisc(const std::string& new_path); // Must only be called on the CPU thread
bool AutoChangeDisc(); // Must only be called on the CPU thread
// Direct access to DI for IOS HLE (simpler to implement than how real IOS accesses DI,
// and lets us skip encrypting/decrypting in some cases)
void ExecuteCommand(ReplyType reply_type);
void PerformDecryptingRead(u32 position, u32 length, u32 output_address,
const DiscIO::Partition& partition, ReplyType reply_type);
// This function returns true and calls SConfig::SetRunningGameMetadata(Volume&, Partition&)
// if both of the following conditions are true:
// - A disc is inserted
// - The title_id argument doesn't contain a value, or its value matches the disc's title ID
bool UpdateRunningGameMetadata(std::optional<u64> title_id = {});
// For circumventing Error #001 in DirectoryBlobs, which may have data in the offsets being checked.
void ForceOutOfBoundsRead(ReplyType reply_type);
// Direct access to DI for IOS HLE (simpler to implement than how real IOS accesses DI,
// and lets us skip encrypting/decrypting in some cases)
void ExecuteCommand(ReplyType reply_type);
void PerformDecryptingRead(u32 position, u32 length, u32 output_address,
const DiscIO::Partition& partition, ReplyType reply_type);
// Exposed for use by emulated BS2; does not perform any checks on drive state
void AudioBufferConfig(bool enable_dtk, u8 dtk_buffer_length);
// For circumventing Error #001 in DirectoryBlobs, which may have data in the offsets being
// checked.
void ForceOutOfBoundsRead(ReplyType reply_type);
void SetDriveState(DriveState state);
void SetDriveError(DriveError error);
// Exposed for use by emulated BS2; does not perform any checks on drive state
void AudioBufferConfig(bool enable_dtk, u8 dtk_buffer_length);
// Used by DVDThread
void FinishExecutingCommand(ReplyType reply_type, DIInterruptType interrupt_type, s64 cycles_late,
const std::vector<u8>& data = std::vector<u8>());
void SetDriveState(DriveState state);
void SetDriveError(DriveError error);
// Used by IOS HLE
void SetInterruptEnabled(DIInterruptType interrupt, bool enabled);
void ClearInterrupt(DIInterruptType interrupt);
// Used by DVDThread
void FinishExecutingCommand(ReplyType reply_type, DIInterruptType interrupt_type, s64 cycles_late,
const std::vector<u8>& data = std::vector<u8>());
// Used by IOS HLE
void SetInterruptEnabled(DIInterruptType interrupt, bool enabled);
void ClearInterrupt(DIInterruptType interrupt);
private:
void DTKStreamingCallback(DIInterruptType interrupt_type, const std::vector<u8>& audio_data,
s64 cycles_late);
size_t ProcessDTKSamples(std::vector<s16>* temp_pcm, const std::vector<u8>& audio_data);
u32 AdvanceDTK(u32 maximum_samples, u32* samples_to_process);
void SetLidOpen();
void UpdateInterrupts();
void GenerateDIInterrupt(DIInterruptType dvd_interrupt);
bool CheckReadPreconditions();
bool ExecuteReadCommand(u64 dvd_offset, u32 output_address, u32 dvd_length, u32 output_length,
const DiscIO::Partition& partition, ReplyType reply_type,
DIInterruptType* interrupt_type);
void ScheduleReads(u64 offset, u32 length, const DiscIO::Partition& partition, u32 output_address,
ReplyType reply_type);
static void AutoChangeDiscCallback(Core::System& system, u64 userdata, s64 cyclesLate);
static void EjectDiscCallback(Core::System& system, u64 userdata, s64 cyclesLate);
static void InsertDiscCallback(Core::System& system, u64 userdata, s64 cyclesLate);
static void FinishExecutingCommandCallback(Core::System& system, u64 userdata, s64 cycles_late);
// DI Status Register
union UDISR
{
u32 Hex = 0;
BitField<0, 1, u32> BREAK; // Stop the Device + Interrupt
BitField<1, 1, u32> DEINTMASK; // Access Device Error Int Mask
BitField<2, 1, u32> DEINT; // Access Device Error Int
BitField<3, 1, u32> TCINTMASK; // Transfer Complete Int Mask
BitField<4, 1, u32> TCINT; // Transfer Complete Int
BitField<5, 1, u32> BRKINTMASK;
BitField<6, 1, u32> BRKINT; // w 1: clear brkint
BitField<7, 25, u32> reserved;
UDISR() = default;
explicit UDISR(u32 hex) : Hex{hex} {}
};
// DI Cover Register
union UDICVR
{
u32 Hex = 0;
BitField<0, 1, u32> CVR; // 0: Cover closed 1: Cover open
BitField<1, 1, u32> CVRINTMASK; // 1: Interrupt enabled
BitField<2, 1, u32> CVRINT; // r 1: Interrupt requested w 1: Interrupt clear
BitField<3, 29, u32> reserved;
UDICVR() = default;
explicit UDICVR(u32 hex) : Hex{hex} {}
};
// DI DMA Control Register
union UDICR
{
u32 Hex = 0;
BitField<0, 1, u32> TSTART; // w:1 start r:0 ready
BitField<1, 1, u32> DMA; // 1: DMA Mode
// 0: Immediate Mode (can only do Access Register Command)
BitField<2, 1, u32> RW; // 0: Read Command (DVD to Memory) 1: Write Command (Memory to DVD)
BitField<3, 29, u32> reserved;
};
// DI Config Register
union UDICFG
{
u32 Hex = 0;
BitField<0, 8, u32> CONFIG;
BitField<8, 24, u32> reserved;
UDICFG() = default;
explicit UDICFG(u32 hex) : Hex{hex} {}
};
// Hardware registers
UDISR m_DISR;
UDICVR m_DICVR;
std::array<u32, 3> m_DICMDBUF{};
u32 m_DIMAR = 0;
u32 m_DILENGTH = 0;
UDICR m_DICR;
u32 m_DIIMMBUF = 0;
UDICFG m_DICFG;
StreamADPCM::ADPCMDecoder m_adpcm_decoder;
// DTK
bool m_stream = false;
bool m_stop_at_track_end = false;
u64 m_audio_position = 0;
u64 m_current_start = 0;
u32 m_current_length = 0;
u64 m_next_start = 0;
u32 m_next_length = 0;
u32 m_pending_samples = 0;
bool m_enable_dtk = false;
u8 m_dtk_buffer_length = 0; // TODO: figure out how this affects the regular buffer
// Disc drive state
DriveState m_drive_state = DriveState::Ready;
DriveError m_error_code = DriveError::None;
u64 m_disc_end_offset = 0;
// Disc drive timing
u64 m_read_buffer_start_time = 0;
u64 m_read_buffer_end_time = 0;
u64 m_read_buffer_start_offset = 0;
u64 m_read_buffer_end_offset = 0;
// Disc changing
std::string m_disc_path_to_insert;
std::vector<std::string> m_auto_disc_change_paths;
size_t m_auto_disc_change_index = 0;
// Events
CoreTiming::EventType* m_finish_executing_command = nullptr;
CoreTiming::EventType* m_auto_change_disc = nullptr;
CoreTiming::EventType* m_eject_disc = nullptr;
CoreTiming::EventType* m_insert_disc = nullptr;
Core::System& m_system;
};
} // namespace DVDInterface

5
Source/Core/Core/HW/DVD/DVDThread.cpp
View File

@ -379,13 +379,14 @@ static void FinishRead(Core::System& system, u64 id, s64 cycles_late)
(system.GetCoreTiming().GetTicks() - request.time_started_ticks) /
(SystemTimers::GetTicksPerSecond() / 1000000));
auto& dvd_interface = system.GetDVDInterface();
DVDInterface::DIInterruptType interrupt;
if (buffer.size() != request.length)
{
PanicAlertFmtT("The disc could not be read (at {0:#x} - {1:#x}).", request.dvd_offset,
request.dvd_offset + request.length);
DVDInterface::SetDriveError(DVDInterface::DriveError::ReadError);
dvd_interface.SetDriveError(DVDInterface::DriveError::ReadError);
interrupt = DVDInterface::DIInterruptType::DEINT;
}
else
@ -400,7 +401,7 @@ static void FinishRead(Core::System& system, u64 id, s64 cycles_late)
}
// Notify the emulated software that the command has been executed
DVDInterface::FinishExecutingCommand(request.reply_type, interrupt, cycles_late, buffer);
dvd_interface.FinishExecutingCommand(request.reply_type, interrupt, cycles_late, buffer);
}
static void DVDThread()

6
Source/Core/Core/HW/HW.cpp
View File

@ -50,7 +50,7 @@ void Init(const Sram* override_sram)
AddressSpace::Init();
MemoryInterface::Init();
system.GetDSP().Init(Config::Get(Config::MAIN_DSP_HLE));
DVDInterface::Init();
system.GetDVDInterface().Init();
system.GetGPFifo().Init();
system.GetCPU().Init(Config::Get(Config::MAIN_CPU_CORE));
SystemTimers::Init();
@ -72,7 +72,7 @@ void Shutdown()
SystemTimers::Shutdown();
system.GetCPU().Shutdown();
DVDInterface::Shutdown();
system.GetDVDInterface().Shutdown();
system.GetDSP().Shutdown();
MemoryInterface::Shutdown();
AddressSpace::Shutdown();
@ -101,7 +101,7 @@ void DoState(PointerWrap& p)
p.DoMarker("ProcessorInterface");
system.GetDSP().DoState(p);
p.DoMarker("DSP");
DVDInterface::DoState(p);
system.GetDVDInterface().DoState(p);
p.DoMarker("DVDInterface");
system.GetGPFifo().DoState(p);
p.DoMarker("GPFifo");

4
Source/Core/Core/HW/Memmap.cpp
View File

@ -55,14 +55,14 @@ void MemoryManager::InitMMIO(bool is_wii)
system.GetProcessorInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0C003000);
MemoryInterface::RegisterMMIO(m_mmio_mapping.get(), 0x0C004000);
system.GetDSP().RegisterMMIO(m_mmio_mapping.get(), 0x0C005000);
DVDInterface::RegisterMMIO(m_mmio_mapping.get(), 0x0C006000, false);
system.GetDVDInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0C006000, false);
SerialInterface::RegisterMMIO(m_mmio_mapping.get(), 0x0C006400);
ExpansionInterface::RegisterMMIO(m_mmio_mapping.get(), 0x0C006800);
system.GetAudioInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0C006C00);
if (is_wii)
{
IOS::RegisterMMIO(m_mmio_mapping.get(), 0x0D000000);
DVDInterface::RegisterMMIO(m_mmio_mapping.get(), 0x0D006000, true);
system.GetDVDInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0D006000, true);
SerialInterface::RegisterMMIO(m_mmio_mapping.get(), 0x0D006400);
ExpansionInterface::RegisterMMIO(m_mmio_mapping.get(), 0x0D006800);
system.GetAudioInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0D006C00);

2
Source/Core/Core/HW/ProcessorInterface.cpp
View File

@ -120,7 +120,7 @@ void ProcessorInterfaceManager::RegisterMMIO(MMIO::Mapping* mmio, u32 base)
processor_interface.m_reset_code);
if (!SConfig::GetInstance().bWii && ~processor_interface.m_reset_code & 0x4)
{
DVDInterface::ResetDrive(true);
system.GetDVDInterface().ResetDrive(true);
}
}));

20
Source/Core/Core/HW/WII_IPC.cpp
View File

@ -208,13 +208,13 @@ void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
}));
mmio->Register(base | GPIOB_OUT, MMIO::DirectRead<u32>(&g_gpio_out.m_hex),
MMIO::ComplexWrite<u32>([](Core::System&, u32, u32 val) {
MMIO::ComplexWrite<u32>([](Core::System& system, u32, u32 val) {
g_gpio_out.m_hex =
(val & gpio_owner.m_hex) | (g_gpio_out.m_hex & ~gpio_owner.m_hex);
if (g_gpio_out[GPIO::DO_EJECT])
{
INFO_LOG_FMT(WII_IPC, "Ejecting disc due to GPIO write");
DVDInterface::EjectDisc(DVDInterface::EjectCause::Software);
system.GetDVDInterface().EjectDisc(DVDInterface::EjectCause::Software);
}
// SENSOR_BAR is checked by WiimoteEmu::CameraLogic
// TODO: AVE, SLOT_LED
@ -223,9 +223,9 @@ void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
MMIO::ComplexWrite<u32>([](Core::System&, u32, u32 val) {
gpio_dir.m_hex = (val & gpio_owner.m_hex) | (gpio_dir.m_hex & ~gpio_owner.m_hex);
}));
mmio->Register(base | GPIOB_IN, MMIO::ComplexRead<u32>([](Core::System&, u32) {
mmio->Register(base | GPIOB_IN, MMIO::ComplexRead<u32>([](Core::System& system, u32) {
Common::Flags<GPIO> gpio_in;
gpio_in[GPIO::SLOT_IN] = DVDInterface::IsDiscInside();
gpio_in[GPIO::SLOT_IN] = system.GetDVDInterface().IsDiscInside();
return gpio_in.m_hex;
}),
MMIO::Nop<u32>());
@ -241,13 +241,13 @@ void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
// go through the HW_GPIOB registers if the corresponding bit is set in the HW_GPIO_OWNER
// register.
mmio->Register(base | GPIO_OUT, MMIO::DirectRead<u32>(&g_gpio_out.m_hex),
MMIO::ComplexWrite<u32>([](Core::System&, u32, u32 val) {
MMIO::ComplexWrite<u32>([](Core::System& system, u32, u32 val) {
g_gpio_out.m_hex =
(g_gpio_out.m_hex & gpio_owner.m_hex) | (val & ~gpio_owner.m_hex);
if (g_gpio_out[GPIO::DO_EJECT])
{
INFO_LOG_FMT(WII_IPC, "Ejecting disc due to GPIO write");
DVDInterface::EjectDisc(DVDInterface::EjectCause::Software);
system.GetDVDInterface().EjectDisc(DVDInterface::EjectCause::Software);
}
// SENSOR_BAR is checked by WiimoteEmu::CameraLogic
// TODO: AVE, SLOT_LED
@ -256,15 +256,15 @@ void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
MMIO::ComplexWrite<u32>([](Core::System&, u32, u32 val) {
gpio_dir.m_hex = (gpio_dir.m_hex & gpio_owner.m_hex) | (val & ~gpio_owner.m_hex);
}));
mmio->Register(base | GPIO_IN, MMIO::ComplexRead<u32>([](Core::System&, u32) {
mmio->Register(base | GPIO_IN, MMIO::ComplexRead<u32>([](Core::System& system, u32) {
Common::Flags<GPIO> gpio_in;
gpio_in[GPIO::SLOT_IN] = DVDInterface::IsDiscInside();
gpio_in[GPIO::SLOT_IN] = system.GetDVDInterface().IsDiscInside();
return gpio_in.m_hex;
}),
MMIO::Nop<u32>());
mmio->Register(base | HW_RESETS, MMIO::DirectRead<u32>(&resets),
MMIO::ComplexWrite<u32>([](Core::System&, u32, u32 val) {
MMIO::ComplexWrite<u32>([](Core::System& system, u32, u32 val) {
// A reset occurs when the corresponding bit is cleared
const bool di_reset_triggered = (resets & 0x400) && !(val & 0x400);
resets = val;
@ -273,7 +273,7 @@ void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
// The GPIO *disables* spinning up the drive
const bool spinup = !g_gpio_out[GPIO::DI_SPIN];
INFO_LOG_FMT(WII_IPC, "Resetting DI {} spinup", spinup ? "with" : "without");
DVDInterface::ResetDrive(spinup);
system.GetDVDInterface().ResetDrive(spinup);
}
}));

35
Source/Core/Core/IOS/DI/DI.cpp
View File

@ -214,8 +214,8 @@ std::optional<DIDevice::DIResult> DIDevice::StartIOCtl(const IOCtlRequest& reque
return DIResult::SecurityError;
}
m_last_length = position; // An actual mistake in IOS
DVDInterface::PerformDecryptingRead(position, length, request.buffer_out, m_current_partition,
DVDInterface::ReplyType::IOS);
system.GetDVDInterface().PerformDecryptingRead(
position, length, request.buffer_out, m_current_partition, DVDInterface::ReplyType::IOS);
return {};
}
case DIIoctl::DVDLowWaitForCoverClose:
@ -274,12 +274,12 @@ std::optional<DIDevice::DIResult> DIDevice::StartIOCtl(const IOCtlRequest& reque
}
case DIIoctl::DVDLowMaskCoverInterrupt:
INFO_LOG_FMT(IOS_DI, "DVDLowMaskCoverInterrupt");
DVDInterface::SetInterruptEnabled(DVDInterface::DIInterruptType::CVRINT, false);
system.GetDVDInterface().SetInterruptEnabled(DVDInterface::DIInterruptType::CVRINT, false);
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DI_INTERRUPT_MASK_COMMAND);
return DIResult::Success;
case DIIoctl::DVDLowClearCoverInterrupt:
DEBUG_LOG_FMT(IOS_DI, "DVDLowClearCoverInterrupt");
DVDInterface::ClearInterrupt(DVDInterface::DIInterruptType::CVRINT);
system.GetDVDInterface().ClearInterrupt(DVDInterface::DIInterruptType::CVRINT);
return DIResult::Success;
case DIIoctl::DVDLowUnmaskStatusInterrupts:
INFO_LOG_FMT(IOS_DI, "DVDLowUnmaskStatusInterrupts");
@ -287,13 +287,15 @@ std::optional<DIDevice::DIResult> DIDevice::StartIOCtl(const IOCtlRequest& reque
// Dummied out
return DIResult::Success;
case DIIoctl::DVDLowGetCoverStatus:
{
// TODO: handle resetting case
INFO_LOG_FMT(IOS_DI, "DVDLowGetCoverStatus: Disc {}Inserted",
DVDInterface::IsDiscInside() ? "" : "Not ");
return WriteIfFits(request, DVDInterface::IsDiscInside() ? 2 : 1);
const bool is_disc_inside = system.GetDVDInterface().IsDiscInside();
INFO_LOG_FMT(IOS_DI, "DVDLowGetCoverStatus: Disc {}Inserted", is_disc_inside ? "" : "Not ");
return WriteIfFits(request, is_disc_inside ? 2 : 1);
}
case DIIoctl::DVDLowUnmaskCoverInterrupt:
INFO_LOG_FMT(IOS_DI, "DVDLowUnmaskCoverInterrupt");
DVDInterface::SetInterruptEnabled(DVDInterface::DIInterruptType::CVRINT, true);
system.GetDVDInterface().SetInterruptEnabled(DVDInterface::DIInterruptType::CVRINT, true);
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DI_INTERRUPT_MASK_COMMAND);
return DIResult::Success;
case DIIoctl::DVDLowReset:
@ -362,7 +364,7 @@ std::optional<DIDevice::DIResult> DIDevice::StartIOCtl(const IOCtlRequest& reque
DIMAR = request.buffer_out;
m_last_length = length;
DILENGTH = length;
DVDInterface::ForceOutOfBoundsRead(DVDInterface::ReplyType::IOS);
system.GetDVDInterface().ForceOutOfBoundsRead(DVDInterface::ReplyType::IOS);
return {};
}
else
@ -579,7 +581,7 @@ std::optional<DIDevice::DIResult> DIDevice::StartDMATransfer(u32 command_length,
m_last_length = command_length;
DILENGTH = command_length;
DVDInterface::ExecuteCommand(DVDInterface::ReplyType::IOS);
Core::System::GetInstance().GetDVDInterface().ExecuteCommand(DVDInterface::ReplyType::IOS);
// Reply will be posted when done by FinishIOCtl.
return {};
}
@ -597,7 +599,7 @@ std::optional<DIDevice::DIResult> DIDevice::StartImmediateTransfer(const IOCtlRe
m_executing_command->m_copy_diimmbuf = write_to_buf;
DVDInterface::ExecuteCommand(DVDInterface::ReplyType::IOS);
Core::System::GetInstance().GetDVDInterface().ExecuteCommand(DVDInterface::ReplyType::IOS);
// Reply will be posted when done by FinishIOCtl.
return {};
}
@ -814,12 +816,13 @@ void DIDevice::ResetDIRegisters()
{
// Clear transfer complete and error interrupts (normally r/z, but here we just directly write
// zero)
DVDInterface::ClearInterrupt(DVDInterface::DIInterruptType::TCINT);
DVDInterface::ClearInterrupt(DVDInterface::DIInterruptType::DEINT);
auto& di = Core::System::GetInstance().GetDVDInterface();
di.ClearInterrupt(DVDInterface::DIInterruptType::TCINT);
di.ClearInterrupt(DVDInterface::DIInterruptType::DEINT);
// Enable transfer complete and error interrupts, and disable cover interrupt
DVDInterface::SetInterruptEnabled(DVDInterface::DIInterruptType::TCINT, true);
DVDInterface::SetInterruptEnabled(DVDInterface::DIInterruptType::DEINT, true);
DVDInterface::SetInterruptEnabled(DVDInterface::DIInterruptType::CVRINT, false);
di.SetInterruptEnabled(DVDInterface::DIInterruptType::TCINT, true);
di.SetInterruptEnabled(DVDInterface::DIInterruptType::DEINT, true);
di.SetInterruptEnabled(DVDInterface::DIInterruptType::CVRINT, false);
// Close the current partition, if there is one
ChangePartition(DiscIO::PARTITION_NONE);
}

4
Source/Core/Core/IOS/MIOS.cpp
View File

@ -42,7 +42,7 @@ static void ReinitHardware()
// HACK However, resetting DI will reset the DTK config, which is set by the system menu
// (and not by MIOS), causing games that use DTK to break. Perhaps MIOS doesn't actually
// reset DI fully, in such a way that the DTK config isn't cleared?
// DVDInterface::ResetDrive(true);
// system.GetDVDInterface().ResetDrive(true);
PowerPC::Reset();
Wiimote::ResetAllWiimotes();
// Note: this is specific to Dolphin and is required because we initialised it in Wii mode.
@ -99,7 +99,7 @@ bool Load()
memory.Write_U32(0x00000000, ADDRESS_INIT_SEMAPHORE);
NOTICE_LOG_FMT(IOS, "IPL ready.");
SConfig::GetInstance().m_is_mios = true;
DVDInterface::UpdateRunningGameMetadata();
system.GetDVDInterface().UpdateRunningGameMetadata();
SConfig::OnNewTitleLoad(guard);
return true;
}

4
Source/Core/Core/Movie.cpp
View File

@ -1274,9 +1274,9 @@ void PlayController(GCPadStatus* PadStatus, int controllerID)
if (s_padState.disc)
{
Core::RunAsCPUThread([] {
if (!DVDInterface::AutoChangeDisc())
auto& system = Core::System::GetInstance();
if (!system.GetDVDInterface().AutoChangeDisc())
{
auto& system = Core::System::GetInstance();
system.GetCPU().Break();
PanicAlertFmtT("Change the disc to {0}", s_discChange);
}

10
Source/Core/Core/System.cpp
View File

@ -36,8 +36,8 @@ namespace Core
struct System::Impl
{
explicit Impl(System& system)
: m_audio_interface(system), m_core_timing(system), m_dsp(system), m_gp_fifo(system),
m_ppc_state(PowerPC::ppcState)
: m_audio_interface(system), m_core_timing(system), m_dsp(system), m_dvd_interface(system),
m_gp_fifo(system), m_ppc_state(PowerPC::ppcState)
{
}
@ -50,7 +50,7 @@ struct System::Impl
CommandProcessor::CommandProcessorManager m_command_processor;
CPU::CPUManager m_cpu;
DSP::DSPManager m_dsp;
DVDInterface::DVDInterfaceState m_dvd_interface_state;
DVDInterface::DVDInterfaceManager m_dvd_interface;
DVDThread::DVDThreadState m_dvd_thread_state;
ExpansionInterface::ExpansionInterfaceState m_expansion_interface_state;
Fifo::FifoManager m_fifo;
@ -138,9 +138,9 @@ DSP::DSPManager& System::GetDSP() const
return m_impl->m_dsp;
}
DVDInterface::DVDInterfaceState& System::GetDVDInterfaceState() const
DVDInterface::DVDInterfaceManager& System::GetDVDInterface() const
{
return m_impl->m_dvd_interface_state;
return m_impl->m_dvd_interface;
}
DVDThread::DVDThreadState& System::GetDVDThreadState() const

4
Source/Core/Core/System.h
View File

@ -33,7 +33,7 @@ class DSPManager;
}
namespace DVDInterface
{
class DVDInterfaceState;
class DVDInterfaceManager;
}
namespace DVDThread
{
@ -127,7 +127,7 @@ public:
CoreTiming::CoreTimingManager& GetCoreTiming() const;
CommandProcessor::CommandProcessorManager& GetCommandProcessor() const;
DSP::DSPManager& GetDSP() const;
DVDInterface::DVDInterfaceState& GetDVDInterfaceState() const;
DVDInterface::DVDInterfaceManager& GetDVDInterface() const;
DVDThread::DVDThreadState& GetDVDThreadState() const;
ExpansionInterface::ExpansionInterfaceState& GetExpansionInterfaceState() const;
Fifo::FifoManager& GetFifo() const;

5
Source/Core/DolphinQt/GameList/GameList.cpp
View File

@ -52,6 +52,7 @@
#include "Core/HW/EXI/EXI.h"
#include "Core/HW/EXI/EXI_Device.h"
#include "Core/HW/WiiSave.h"
#include "Core/System.h"
#include "Core/WiiUtils.h"
#include "DiscIO/Blob.h"
@ -852,7 +853,9 @@ void GameList::ChangeDisc()
if (!game)
return;
Core::RunAsCPUThread([file_path = game->GetFilePath()] { DVDInterface::ChangeDisc(file_path); });
Core::RunAsCPUThread([file_path = game->GetFilePath()] {
Core::System::GetInstance().GetDVDInterface().ChangeDisc(file_path);
});
}
QAbstractItemView* GameList::GetActiveView() const

7
Source/Core/DolphinQt/MainWindow.cpp
View File

@ -746,12 +746,15 @@ void MainWindow::ChangeDisc()
std::vector<std::string> paths = StringListToStdVector(PromptFileNames());
if (!paths.empty())
Core::RunAsCPUThread([&paths] { DVDInterface::ChangeDisc(paths); });
Core::RunAsCPUThread(
[&paths] { Core::System::GetInstance().GetDVDInterface().ChangeDisc(paths); });
}
void MainWindow::EjectDisc()
{
Core::RunAsCPUThread([] { DVDInterface::EjectDisc(DVDInterface::EjectCause::User); });
Core::RunAsCPUThread([] {
Core::System::GetInstance().GetDVDInterface().EjectDisc(DVDInterface::EjectCause::User);
});
}
void MainWindow::OpenUserFolder()