ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1739 from JosJuice/wii-di-timing 

Accurate loading times for Wii games
This commit is contained in:
skidau 2015-01-03 10:41:18 +11:00
parent 7dc6484fe7 34a37cc30d
commit 598dc033f2
25 changed files with 267 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Source/Core/Core/HW/DVDInterface.cpp
View File

@ -744,6 +744,7 @@ DVDCommandResult ExecuteCommand(u32 command_0, u32 command_1, u32 command_2,
// Less than ~1/155th of a second hangs Oregon Trail at "loading wheel". // Less than ~1/155th of a second hangs Oregon Trail at "loading wheel".
// More than ~1/140th of a second hangs Resident Evil Archives: Resident Evil Zero. // More than ~1/140th of a second hangs Resident Evil Archives: Resident Evil Zero.
// (Might not be true anymore since the other speeds were completely redone in December 2014)
result.ticks_until_completion = SystemTimers::GetTicksPerSecond() / 146; result.ticks_until_completion = SystemTimers::GetTicksPerSecond() / 146;
break; break;

62
Source/Core/Core/IPC_HLE/WII_IPC_HLE.cpp
View File

@ -349,7 +349,7 @@ void DoState(PointerWrap &p)
void ExecuteCommand(u32 _Address) void ExecuteCommand(u32 _Address)
{ {
bool CmdSuccess = false; IPCCommandResult result = IPC_NO_REPLY;
IPCCommandType Command = static_cast<IPCCommandType>(Memory::Read_U32(_Address)); IPCCommandType Command = static_cast<IPCCommandType>(Memory::Read_U32(_Address));
volatile s32 DeviceID = Memory::Read_U32(_Address + 8); volatile s32 DeviceID = Memory::Read_U32(_Address + 8);
@ -379,7 +379,7 @@ void ExecuteCommand(u32 _Address)
{ {
es_inuse[j] = true; es_inuse[j] = true;
g_FdMap[DeviceID] = es_handles[j]; g_FdMap[DeviceID] = es_handles[j];
CmdSuccess = es_handles[j]->Open(_Address, Mode); result = es_handles[j]->Open(_Address, Mode);
Memory::Write_U32(DeviceID, _Address+4); Memory::Write_U32(DeviceID, _Address+4);
break; break;
} }
@ -388,7 +388,7 @@ void ExecuteCommand(u32 _Address)
if (j == ES_MAX_COUNT) if (j == ES_MAX_COUNT)
{ {
Memory::Write_U32(FS_EESEXHAUSTED, _Address + 4); Memory::Write_U32(FS_EESEXHAUSTED, _Address + 4);
CmdSuccess = true; result = IPC_DEFAULT_REPLY;
} }
} }
else if (DeviceName.find("/dev/") == 0) else if (DeviceName.find("/dev/") == 0)
@ -397,7 +397,7 @@ void ExecuteCommand(u32 _Address)
if (pDevice) if (pDevice)
{ {
g_FdMap[DeviceID] = pDevice; g_FdMap[DeviceID] = pDevice;
CmdSuccess = pDevice->Open(_Address, Mode); result = pDevice->Open(_Address, Mode);
INFO_LOG(WII_IPC_FILEIO, "IOP: ReOpen (Device=%s, DeviceID=%08x, Mode=%i)", INFO_LOG(WII_IPC_FILEIO, "IOP: ReOpen (Device=%s, DeviceID=%08x, Mode=%i)",
pDevice->GetDeviceName().c_str(), DeviceID, Mode); pDevice->GetDeviceName().c_str(), DeviceID, Mode);
Memory::Write_U32(DeviceID, _Address+4); Memory::Write_U32(DeviceID, _Address+4);
@ -406,13 +406,13 @@ void ExecuteCommand(u32 _Address)
{ {
WARN_LOG(WII_IPC_HLE, "Unimplemented device: %s", DeviceName.c_str()); WARN_LOG(WII_IPC_HLE, "Unimplemented device: %s", DeviceName.c_str());
Memory::Write_U32(FS_ENOENT, _Address+4); Memory::Write_U32(FS_ENOENT, _Address+4);
CmdSuccess = true; result = IPC_DEFAULT_REPLY;
} }
} }
else else
{ {
pDevice = CreateFileIO(DeviceID, DeviceName); pDevice = CreateFileIO(DeviceID, DeviceName);
CmdSuccess = pDevice->Open(_Address, Mode); result = pDevice->Open(_Address, Mode);
INFO_LOG(WII_IPC_FILEIO, "IOP: Open File (Device=%s, ID=%08x, Mode=%i)", INFO_LOG(WII_IPC_FILEIO, "IOP: Open File (Device=%s, ID=%08x, Mode=%i)",
pDevice->GetDeviceName().c_str(), DeviceID, Mode); pDevice->GetDeviceName().c_str(), DeviceID, Mode);
@ -430,7 +430,7 @@ void ExecuteCommand(u32 _Address)
else else
{ {
Memory::Write_U32(FS_EFDEXHAUSTED, _Address + 4); Memory::Write_U32(FS_EFDEXHAUSTED, _Address + 4);
CmdSuccess = true; result = IPC_DEFAULT_REPLY;
} }
break; break;
} }
@ -438,7 +438,7 @@ void ExecuteCommand(u32 _Address)
{ {
if (pDevice) if (pDevice)
{ {
CmdSuccess = pDevice->Close(_Address); result = pDevice->Close(_Address);
for (u32 j=0; j<ES_MAX_COUNT; j++) for (u32 j=0; j<ES_MAX_COUNT; j++)
{ {
@ -460,7 +460,7 @@ void ExecuteCommand(u32 _Address)
else else
{ {
Memory::Write_U32(FS_EINVAL, _Address + 4); Memory::Write_U32(FS_EINVAL, _Address + 4);
CmdSuccess = true; result = IPC_DEFAULT_REPLY;
} }
break; break;
} }
@ -468,12 +468,12 @@ void ExecuteCommand(u32 _Address)
{ {
if (pDevice) if (pDevice)
{ {
CmdSuccess = pDevice->Read(_Address); result = pDevice->Read(_Address);
} }
else else
{ {
Memory::Write_U32(FS_EINVAL, _Address + 4); Memory::Write_U32(FS_EINVAL, _Address + 4);
CmdSuccess = true; result = IPC_DEFAULT_REPLY;
} }
break; break;
} }
@ -481,12 +481,12 @@ void ExecuteCommand(u32 _Address)
{ {
if (pDevice) if (pDevice)
{ {
CmdSuccess = pDevice->Write(_Address); result = pDevice->Write(_Address);
} }
else else
{ {
Memory::Write_U32(FS_EINVAL, _Address + 4); Memory::Write_U32(FS_EINVAL, _Address + 4);
CmdSuccess = true; result = IPC_DEFAULT_REPLY;
} }
break; break;
} }
@ -494,12 +494,12 @@ void ExecuteCommand(u32 _Address)
{ {
if (pDevice) if (pDevice)
{ {
CmdSuccess = pDevice->Seek(_Address); result = pDevice->Seek(_Address);
} }
else else
{ {
Memory::Write_U32(FS_EINVAL, _Address + 4); Memory::Write_U32(FS_EINVAL, _Address + 4);
CmdSuccess = true; result = IPC_DEFAULT_REPLY;
} }
break; break;
} }
@ -507,7 +507,7 @@ void ExecuteCommand(u32 _Address)
{ {
if (pDevice) if (pDevice)
{ {
CmdSuccess = pDevice->IOCtl(_Address); result = pDevice->IOCtl(_Address);
} }
break; break;
} }
@ -515,7 +515,7 @@ void ExecuteCommand(u32 _Address)
{ {
if (pDevice) if (pDevice)
{ {
CmdSuccess = pDevice->IOCtlV(_Address); result = pDevice->IOCtlV(_Address);
} }
break; break;
} }
@ -526,34 +526,20 @@ void ExecuteCommand(u32 _Address)
} }
} }
// Ensure replies happen in order
const s64 ticks_until_last_reply = last_reply_time - CoreTiming::GetTicks();
if (ticks_until_last_reply > 0)
result.reply_delay_ticks += ticks_until_last_reply;
last_reply_time = CoreTiming::GetTicks() + result.reply_delay_ticks;
if (CmdSuccess) if (result.send_reply)
{ {
// The original hardware overwrites the command type with the async reply type. // The original hardware overwrites the command type with the async reply type.
Memory::Write_U32(IPC_REP_ASYNC, _Address); Memory::Write_U32(IPC_REP_ASYNC, _Address);
// IOS also seems to write back the command that was responded to in the FD field. // IOS also seems to write back the command that was responded to in the FD field.
Memory::Write_U32(Command, _Address + 8); Memory::Write_U32(Command, _Address + 8);
// Ensure replies happen in order, fairly ugly
// Without this, tons of games fail now that DI commands have different reply delays
int reply_delay = pDevice ? pDevice->GetCmdDelay(_Address) : 0;
if (!reply_delay)
{
int delay_us = 250;
reply_delay = SystemTimers::GetTicksPerSecond() / 1000000 * delay_us;
}
const s64 ticks_til_last_reply = last_reply_time - CoreTiming::GetTicks();
if (ticks_til_last_reply > 0)
{
reply_delay = (int)ticks_til_last_reply;
}
last_reply_time = CoreTiming::GetTicks() + reply_delay;
// Generate a reply to the IPC command // Generate a reply to the IPC command
EnqueueReply(_Address, reply_delay); EnqueueReply(_Address, (int)result.reply_delay_ticks);
} }
} }

12
Source/Core/Core/IPC_HLE/WII_IPC_HLE.h
View File

@ -8,9 +8,17 @@
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "Core/HW/SystemTimers.h"
class IWII_IPC_HLE_Device; class IWII_IPC_HLE_Device;
class PointerWrap; class PointerWrap;
struct IPCCommandResult
{
bool send_reply;
u64 reply_delay_ticks;
};
enum IPCCommandType : u32 enum IPCCommandType : u32
{ {
IPC_CMD_OPEN = 1, IPC_CMD_OPEN = 1,
@ -26,6 +34,10 @@ enum IPCCommandType : u32
IPC_REP_ASYNC = 8 IPC_REP_ASYNC = 8
}; };
static const u32 IPC_DEFAULT_DELAY = SystemTimers::GetTicksPerSecond() / 4000; // 250 us
static const IPCCommandResult IPC_NO_REPLY = { false, 0 };
static const IPCCommandResult IPC_DEFAULT_REPLY = { true, IPC_DEFAULT_DELAY };
namespace WII_IPC_HLE_Interface namespace WII_IPC_HLE_Interface
{ {

41
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device.h
View File

@ -11,6 +11,7 @@
#include "Common/StringUtil.h" #include "Common/StringUtil.h"
#include "Core/HW/Memmap.h" #include "Core/HW/Memmap.h"
#include "Core/IPC_HLE/WII_IPC_HLE.h"
#define FS_SUCCESS (u32)0 // Success #define FS_SUCCESS (u32)0 // Success
#define FS_EACCES (u32)-1 // Permission denied #define FS_EACCES (u32)-1 // Permission denied
@ -119,39 +120,37 @@ public:
const std::string& GetDeviceName() const { return m_Name; } const std::string& GetDeviceName() const { return m_Name; }
u32 GetDeviceID() const { return m_DeviceID; } u32 GetDeviceID() const { return m_DeviceID; }
virtual bool Open(u32 _CommandAddress, u32 _Mode) virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode)
{ {
(void)_Mode; (void)_Mode;
WARN_LOG(WII_IPC_HLE, "%s does not support Open()", m_Name.c_str()); WARN_LOG(WII_IPC_HLE, "%s does not support Open()", m_Name.c_str());
Memory::Write_U32(FS_ENOENT, _CommandAddress + 4); Memory::Write_U32(FS_ENOENT, _CommandAddress + 4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
virtual bool Close(u32 _CommandAddress, bool _bForce = false) virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce = false)
{ {
WARN_LOG(WII_IPC_HLE, "%s does not support Close()", m_Name.c_str()); WARN_LOG(WII_IPC_HLE, "%s does not support Close()", m_Name.c_str());
if (!_bForce) if (!_bForce)
Memory::Write_U32(FS_EINVAL, _CommandAddress + 4); Memory::Write_U32(FS_EINVAL, _CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
#define UNIMPLEMENTED_CMD(cmd) WARN_LOG(WII_IPC_HLE, "%s does not support "#cmd"()", m_Name.c_str()); return true; #define UNIMPLEMENTED_CMD(cmd) WARN_LOG(WII_IPC_HLE, "%s does not support "#cmd"()", m_Name.c_str()); return IPC_DEFAULT_REPLY;
virtual bool Seek (u32) { UNIMPLEMENTED_CMD(Seek) } virtual IPCCommandResult Seek(u32) { UNIMPLEMENTED_CMD(Seek) }
virtual bool Read (u32) { UNIMPLEMENTED_CMD(Read) } virtual IPCCommandResult Read(u32) { UNIMPLEMENTED_CMD(Read) }
virtual bool Write (u32) { UNIMPLEMENTED_CMD(Write) } virtual IPCCommandResult Write(u32) { UNIMPLEMENTED_CMD(Write) }
virtual bool IOCtl (u32) { UNIMPLEMENTED_CMD(IOCtl) } virtual IPCCommandResult IOCtl(u32) { UNIMPLEMENTED_CMD(IOCtl) }
virtual bool IOCtlV (u32) { UNIMPLEMENTED_CMD(IOCtlV) } virtual IPCCommandResult IOCtlV(u32) { UNIMPLEMENTED_CMD(IOCtlV) }
#undef UNIMPLEMENTED_CMD #undef UNIMPLEMENTED_CMD
virtual int GetCmdDelay(u32) { return 0; }
virtual u32 Update() { return 0; } virtual u32 Update() { return 0; }
virtual bool IsHardware() { return m_Hardware; } virtual bool IsHardware() { return m_Hardware; }
virtual bool IsOpened() { return m_Active; } virtual bool IsOpened() { return m_Active; }
public:
std::string m_Name; std::string m_Name;
protected: protected:
@ -223,33 +222,33 @@ public:
{ {
} }
bool Open(u32 CommandAddress, u32 Mode) override IPCCommandResult Open(u32 CommandAddress, u32 Mode) override
{ {
(void)Mode; (void)Mode;
WARN_LOG(WII_IPC_HLE, "%s faking Open()", m_Name.c_str()); WARN_LOG(WII_IPC_HLE, "%s faking Open()", m_Name.c_str());
Memory::Write_U32(GetDeviceID(), CommandAddress + 4); Memory::Write_U32(GetDeviceID(), CommandAddress + 4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
bool Close(u32 CommandAddress, bool bForce = false) override IPCCommandResult Close(u32 CommandAddress, bool bForce = false) override
{ {
WARN_LOG(WII_IPC_HLE, "%s faking Close()", m_Name.c_str()); WARN_LOG(WII_IPC_HLE, "%s faking Close()", m_Name.c_str());
if (!bForce) if (!bForce)
Memory::Write_U32(FS_SUCCESS, CommandAddress + 4); Memory::Write_U32(FS_SUCCESS, CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
bool IOCtl(u32 CommandAddress) override IPCCommandResult IOCtl(u32 CommandAddress) override
{ {
WARN_LOG(WII_IPC_HLE, "%s faking IOCtl()", m_Name.c_str()); WARN_LOG(WII_IPC_HLE, "%s faking IOCtl()", m_Name.c_str());
Memory::Write_U32(FS_SUCCESS, CommandAddress + 4); Memory::Write_U32(FS_SUCCESS, CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }
bool IOCtlV(u32 CommandAddress) override IPCCommandResult IOCtlV(u32 CommandAddress) override
{ {
WARN_LOG(WII_IPC_HLE, "%s faking IOCtlV()", m_Name.c_str()); WARN_LOG(WII_IPC_HLE, "%s faking IOCtlV()", m_Name.c_str());
Memory::Write_U32(FS_SUCCESS, CommandAddress + 4); Memory::Write_U32(FS_SUCCESS, CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }
}; };

61
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_DI.cpp
View File

@ -8,6 +8,7 @@
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "Common/Logging/LogManager.h" #include "Common/Logging/LogManager.h"
#include "Core/ConfigManager.h"
#include "Core/VolumeHandler.h" #include "Core/VolumeHandler.h"
#include "Core/HW/DVDInterface.h" #include "Core/HW/DVDInterface.h"
#include "Core/HW/Memmap.h" #include "Core/HW/Memmap.h"
@ -25,22 +26,22 @@ CWII_IPC_HLE_Device_di::CWII_IPC_HLE_Device_di(u32 _DeviceID, const std::string&
CWII_IPC_HLE_Device_di::~CWII_IPC_HLE_Device_di() CWII_IPC_HLE_Device_di::~CWII_IPC_HLE_Device_di()
{} {}
bool CWII_IPC_HLE_Device_di::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_di::Open(u32 _CommandAddress, u32 _Mode)
{ {
Memory::Write_U32(GetDeviceID(), _CommandAddress + 4); Memory::Write_U32(GetDeviceID(), _CommandAddress + 4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_di::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_di::Close(u32 _CommandAddress, bool _bForce)
{ {
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_di::IOCtl(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_di::IOCtl(u32 _CommandAddress)
{ {
u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10); u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10);
u32 BufferInSize = Memory::Read_U32(_CommandAddress + 0x14); u32 BufferInSize = Memory::Read_U32(_CommandAddress + 0x14);
@ -65,11 +66,14 @@ bool CWII_IPC_HLE_Device_di::IOCtl(u32 _CommandAddress)
DVDCommandResult result = ExecuteCommand(command_0, command_1, command_2, DVDCommandResult result = ExecuteCommand(command_0, command_1, command_2,
BufferOut, BufferOutSize, false); BufferOut, BufferOutSize, false);
Memory::Write_U32(result.interrupt_type, _CommandAddress + 0x4); Memory::Write_U32(result.interrupt_type, _CommandAddress + 0x4);
// TODO: Don't discard result.ticks_until_completion
return true; if (SConfig::GetInstance().m_LocalCoreStartupParameter.bFastDiscSpeed)
result.ticks_until_completion = 0; // An optional hack to speed up loading times
return { true, result.ticks_until_completion };
} }
bool CWII_IPC_HLE_Device_di::IOCtlV(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_di::IOCtlV(u32 _CommandAddress)
{ {
SIOCtlVBuffer CommandBuffer(_CommandAddress); SIOCtlVBuffer CommandBuffer(_CommandAddress);
@ -111,44 +115,5 @@ bool CWII_IPC_HLE_Device_di::IOCtlV(u32 _CommandAddress)
} }
Memory::Write_U32(ReturnValue, _CommandAddress + 4); Memory::Write_U32(ReturnValue, _CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
}
int CWII_IPC_HLE_Device_di::GetCmdDelay(u32 _CommandAddress)
{
u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10);
u32 Command = Memory::Read_U32(BufferIn) >> 24;
// Hacks below
switch (Command)
{
case DVDLowRead:
case DVDLowUnencryptedRead:
{
u32 const Size = Memory::Read_U32(BufferIn + 0x04);
// Delay depends on size of read, that makes sense, right?
// More than ~1150K "bytes / sec" hangs NSMBWii on boot.
// Less than ~800K "bytes / sec" hangs DKCR randomly (ok, probably not true)
return SystemTimers::GetTicksPerSecond() / 975000 * Size;
}
case DVDLowClearCoverInterrupt:
// Less than ~1/155th of a second hangs Oregon Trail at "loading wheel".
// More than ~1/140th of a second hangs Resident Evil Archives: Resident Evil Zero.
return SystemTimers::GetTicksPerSecond() / 146;
// case DVDLowAudioBufferConfig:
// case DVDLowInquiry:
// case DVDLowReadDiskID:
// case DVDLowWaitForCoverClose:
// case DVDLowGetCoverReg:
// case DVDLowGetCoverStatus:
// case DVDLowReset:
// case DVDLowClosePartition:
default:
// random numbers here!
// More than ~1/2000th of a second hangs DKCR with DSP HLE, maybe.
return SystemTimers::GetTicksPerSecond() / 15000;
}
} }

10
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_DI.h
View File

@ -20,11 +20,9 @@ public:
virtual ~CWII_IPC_HLE_Device_di(); virtual ~CWII_IPC_HLE_Device_di();
bool Open(u32 _CommandAddress, u32 _Mode) override; IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
bool Close(u32 _CommandAddress, bool _bForce) override; IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
bool IOCtl(u32 _CommandAddress) override; IPCCommandResult IOCtl(u32 _CommandAddress) override;
bool IOCtlV(u32 _CommandAddress) override; IPCCommandResult IOCtlV(u32 _CommandAddress) override;
int GetCmdDelay(u32) override;
}; };

24
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_FileIO.cpp
View File

@ -78,7 +78,7 @@ CWII_IPC_HLE_Device_FileIO::~CWII_IPC_HLE_Device_FileIO()
{ {
} }
bool CWII_IPC_HLE_Device_FileIO::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_FileIO::Close(u32 _CommandAddress, bool _bForce)
{ {
INFO_LOG(WII_IPC_FILEIO, "FileIO: Close %s (DeviceID=%08x)", m_Name.c_str(), m_DeviceID); INFO_LOG(WII_IPC_FILEIO, "FileIO: Close %s (DeviceID=%08x)", m_Name.c_str(), m_DeviceID);
m_Mode = 0; m_Mode = 0;
@ -87,10 +87,10 @@ bool CWII_IPC_HLE_Device_FileIO::Close(u32 _CommandAddress, bool _bForce)
if (_CommandAddress && !_bForce) if (_CommandAddress && !_bForce)
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_FileIO::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_FileIO::Open(u32 _CommandAddress, u32 _Mode)
{ {
m_Mode = _Mode; m_Mode = _Mode;
u32 ReturnValue = 0; u32 ReturnValue = 0;
@ -121,7 +121,7 @@ bool CWII_IPC_HLE_Device_FileIO::Open(u32 _CommandAddress, u32 _Mode)
if (_CommandAddress) if (_CommandAddress)
Memory::Write_U32(ReturnValue, _CommandAddress+4); Memory::Write_U32(ReturnValue, _CommandAddress+4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
File::IOFile CWII_IPC_HLE_Device_FileIO::OpenFile() File::IOFile CWII_IPC_HLE_Device_FileIO::OpenFile()
@ -147,7 +147,7 @@ File::IOFile CWII_IPC_HLE_Device_FileIO::OpenFile()
return File::IOFile(m_filepath, open_mode); return File::IOFile(m_filepath, open_mode);
} }
bool CWII_IPC_HLE_Device_FileIO::Seek(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_FileIO::Seek(u32 _CommandAddress)
{ {
u32 ReturnValue = FS_RESULT_FATAL; u32 ReturnValue = FS_RESULT_FATAL;
const s32 SeekPosition = Memory::Read_U32(_CommandAddress + 0xC); const s32 SeekPosition = Memory::Read_U32(_CommandAddress + 0xC);
@ -208,10 +208,10 @@ bool CWII_IPC_HLE_Device_FileIO::Seek(u32 _CommandAddress)
} }
Memory::Write_U32(ReturnValue, _CommandAddress + 0x4); Memory::Write_U32(ReturnValue, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_FileIO::Read(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_FileIO::Read(u32 _CommandAddress)
{ {
u32 ReturnValue = FS_EACCESS; u32 ReturnValue = FS_EACCESS;
const u32 Address = Memory::Read_U32(_CommandAddress + 0xC); // Read to this memory address const u32 Address = Memory::Read_U32(_CommandAddress + 0xC); // Read to this memory address
@ -247,10 +247,10 @@ bool CWII_IPC_HLE_Device_FileIO::Read(u32 _CommandAddress)
} }
Memory::Write_U32(ReturnValue, _CommandAddress + 0x4); Memory::Write_U32(ReturnValue, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_FileIO::Write(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_FileIO::Write(u32 _CommandAddress)
{ {
u32 ReturnValue = FS_EACCESS; u32 ReturnValue = FS_EACCESS;
const u32 Address = Memory::Read_U32(_CommandAddress + 0xC); // Write data from this memory address const u32 Address = Memory::Read_U32(_CommandAddress + 0xC); // Write data from this memory address
@ -280,10 +280,10 @@ bool CWII_IPC_HLE_Device_FileIO::Write(u32 _CommandAddress)
} }
Memory::Write_U32(ReturnValue, _CommandAddress + 0x4); Memory::Write_U32(ReturnValue, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_FileIO::IOCtl(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_FileIO::IOCtl(u32 _CommandAddress)
{ {
INFO_LOG(WII_IPC_FILEIO, "FileIO: IOCtl (Device=%s)", m_Name.c_str()); INFO_LOG(WII_IPC_FILEIO, "FileIO: IOCtl (Device=%s)", m_Name.c_str());
#if defined(_DEBUG) || defined(DEBUGFAST) #if defined(_DEBUG) || defined(DEBUGFAST)
@ -323,7 +323,7 @@ bool CWII_IPC_HLE_Device_FileIO::IOCtl(u32 _CommandAddress)
Memory::Write_U32(ReturnValue, _CommandAddress + 0x4); Memory::Write_U32(ReturnValue, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
void CWII_IPC_HLE_Device_FileIO::DoState(PointerWrap &p) void CWII_IPC_HLE_Device_FileIO::DoState(PointerWrap &p)

12
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_FileIO.h
View File

@ -17,12 +17,12 @@ public:
virtual ~CWII_IPC_HLE_Device_FileIO(); virtual ~CWII_IPC_HLE_Device_FileIO();
bool Close(u32 _CommandAddress, bool _bForce) override; IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
bool Open(u32 _CommandAddress, u32 _Mode) override; IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
bool Seek(u32 _CommandAddress) override; IPCCommandResult Seek(u32 _CommandAddress) override;
bool Read(u32 _CommandAddress) override; IPCCommandResult Read(u32 _CommandAddress) override;
bool Write(u32 _CommandAddress) override; IPCCommandResult Write(u32 _CommandAddress) override;
bool IOCtl(u32 _CommandAddress) override; IPCCommandResult IOCtl(u32 _CommandAddress) override;
void DoState(PointerWrap &p) override; void DoState(PointerWrap &p) override;
File::IOFile OpenFile(); File::IOFile OpenFile();

56
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_es.cpp
View File

@ -172,7 +172,7 @@ void CWII_IPC_HLE_Device_es::DoState(PointerWrap& p)
} }
} }
bool CWII_IPC_HLE_Device_es::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_es::Open(u32 _CommandAddress, u32 _Mode)
{ {
OpenInternal(); OpenInternal();
@ -180,10 +180,10 @@ bool CWII_IPC_HLE_Device_es::Open(u32 _CommandAddress, u32 _Mode)
if (m_Active) if (m_Active)
INFO_LOG(WII_IPC_ES, "Device was re-opened."); INFO_LOG(WII_IPC_ES, "Device was re-opened.");
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_es::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_es::Close(u32 _CommandAddress, bool _bForce)
{ {
// Leave deletion of the INANDContentLoader objects to CNANDContentManager, don't do it here! // Leave deletion of the INANDContentLoader objects to CNANDContentManager, don't do it here!
m_NANDContent.clear(); m_NANDContent.clear();
@ -201,7 +201,7 @@ bool CWII_IPC_HLE_Device_es::Close(u32 _CommandAddress, bool _bForce)
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
u32 CWII_IPC_HLE_Device_es::OpenTitleContent(u32 CFD, u64 TitleID, u16 Index) u32 CWII_IPC_HLE_Device_es::OpenTitleContent(u32 CFD, u64 TitleID, u16 Index)
@ -244,7 +244,7 @@ u32 CWII_IPC_HLE_Device_es::OpenTitleContent(u32 CFD, u64 TitleID, u16 Index)
return CFD; return CFD;
} }
bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
{ {
SIOCtlVBuffer Buffer(_CommandAddress); SIOCtlVBuffer Buffer(_CommandAddress);
@ -281,7 +281,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETDEVICEID %08X", ec.getNgId()); INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETDEVICEID %08X", ec.getNgId());
Memory::Write_U32(ec.getNgId(), Buffer.PayloadBuffer[0].m_Address); Memory::Write_U32(ec.getNgId(), Buffer.PayloadBuffer[0].m_Address);
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -311,7 +311,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTITLECONTENTSCNT: TitleID: %08x/%08x content count %i", INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTITLECONTENTSCNT: TitleID: %08x/%08x content count %i",
(u32)(TitleID>>32), (u32)TitleID, rNANDContent.IsValid() ? NumberOfPrivateContent : (u32)rNANDContent.GetContentSize()); (u32)(TitleID>>32), (u32)TitleID, rNANDContent.IsValid() ? NumberOfPrivateContent : (u32)rNANDContent.GetContentSize());
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -342,7 +342,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
GetContentSize()); GetContentSize());
} }
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -360,7 +360,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
INFO_LOG(WII_IPC_ES, "IOCTL_ES_OPENTITLECONTENT: TitleID: %08x/%08x Index %i -> got CFD %x", (u32)(TitleID>>32), (u32)TitleID, Index, CFD); INFO_LOG(WII_IPC_ES, "IOCTL_ES_OPENTITLECONTENT: TitleID: %08x/%08x Index %i -> got CFD %x", (u32)(TitleID>>32), (u32)TitleID, Index, CFD);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -374,7 +374,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
Memory::Write_U32(CFD, _CommandAddress + 0x4); Memory::Write_U32(CFD, _CommandAddress + 0x4);
INFO_LOG(WII_IPC_ES, "IOCTL_ES_OPENCONTENT: Index %i -> got CFD %x", Index, CFD); INFO_LOG(WII_IPC_ES, "IOCTL_ES_OPENCONTENT: Index %i -> got CFD %x", Index, CFD);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -391,7 +391,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
if (itr == m_ContentAccessMap.end()) if (itr == m_ContentAccessMap.end())
{ {
Memory::Write_U32(-1, _CommandAddress + 0x4); Memory::Write_U32(-1, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
SContentAccess& rContent = itr->second; SContentAccess& rContent = itr->second;
@ -433,7 +433,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
INFO_LOG(WII_IPC_ES, "IOCTL_ES_READCONTENT: CFD %x, Address 0x%x, Size %i -> stream pos %i (Index %i)", CFD, Addr, Size, rContent.m_Position, rContent.m_pContent->m_Index); INFO_LOG(WII_IPC_ES, "IOCTL_ES_READCONTENT: CFD %x, Address 0x%x, Size %i -> stream pos %i (Index %i)", CFD, Addr, Size, rContent.m_Position, rContent.m_pContent->m_Index);
Memory::Write_U32(Size, _CommandAddress + 0x4); Memory::Write_U32(Size, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -450,14 +450,14 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
if (itr == m_ContentAccessMap.end()) if (itr == m_ContentAccessMap.end())
{ {
Memory::Write_U32(-1, _CommandAddress + 0x4); Memory::Write_U32(-1, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
delete itr->second.m_pFile; delete itr->second.m_pFile;
m_ContentAccessMap.erase(itr); m_ContentAccessMap.erase(itr);
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -474,7 +474,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
if (itr == m_ContentAccessMap.end()) if (itr == m_ContentAccessMap.end())
{ {
Memory::Write_U32(-1, _CommandAddress + 0x4); Memory::Write_U32(-1, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
SContentAccess& rContent = itr->second; SContentAccess& rContent = itr->second;
@ -496,7 +496,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
INFO_LOG(WII_IPC_ES, "IOCTL_ES_SEEKCONTENT: CFD %x, Address 0x%x, Mode %i -> Pos %i", CFD, Addr, Mode, rContent.m_Position); INFO_LOG(WII_IPC_ES, "IOCTL_ES_SEEKCONTENT: CFD %x, Address 0x%x, Mode %i -> Pos %i", CFD, Addr, Mode, rContent.m_Position);
Memory::Write_U32(rContent.m_Position, _CommandAddress + 0x4); Memory::Write_U32(rContent.m_Position, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -547,7 +547,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -570,7 +570,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTITLES: Number of titles returned %i", Count); INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTITLES: Number of titles returned %i", Count);
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -617,7 +617,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
Memory::Write_U32(ViewCount, Buffer.PayloadBuffer[0].m_Address); Memory::Write_U32(ViewCount, Buffer.PayloadBuffer[0].m_Address);
Memory::Write_U32(retVal, _CommandAddress + 0x4); Memory::Write_U32(retVal, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -681,7 +681,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETVIEWS for titleID: %08x/%08x (MaxViews = %i)", (u32)(TitleID >> 32), (u32)TitleID, maxViews); INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETVIEWS for titleID: %08x/%08x (MaxViews = %i)", (u32)(TitleID >> 32), (u32)TitleID, maxViews);
Memory::Write_U32(retVal, _CommandAddress + 0x4); Memory::Write_U32(retVal, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -707,7 +707,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTMDVIEWCNT: title: %08x/%08x (view size %i)", (u32)(TitleID >> 32), (u32)TitleID, TMDViewCnt); INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTMDVIEWCNT: title: %08x/%08x (view size %i)", (u32)(TitleID >> 32), (u32)TitleID, TMDViewCnt);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -747,7 +747,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTMDVIEWS: title: %08x/%08x (buffer size: %i)", (u32)(TitleID >> 32), (u32)TitleID, MaxCount); INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTMDVIEWS: title: %08x/%08x (buffer size: %i)", (u32)(TitleID >> 32), (u32)TitleID, MaxCount);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -755,7 +755,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
Memory::Write_U32(0, Buffer.PayloadBuffer[1].m_Address); Memory::Write_U32(0, Buffer.PayloadBuffer[1].m_Address);
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
WARN_LOG(WII_IPC_ES, "IOCTL_ES_GETCONSUMPTION:%d", Memory::Read_U32(_CommandAddress+4)); WARN_LOG(WII_IPC_ES, "IOCTL_ES_GETCONSUMPTION:%d", Memory::Read_U32(_CommandAddress+4));
return true; return IPC_DEFAULT_REPLY;
case IOCTL_ES_DELETETICKET: case IOCTL_ES_DELETETICKET:
{ {
@ -809,7 +809,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETSTOREDTMDSIZE: title: %08x/%08x (view size %i)", (u32)(TitleID >> 32), (u32)TitleID, TMDCnt); INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETSTOREDTMDSIZE: title: %08x/%08x (view size %i)", (u32)(TitleID >> 32), (u32)TitleID, TMDCnt);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
case IOCTL_ES_GETSTOREDTMD: case IOCTL_ES_GETSTOREDTMD:
@ -850,7 +850,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETSTOREDTMD: title: %08x/%08x (buffer size: %i)", (u32)(TitleID >> 32), (u32)TitleID, MaxCount); INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETSTOREDTMD: title: %08x/%08x (buffer size: %i)", (u32)(TitleID >> 32), (u32)TitleID, MaxCount);
return true; return IPC_DEFAULT_REPLY;
} }
break; break;
@ -997,7 +997,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
// Generate a "reply" to the IPC command. ES_LAUNCH is unique because it // Generate a "reply" to the IPC command. ES_LAUNCH is unique because it
// involves restarting IOS; IOS generates two acknowledgements in a row. // involves restarting IOS; IOS generates two acknowledgements in a row.
WII_IPC_HLE_Interface::EnqueueCommandAcknowledgement(_CommandAddress, 0); WII_IPC_HLE_Interface::EnqueueCommandAcknowledgement(_CommandAddress, 0);
return false; return IPC_NO_REPLY;
} }
break; break;
@ -1006,7 +1006,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
//if the IOS didn't find the Korean keys and 0 if it does. 0 leads to a error 003 //if the IOS didn't find the Korean keys and 0 if it does. 0 leads to a error 003
WARN_LOG(WII_IPC_ES,"IOCTL_ES_CHECKKOREAREGION: Title checked for Korean keys."); WARN_LOG(WII_IPC_ES,"IOCTL_ES_CHECKKOREAREGION: Title checked for Korean keys.");
Memory::Write_U32(ES_PARAMTER_SIZE_OR_ALIGNMENT , _CommandAddress + 0x4); Memory::Write_U32(ES_PARAMTER_SIZE_OR_ALIGNMENT , _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
case IOCTL_ES_GETDEVICECERT: // (Input: none, Output: 384 bytes) case IOCTL_ES_GETDEVICECERT: // (Input: none, Output: 384 bytes)
{ {
@ -1062,7 +1062,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
// Write return value (0 means OK) // Write return value (0 means OK)
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
const DiscIO::INANDContentLoader& CWII_IPC_HLE_Device_es::AccessContentDevice(u64 _TitleID) const DiscIO::INANDContentLoader& CWII_IPC_HLE_Device_es::AccessContentDevice(u64 _TitleID)

6
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_es.h
View File

@ -24,11 +24,11 @@ public:
virtual void DoState(PointerWrap& p) override; virtual void DoState(PointerWrap& p) override;
virtual bool Open(u32 _CommandAddress, u32 _Mode) override; virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
virtual bool Close(u32 _CommandAddress, bool _bForce) override; virtual IPCCommandResult IOCtlV(u32 _CommandAddress) override;
virtual bool IOCtlV(u32 _CommandAddress) override;
static u32 ES_DIVerify(u8 *_pTMD, u32 _sz); static u32 ES_DIVerify(u8 *_pTMD, u32 _sz);
// This should only be cleared on power reset // This should only be cleared on power reset

27
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_fs.cpp
View File

@ -17,6 +17,10 @@
static Common::replace_v replacements; static Common::replace_v replacements;
// ~1/1000th of a second is too short and causes hangs in Wii Party
// Play it safe at 1/500th
static const IPCCommandResult IPC_FS_REPLY = { true, SystemTimers::GetTicksPerSecond() / 500 };
CWII_IPC_HLE_Device_fs::CWII_IPC_HLE_Device_fs(u32 _DeviceID, const std::string& _rDeviceName) CWII_IPC_HLE_Device_fs::CWII_IPC_HLE_Device_fs(u32 _DeviceID, const std::string& _rDeviceName)
: IWII_IPC_HLE_Device(_DeviceID, _rDeviceName) : IWII_IPC_HLE_Device(_DeviceID, _rDeviceName)
{ {
@ -26,7 +30,7 @@ CWII_IPC_HLE_Device_fs::CWII_IPC_HLE_Device_fs(u32 _DeviceID, const std::string&
CWII_IPC_HLE_Device_fs::~CWII_IPC_HLE_Device_fs() CWII_IPC_HLE_Device_fs::~CWII_IPC_HLE_Device_fs()
{} {}
bool CWII_IPC_HLE_Device_fs::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_fs::Open(u32 _CommandAddress, u32 _Mode)
{ {
// clear tmp folder // clear tmp folder
{ {
@ -37,16 +41,16 @@ bool CWII_IPC_HLE_Device_fs::Open(u32 _CommandAddress, u32 _Mode)
Memory::Write_U32(GetDeviceID(), _CommandAddress+4); Memory::Write_U32(GetDeviceID(), _CommandAddress+4);
m_Active = true; m_Active = true;
return true; return IPC_FS_REPLY;
} }
bool CWII_IPC_HLE_Device_fs::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_fs::Close(u32 _CommandAddress, bool _bForce)
{ {
INFO_LOG(WII_IPC_FILEIO, "Close"); INFO_LOG(WII_IPC_FILEIO, "Close");
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_FS_REPLY;
} }
// Get total filesize of contents of a directory (recursive) // Get total filesize of contents of a directory (recursive)
@ -64,7 +68,7 @@ static u64 ComputeTotalFileSize(const File::FSTEntry& parentEntry)
return sizeOfFiles; return sizeOfFiles;
} }
bool CWII_IPC_HLE_Device_fs::IOCtlV(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_fs::IOCtlV(u32 _CommandAddress)
{ {
u32 ReturnValue = FS_RESULT_OK; u32 ReturnValue = FS_RESULT_OK;
SIOCtlVBuffer CommandBuffer(_CommandAddress); SIOCtlVBuffer CommandBuffer(_CommandAddress);
@ -223,10 +227,10 @@ bool CWII_IPC_HLE_Device_fs::IOCtlV(u32 _CommandAddress)
Memory::Write_U32(ReturnValue, _CommandAddress+4); Memory::Write_U32(ReturnValue, _CommandAddress+4);
return true; return IPC_FS_REPLY;
} }
bool CWII_IPC_HLE_Device_fs::IOCtl(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_fs::IOCtl(u32 _CommandAddress)
{ {
//u32 DeviceID = Memory::Read_U32(_CommandAddress + 8); //u32 DeviceID = Memory::Read_U32(_CommandAddress + 8);
//LOG(WII_IPC_FILEIO, "FS: IOCtl (Device=%s, DeviceID=%08x)", GetDeviceName().c_str(), DeviceID); //LOG(WII_IPC_FILEIO, "FS: IOCtl (Device=%s, DeviceID=%08x)", GetDeviceName().c_str(), DeviceID);
@ -245,7 +249,7 @@ bool CWII_IPC_HLE_Device_fs::IOCtl(u32 _CommandAddress)
u32 ReturnValue = ExecuteCommand(Parameter, BufferIn, BufferInSize, BufferOut, BufferOutSize); u32 ReturnValue = ExecuteCommand(Parameter, BufferIn, BufferInSize, BufferOut, BufferOutSize);
Memory::Write_U32(ReturnValue, _CommandAddress + 4); Memory::Write_U32(ReturnValue, _CommandAddress + 4);
return true; return IPC_FS_REPLY;
} }
s32 CWII_IPC_HLE_Device_fs::ExecuteCommand(u32 _Parameter, u32 _BufferIn, u32 _BufferInSize, u32 _BufferOut, u32 _BufferOutSize) s32 CWII_IPC_HLE_Device_fs::ExecuteCommand(u32 _Parameter, u32 _BufferIn, u32 _BufferInSize, u32 _BufferOut, u32 _BufferOutSize)
@ -485,13 +489,6 @@ s32 CWII_IPC_HLE_Device_fs::ExecuteCommand(u32 _Parameter, u32 _BufferIn, u32 _B
return FS_RESULT_FATAL; return FS_RESULT_FATAL;
} }
int CWII_IPC_HLE_Device_fs::GetCmdDelay(u32)
{
// ~1/1000th of a second is too short and causes hangs in Wii Party
// Play it safe at 1/500th
return SystemTimers::GetTicksPerSecond() / 500;
}
void CWII_IPC_HLE_Device_fs::DoState(PointerWrap& p) void CWII_IPC_HLE_Device_fs::DoState(PointerWrap& p)
{ {
DoStateShared(p); DoStateShared(p);

10
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_fs.h
View File

@ -38,13 +38,11 @@ public:
virtual void DoState(PointerWrap& p) override; virtual void DoState(PointerWrap& p) override;
virtual bool Open(u32 _CommandAddress, u32 _Mode) override; virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
virtual bool Close(u32 _CommandAddress, bool _bForce) override; virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
virtual bool IOCtl(u32 _CommandAddress) override; virtual IPCCommandResult IOCtl(u32 _CommandAddress) override;
virtual bool IOCtlV(u32 _CommandAddress) override; virtual IPCCommandResult IOCtlV(u32 _CommandAddress) override;
virtual int GetCmdDelay(u32) override;
private: private:

22
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_hid.cpp
View File

@ -109,24 +109,24 @@ CWII_IPC_HLE_Device_hid::~CWII_IPC_HLE_Device_hid()
libusb_exit(nullptr); libusb_exit(nullptr);
} }
bool CWII_IPC_HLE_Device_hid::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_hid::Open(u32 _CommandAddress, u32 _Mode)
{ {
DEBUG_LOG(WII_IPC_HID, "HID::Open"); DEBUG_LOG(WII_IPC_HID, "HID::Open");
m_Active = true; m_Active = true;
Memory::Write_U32(GetDeviceID(), _CommandAddress + 4); Memory::Write_U32(GetDeviceID(), _CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_hid::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_hid::Close(u32 _CommandAddress, bool _bForce)
{ {
DEBUG_LOG(WII_IPC_HID, "HID::Close"); DEBUG_LOG(WII_IPC_HID, "HID::Close");
m_Active = false; m_Active = false;
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
{ {
u32 Parameter = Memory::Read_U32(_CommandAddress + 0xC); u32 Parameter = Memory::Read_U32(_CommandAddress + 0xC);
u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10); u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10);
@ -142,7 +142,7 @@ bool CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
DEBUG_LOG(WII_IPC_HID, "HID::IOCtl(Get Attached) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)", DEBUG_LOG(WII_IPC_HID, "HID::IOCtl(Get Attached) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
BufferIn, BufferInSize, BufferOut, BufferOutSize); BufferIn, BufferInSize, BufferOut, BufferOutSize);
deviceCommandAddress = _CommandAddress; deviceCommandAddress = _CommandAddress;
return false; return IPC_NO_REPLY;
} }
case IOCTL_HID_OPEN: case IOCTL_HID_OPEN:
{ {
@ -205,7 +205,7 @@ bool CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
// bmRequestType, bRequest, BufferIn, BufferInSize, BufferOut, BufferOutSize); // bmRequestType, bRequest, BufferIn, BufferInSize, BufferOut, BufferOutSize);
// It's the async way! // It's the async way!
return false; return IPC_NO_REPLY;
} }
case IOCTL_HID_INTERRUPT_OUT: case IOCTL_HID_INTERRUPT_OUT:
case IOCTL_HID_INTERRUPT_IN: case IOCTL_HID_INTERRUPT_IN:
@ -236,7 +236,7 @@ bool CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
// Parameter == IOCTL_HID_INTERRUPT_IN ? "In" : "Out", endpoint, length, data, BufferIn, BufferInSize, BufferOut, BufferOutSize); // Parameter == IOCTL_HID_INTERRUPT_IN ? "In" : "Out", endpoint, length, data, BufferIn, BufferInSize, BufferOut, BufferOutSize);
// It's the async way! // It's the async way!
return false; return IPC_NO_REPLY;
} }
case IOCTL_HID_SHUTDOWN: case IOCTL_HID_SHUTDOWN:
{ {
@ -269,7 +269,7 @@ bool CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
Memory::Write_U32(ReturnValue, _CommandAddress + 4); Memory::Write_U32(ReturnValue, _CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }
@ -299,7 +299,7 @@ bool CWII_IPC_HLE_Device_hid::ClaimDevice(libusb_device_handle * dev)
return true; return true;
} }
bool CWII_IPC_HLE_Device_hid::IOCtlV(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_hid::IOCtlV(u32 _CommandAddress)
{ {
Dolphin_Debugger::PrintCallstack(LogTypes::WII_IPC_HID, LogTypes::LWARNING); Dolphin_Debugger::PrintCallstack(LogTypes::WII_IPC_HID, LogTypes::LWARNING);
@ -318,7 +318,7 @@ bool CWII_IPC_HLE_Device_hid::IOCtlV(u32 _CommandAddress)
#endif #endif
Memory::Write_U32(ReturnValue, _CommandAddress + 4); Memory::Write_U32(ReturnValue, _CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }

8
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_hid.h
View File

@ -36,11 +36,11 @@ public:
virtual ~CWII_IPC_HLE_Device_hid(); virtual ~CWII_IPC_HLE_Device_hid();
virtual bool Open(u32 _CommandAddress, u32 _Mode) override; virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
virtual bool Close(u32 _CommandAddress, bool _bForce) override; virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
virtual bool IOCtlV(u32 _CommandAddress) override; virtual IPCCommandResult IOCtlV(u32 _CommandAddress) override;
virtual bool IOCtl(u32 _CommandAddress) override; virtual IPCCommandResult IOCtl(u32 _CommandAddress) override;
private: private:
enum enum

58
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_net.cpp
View File

@ -60,24 +60,24 @@ CWII_IPC_HLE_Device_net_kd_request::~CWII_IPC_HLE_Device_net_kd_request()
WiiSockMan::GetInstance().Clean(); WiiSockMan::GetInstance().Clean();
} }
bool CWII_IPC_HLE_Device_net_kd_request::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_net_kd_request::Open(u32 _CommandAddress, u32 _Mode)
{ {
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: Open"); INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: Open");
Memory::Write_U32(GetDeviceID(), _CommandAddress + 4); Memory::Write_U32(GetDeviceID(), _CommandAddress + 4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_net_kd_request::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_net_kd_request::Close(u32 _CommandAddress, bool _bForce)
{ {
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: Close"); INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: Close");
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_net_kd_request::IOCtl(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_net_kd_request::IOCtl(u32 _CommandAddress)
{ {
u32 Parameter = Memory::Read_U32(_CommandAddress + 0xC); u32 Parameter = Memory::Read_U32(_CommandAddress + 0xC);
u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10); u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10);
@ -205,7 +205,7 @@ bool CWII_IPC_HLE_Device_net_kd_request::IOCtl(u32 _CommandAddress)
} }
Memory::Write_U32(ReturnValue, _CommandAddress + 4); Memory::Write_U32(ReturnValue, _CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }
@ -340,24 +340,24 @@ CWII_IPC_HLE_Device_net_ncd_manage::~CWII_IPC_HLE_Device_net_ncd_manage()
{ {
} }
bool CWII_IPC_HLE_Device_net_ncd_manage::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_net_ncd_manage::Open(u32 _CommandAddress, u32 _Mode)
{ {
INFO_LOG(WII_IPC_NET, "NET_NCD_MANAGE: Open"); INFO_LOG(WII_IPC_NET, "NET_NCD_MANAGE: Open");
Memory::Write_U32(GetDeviceID(), _CommandAddress+4); Memory::Write_U32(GetDeviceID(), _CommandAddress+4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_net_ncd_manage::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_net_ncd_manage::Close(u32 _CommandAddress, bool _bForce)
{ {
INFO_LOG(WII_IPC_NET, "NET_NCD_MANAGE: Close"); INFO_LOG(WII_IPC_NET, "NET_NCD_MANAGE: Close");
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_net_ncd_manage::IOCtlV(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_net_ncd_manage::IOCtlV(u32 _CommandAddress)
{ {
u32 return_value = 0; u32 return_value = 0;
u32 common_result = 0; u32 common_result = 0;
@ -423,7 +423,7 @@ bool CWII_IPC_HLE_Device_net_ncd_manage::IOCtlV(u32 _CommandAddress)
Memory::Write_U32(common_result, CommandBuffer.PayloadBuffer.at(common_vector).m_Address + 4); Memory::Write_U32(common_result, CommandBuffer.PayloadBuffer.at(common_vector).m_Address + 4);
} }
Memory::Write_U32(return_value, _CommandAddress + 4); Memory::Write_U32(return_value, _CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }
// ********************************************************************************** // **********************************************************************************
@ -437,27 +437,27 @@ CWII_IPC_HLE_Device_net_wd_command::~CWII_IPC_HLE_Device_net_wd_command()
{ {
} }
bool CWII_IPC_HLE_Device_net_wd_command::Open(u32 CommandAddress, u32 Mode) IPCCommandResult CWII_IPC_HLE_Device_net_wd_command::Open(u32 CommandAddress, u32 Mode)
{ {
INFO_LOG(WII_IPC_NET, "NET_WD_COMMAND: Open"); INFO_LOG(WII_IPC_NET, "NET_WD_COMMAND: Open");
Memory::Write_U32(GetDeviceID(), CommandAddress + 4); Memory::Write_U32(GetDeviceID(), CommandAddress + 4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_net_wd_command::Close(u32 CommandAddress, bool Force) IPCCommandResult CWII_IPC_HLE_Device_net_wd_command::Close(u32 CommandAddress, bool Force)
{ {
INFO_LOG(WII_IPC_NET, "NET_WD_COMMAND: Close"); INFO_LOG(WII_IPC_NET, "NET_WD_COMMAND: Close");
if (!Force) if (!Force)
Memory::Write_U32(0, CommandAddress + 4); Memory::Write_U32(0, CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
// This is just for debugging / playing around. // This is just for debugging / playing around.
// There really is no reason to implement wd unless we can bend it such that // There really is no reason to implement wd unless we can bend it such that
// we can talk to the DS. // we can talk to the DS.
bool CWII_IPC_HLE_Device_net_wd_command::IOCtlV(u32 CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_net_wd_command::IOCtlV(u32 CommandAddress)
{ {
u32 return_value = 0; u32 return_value = 0;
@ -544,7 +544,7 @@ bool CWII_IPC_HLE_Device_net_wd_command::IOCtlV(u32 CommandAddress)
} }
Memory::Write_U32(return_value, CommandAddress + 4); Memory::Write_U32(return_value, CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }
// ********************************************************************************** // **********************************************************************************
@ -565,21 +565,21 @@ CWII_IPC_HLE_Device_net_ip_top::~CWII_IPC_HLE_Device_net_ip_top()
#endif #endif
} }
bool CWII_IPC_HLE_Device_net_ip_top::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_net_ip_top::Open(u32 _CommandAddress, u32 _Mode)
{ {
INFO_LOG(WII_IPC_NET, "NET_IP_TOP: Open"); INFO_LOG(WII_IPC_NET, "NET_IP_TOP: Open");
Memory::Write_U32(GetDeviceID(), _CommandAddress+4); Memory::Write_U32(GetDeviceID(), _CommandAddress+4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_net_ip_top::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_net_ip_top::Close(u32 _CommandAddress, bool _bForce)
{ {
INFO_LOG(WII_IPC_NET, "NET_IP_TOP: Close"); INFO_LOG(WII_IPC_NET, "NET_IP_TOP: Close");
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
static int inet_pton(const char* src, unsigned char* dst) static int inet_pton(const char* src, unsigned char* dst)
@ -638,7 +638,7 @@ static unsigned int opt_name_mapping[][2] = {
{ SO_ERROR, 0x1009 } { SO_ERROR, 0x1009 }
}; };
bool CWII_IPC_HLE_Device_net_ip_top::IOCtl(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_net_ip_top::IOCtl(u32 _CommandAddress)
{ {
u32 Command = Memory::Read_U32(_CommandAddress + 0x0C); u32 Command = Memory::Read_U32(_CommandAddress + 0x0C);
u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10); u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10);
@ -697,7 +697,7 @@ bool CWII_IPC_HLE_Device_net_ip_top::IOCtl(u32 _CommandAddress)
u32 fd = Memory::Read_U32(BufferIn); u32 fd = Memory::Read_U32(BufferIn);
WiiSockMan &sm = WiiSockMan::GetInstance(); WiiSockMan &sm = WiiSockMan::GetInstance();
sm.DoSock(fd, _CommandAddress, (NET_IOCTL)Command); sm.DoSock(fd, _CommandAddress, (NET_IOCTL)Command);
return false; return IPC_NO_REPLY;
} }
///////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////
// TODO: Tidy all below // // TODO: Tidy all below //
@ -1134,11 +1134,11 @@ bool CWII_IPC_HLE_Device_net_ip_top::IOCtl(u32 _CommandAddress)
Memory::Write_U32(ReturnValue, _CommandAddress + 0x4); Memory::Write_U32(ReturnValue, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_net_ip_top::IOCtlV(u32 CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_net_ip_top::IOCtlV(u32 CommandAddress)
{ {
SIOCtlVBuffer CommandBuffer(CommandAddress); SIOCtlVBuffer CommandBuffer(CommandAddress);
@ -1307,7 +1307,7 @@ bool CWII_IPC_HLE_Device_net_ip_top::IOCtlV(u32 CommandAddress)
u32 fd = Memory::Read_U32(_BufferIn2); u32 fd = Memory::Read_U32(_BufferIn2);
WiiSockMan &sm = WiiSockMan::GetInstance(); WiiSockMan &sm = WiiSockMan::GetInstance();
sm.DoSock(fd, CommandAddress, IOCTLV_SO_SENDTO); sm.DoSock(fd, CommandAddress, IOCTLV_SO_SENDTO);
return false; return IPC_NO_REPLY;
break; break;
} }
case IOCTLV_SO_RECVFROM: case IOCTLV_SO_RECVFROM:
@ -1315,7 +1315,7 @@ bool CWII_IPC_HLE_Device_net_ip_top::IOCtlV(u32 CommandAddress)
u32 fd = Memory::Read_U32(_BufferIn); u32 fd = Memory::Read_U32(_BufferIn);
WiiSockMan &sm = WiiSockMan::GetInstance(); WiiSockMan &sm = WiiSockMan::GetInstance();
sm.DoSock(fd, CommandAddress, IOCTLV_SO_RECVFROM); sm.DoSock(fd, CommandAddress, IOCTLV_SO_RECVFROM);
return false; return IPC_NO_REPLY;
break; break;
} }
case IOCTLV_SO_GETADDRINFO: case IOCTLV_SO_GETADDRINFO:
@ -1491,7 +1491,7 @@ bool CWII_IPC_HLE_Device_net_ip_top::IOCtlV(u32 CommandAddress)
} }
Memory::Write_U32(ReturnValue, CommandAddress + 4); Memory::Write_U32(ReturnValue, CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }
u32 CWII_IPC_HLE_Device_net_ip_top::Update() u32 CWII_IPC_HLE_Device_net_ip_top::Update()
{ {

38
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_net.h
View File

@ -391,9 +391,9 @@ public:
virtual ~CWII_IPC_HLE_Device_net_kd_request(); virtual ~CWII_IPC_HLE_Device_net_kd_request();
virtual bool Open(u32 _CommandAddress, u32 _Mode) override; virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
virtual bool Close(u32 _CommandAddress, bool _bForce) override; virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
virtual bool IOCtl(u32 _CommandAddress) override; virtual IPCCommandResult IOCtl(u32 _CommandAddress) override;
private: private:
enum enum
@ -454,22 +454,22 @@ public:
virtual ~CWII_IPC_HLE_Device_net_kd_time() virtual ~CWII_IPC_HLE_Device_net_kd_time()
{} {}
virtual bool Open(u32 _CommandAddress, u32 _Mode) override virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override
{ {
INFO_LOG(WII_IPC_NET, "NET_KD_TIME: Open"); INFO_LOG(WII_IPC_NET, "NET_KD_TIME: Open");
Memory::Write_U32(GetDeviceID(), _CommandAddress+4); Memory::Write_U32(GetDeviceID(), _CommandAddress+4);
return true; return IPC_DEFAULT_REPLY;
} }
virtual bool Close(u32 _CommandAddress, bool _bForce) override virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override
{ {
INFO_LOG(WII_IPC_NET, "NET_KD_TIME: Close"); INFO_LOG(WII_IPC_NET, "NET_KD_TIME: Close");
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }
virtual bool IOCtl(u32 _CommandAddress) override virtual IPCCommandResult IOCtl(u32 _CommandAddress) override
{ {
u32 Parameter = Memory::Read_U32(_CommandAddress + 0x0C); u32 Parameter = Memory::Read_U32(_CommandAddress + 0x0C);
u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10); u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10);
@ -512,7 +512,7 @@ public:
// write return values // write return values
Memory::Write_U32(common_result, BufferOut); Memory::Write_U32(common_result, BufferOut);
Memory::Write_U32(result, _CommandAddress + 4); Memory::Write_U32(result, _CommandAddress + 4);
return true; return IPC_DEFAULT_REPLY;
} }
private: private:
@ -593,10 +593,10 @@ public:
virtual ~CWII_IPC_HLE_Device_net_ip_top(); virtual ~CWII_IPC_HLE_Device_net_ip_top();
virtual bool Open(u32 _CommandAddress, u32 _Mode) override; virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
virtual bool Close(u32 _CommandAddress, bool _bForce) override; virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
virtual bool IOCtl(u32 _CommandAddress) override; virtual IPCCommandResult IOCtl(u32 _CommandAddress) override;
virtual bool IOCtlV(u32 _CommandAddress) override; virtual IPCCommandResult IOCtlV(u32 _CommandAddress) override;
virtual u32 Update() override; virtual u32 Update() override;
@ -617,9 +617,9 @@ public:
virtual ~CWII_IPC_HLE_Device_net_ncd_manage(); virtual ~CWII_IPC_HLE_Device_net_ncd_manage();
virtual bool Open(u32 _CommandAddress, u32 _Mode) override; virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
virtual bool Close(u32 _CommandAddress, bool _bForce) override; virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
virtual bool IOCtlV(u32 _CommandAddress) override; virtual IPCCommandResult IOCtlV(u32 _CommandAddress) override;
private: private:
enum enum
@ -645,9 +645,9 @@ public:
virtual ~CWII_IPC_HLE_Device_net_wd_command(); virtual ~CWII_IPC_HLE_Device_net_wd_command();
virtual bool Open(u32 CommandAddress, u32 Mode) override; virtual IPCCommandResult Open(u32 CommandAddress, u32 Mode) override;
virtual bool Close(u32 CommandAddress, bool Force) override; virtual IPCCommandResult Close(u32 CommandAddress, bool Force) override;
virtual bool IOCtlV(u32 CommandAddress) override; virtual IPCCommandResult IOCtlV(u32 CommandAddress) override;
private: private:
enum enum

22
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_net_ssl.cpp
View File

@ -52,24 +52,24 @@ int CWII_IPC_HLE_Device_net_ssl::getSSLFreeID()
return 0; return 0;
} }
bool CWII_IPC_HLE_Device_net_ssl::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_net_ssl::Open(u32 _CommandAddress, u32 _Mode)
{ {
Memory::Write_U32(GetDeviceID(), _CommandAddress+4); Memory::Write_U32(GetDeviceID(), _CommandAddress+4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_net_ssl::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_net_ssl::Close(u32 _CommandAddress, bool _bForce)
{ {
if (!_bForce) if (!_bForce)
{ {
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
} }
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_net_ssl::IOCtl(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_net_ssl::IOCtl(u32 _CommandAddress)
{ {
u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10); u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10);
u32 BufferInSize = Memory::Read_U32(_CommandAddress + 0x14); u32 BufferInSize = Memory::Read_U32(_CommandAddress + 0x14);
@ -82,10 +82,10 @@ bool CWII_IPC_HLE_Device_net_ssl::IOCtl(u32 _CommandAddress)
GetDeviceName().c_str(), Command, GetDeviceName().c_str(), Command,
BufferIn, BufferInSize, BufferOut, BufferOutSize); BufferIn, BufferInSize, BufferOut, BufferOutSize);
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_net_ssl::IOCtlV(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_net_ssl::IOCtlV(u32 _CommandAddress)
{ {
SIOCtlVBuffer CommandBuffer(_CommandAddress); SIOCtlVBuffer CommandBuffer(_CommandAddress);
@ -393,7 +393,7 @@ _SSL_NEW_ERROR:
{ {
WiiSockMan &sm = WiiSockMan::GetInstance(); WiiSockMan &sm = WiiSockMan::GetInstance();
sm.DoSock(_SSL[sslID].sockfd, _CommandAddress, IOCTLV_NET_SSL_DOHANDSHAKE); sm.DoSock(_SSL[sslID].sockfd, _CommandAddress, IOCTLV_NET_SSL_DOHANDSHAKE);
return false; return IPC_NO_REPLY;
} }
else else
{ {
@ -408,7 +408,7 @@ _SSL_NEW_ERROR:
{ {
WiiSockMan &sm = WiiSockMan::GetInstance(); WiiSockMan &sm = WiiSockMan::GetInstance();
sm.DoSock(_SSL[sslID].sockfd, _CommandAddress, IOCTLV_NET_SSL_WRITE); sm.DoSock(_SSL[sslID].sockfd, _CommandAddress, IOCTLV_NET_SSL_WRITE);
return false; return IPC_NO_REPLY;
} }
else else
{ {
@ -433,7 +433,7 @@ _SSL_NEW_ERROR:
{ {
WiiSockMan &sm = WiiSockMan::GetInstance(); WiiSockMan &sm = WiiSockMan::GetInstance();
sm.DoSock(_SSL[sslID].sockfd, _CommandAddress, IOCTLV_NET_SSL_READ); sm.DoSock(_SSL[sslID].sockfd, _CommandAddress, IOCTLV_NET_SSL_READ);
return false; return IPC_NO_REPLY;
} }
else else
{ {
@ -506,6 +506,6 @@ _SSL_NEW_ERROR:
// SSL return codes are written to BufferIn // SSL return codes are written to BufferIn
Memory::Write_U32(0, _CommandAddress+4); Memory::Write_U32(0, _CommandAddress+4);
return true; return IPC_DEFAULT_REPLY;
} }

8
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_net_ssl.h
View File

@ -75,12 +75,12 @@ public:
virtual ~CWII_IPC_HLE_Device_net_ssl(); virtual ~CWII_IPC_HLE_Device_net_ssl();
virtual bool Open(u32 _CommandAddress, u32 _Mode) override; virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
virtual bool Close(u32 _CommandAddress, bool _bForce) override; virtual IPCCommandResult IOCtl(u32 _CommandAddress) override;
virtual IPCCommandResult IOCtlV(u32 _CommandAddress) override;
virtual bool IOCtl(u32 _CommandAddress) override;
virtual bool IOCtlV(u32 _CommandAddress) override;
int getSSLFreeID(); int getSSLFreeID();
static WII_SSL _SSL[NET_SSL_MAXINSTANCES]; static WII_SSL _SSL[NET_SSL_MAXINSTANCES];

20
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_sdio_slot0.cpp
View File

@ -76,7 +76,7 @@ void CWII_IPC_HLE_Device_sdio_slot0::OpenInternal()
} }
} }
bool CWII_IPC_HLE_Device_sdio_slot0::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_sdio_slot0::Open(u32 _CommandAddress, u32 _Mode)
{ {
INFO_LOG(WII_IPC_SD, "Open"); INFO_LOG(WII_IPC_SD, "Open");
@ -85,10 +85,10 @@ bool CWII_IPC_HLE_Device_sdio_slot0::Open(u32 _CommandAddress, u32 _Mode)
Memory::Write_U32(GetDeviceID(), _CommandAddress + 0x4); Memory::Write_U32(GetDeviceID(), _CommandAddress + 0x4);
memset(m_Registers, 0, sizeof(m_Registers)); memset(m_Registers, 0, sizeof(m_Registers));
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_sdio_slot0::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_sdio_slot0::Close(u32 _CommandAddress, bool _bForce)
{ {
INFO_LOG(WII_IPC_SD, "Close"); INFO_LOG(WII_IPC_SD, "Close");
@ -99,11 +99,11 @@ bool CWII_IPC_HLE_Device_sdio_slot0::Close(u32 _CommandAddress, bool _bForce)
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
// The front SD slot // The front SD slot
bool CWII_IPC_HLE_Device_sdio_slot0::IOCtl(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_sdio_slot0::IOCtl(u32 _CommandAddress)
{ {
u32 Cmd = Memory::Read_U32(_CommandAddress + 0xC); u32 Cmd = Memory::Read_U32(_CommandAddress + 0xC);
@ -226,7 +226,7 @@ bool CWII_IPC_HLE_Device_sdio_slot0::IOCtl(u32 _CommandAddress)
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
// Check if the condition is already true // Check if the condition is already true
EventNotify(); EventNotify();
return false; return IPC_NO_REPLY;
} }
else if (ReturnValue == RET_EVENT_UNREGISTER) else if (ReturnValue == RET_EVENT_UNREGISTER)
{ {
@ -237,16 +237,16 @@ bool CWII_IPC_HLE_Device_sdio_slot0::IOCtl(u32 _CommandAddress)
m_event.addr = 0; m_event.addr = 0;
m_event.type = EVENT_NONE; m_event.type = EVENT_NONE;
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
else else
{ {
Memory::Write_U32(ReturnValue, _CommandAddress + 0x4); Memory::Write_U32(ReturnValue, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
} }
bool CWII_IPC_HLE_Device_sdio_slot0::IOCtlV(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_sdio_slot0::IOCtlV(u32 _CommandAddress)
{ {
// PPC sending commands // PPC sending commands
@ -280,7 +280,7 @@ bool CWII_IPC_HLE_Device_sdio_slot0::IOCtlV(u32 _CommandAddress)
Memory::Write_U32(ReturnValue, _CommandAddress + 0x4); Memory::Write_U32(ReturnValue, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
u32 CWII_IPC_HLE_Device_sdio_slot0::ExecuteCommand(u32 _BufferIn, u32 _BufferInSize, u32 CWII_IPC_HLE_Device_sdio_slot0::ExecuteCommand(u32 _BufferIn, u32 _BufferInSize,

9
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_sdio_slot0.h
View File

@ -16,10 +16,11 @@ public:
virtual void DoState(PointerWrap& p) override; virtual void DoState(PointerWrap& p) override;
bool Open(u32 _CommandAddress, u32 _Mode) override; IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
bool Close(u32 _CommandAddress, bool _bForce) override; IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
bool IOCtl(u32 _CommandAddress) override;
bool IOCtlV(u32 _CommandAddress) override; IPCCommandResult IOCtl(u32 _CommandAddress) override;
IPCCommandResult IOCtlV(u32 _CommandAddress) override;
static void EnqueueReply(u32 CommandAddress, u32 ReturnValue); static void EnqueueReply(u32 CommandAddress, u32 ReturnValue);
void EventNotify(); void EventNotify();

24
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_stm.h
View File

@ -36,24 +36,24 @@ public:
virtual ~CWII_IPC_HLE_Device_stm_immediate() virtual ~CWII_IPC_HLE_Device_stm_immediate()
{} {}
virtual bool Open(u32 _CommandAddress, u32 _Mode) override virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override
{ {
INFO_LOG(WII_IPC_STM, "STM immediate: Open"); INFO_LOG(WII_IPC_STM, "STM immediate: Open");
Memory::Write_U32(GetDeviceID(), _CommandAddress+4); Memory::Write_U32(GetDeviceID(), _CommandAddress+4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
virtual bool Close(u32 _CommandAddress, bool _bForce) override virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override
{ {
INFO_LOG(WII_IPC_STM, "STM immediate: Close"); INFO_LOG(WII_IPC_STM, "STM immediate: Close");
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress+4); Memory::Write_U32(0, _CommandAddress+4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
virtual bool IOCtl(u32 _CommandAddress) override virtual IPCCommandResult IOCtl(u32 _CommandAddress) override
{ {
u32 Parameter = Memory::Read_U32(_CommandAddress + 0x0C); u32 Parameter = Memory::Read_U32(_CommandAddress + 0x0C);
u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10); u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10);
@ -107,7 +107,7 @@ public:
// Write return value to the IPC call // Write return value to the IPC call
Memory::Write_U32(ReturnValue, _CommandAddress + 0x4); Memory::Write_U32(ReturnValue, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
}; };
@ -125,14 +125,14 @@ public:
{ {
} }
virtual bool Open(u32 _CommandAddress, u32 _Mode) override virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override
{ {
Memory::Write_U32(GetDeviceID(), _CommandAddress + 4); Memory::Write_U32(GetDeviceID(), _CommandAddress + 4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
virtual bool Close(u32 _CommandAddress, bool _bForce) override virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override
{ {
m_EventHookAddress = 0; m_EventHookAddress = 0;
@ -140,10 +140,10 @@ public:
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress+4); Memory::Write_U32(0, _CommandAddress+4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
virtual bool IOCtl(u32 _CommandAddress) override virtual IPCCommandResult IOCtl(u32 _CommandAddress) override
{ {
u32 Parameter = Memory::Read_U32(_CommandAddress + 0x0C); u32 Parameter = Memory::Read_U32(_CommandAddress + 0x0C);
u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10); u32 BufferIn = Memory::Read_U32(_CommandAddress + 0x10);
@ -182,7 +182,7 @@ public:
// Write return value to the IPC call, 0 means success // Write return value to the IPC call, 0 means success
Memory::Write_U32(ReturnValue, _CommandAddress + 0x4); Memory::Write_U32(ReturnValue, _CommandAddress + 0x4);
return false; return IPC_DEFAULT_REPLY;
} }
// STATE_TO_SAVE // STATE_TO_SAVE

14
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_usb.cpp
View File

@ -129,7 +129,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::RemoteDisconnect(u16 _connectionHandle
return SendEventDisconnect(_connectionHandle, 0x13); return SendEventDisconnect(_connectionHandle, 0x13);
} }
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_usb_oh1_57e_305::Open(u32 _CommandAddress, u32 _Mode)
{ {
m_ScanEnable = 0; m_ScanEnable = 0;
@ -141,10 +141,10 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::Open(u32 _CommandAddress, u32 _Mode)
Memory::Write_U32(GetDeviceID(), _CommandAddress + 4); Memory::Write_U32(GetDeviceID(), _CommandAddress + 4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_usb_oh1_57e_305::Close(u32 _CommandAddress, bool _bForce)
{ {
m_ScanEnable = 0; m_ScanEnable = 0;
@ -157,16 +157,16 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::Close(u32 _CommandAddress, bool _bForc
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::IOCtl(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_usb_oh1_57e_305::IOCtl(u32 _CommandAddress)
{ {
//ERROR_LOG(WII_IPC_WIIMOTE, "Passing ioctl to ioctlv"); //ERROR_LOG(WII_IPC_WIIMOTE, "Passing ioctl to ioctlv");
return IOCtlV(_CommandAddress); // FIXME: Hack return IOCtlV(_CommandAddress); // FIXME: Hack
} }
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::IOCtlV(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_usb_oh1_57e_305::IOCtlV(u32 _CommandAddress)
{ {
/* /*
Memory::Write_U8(255, 0x80149950); // BTM LOG // 3 logs L2Cap // 4 logs l2_csm$ Memory::Write_U8(255, 0x80149950); // BTM LOG // 3 logs L2Cap // 4 logs l2_csm$
@ -304,7 +304,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::IOCtlV(u32 _CommandAddress)
// write return value // write return value
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
return _SendReply; return { _SendReply, IPC_DEFAULT_DELAY };
} }

8
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_usb.h
View File

@ -50,11 +50,11 @@ public:
virtual ~CWII_IPC_HLE_Device_usb_oh1_57e_305(); virtual ~CWII_IPC_HLE_Device_usb_oh1_57e_305();
virtual bool Open(u32 _CommandAddress, u32 _Mode) override; virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
virtual bool Close(u32 _CommandAddress, bool _bForce) override; virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
virtual bool IOCtlV(u32 _CommandAddress) override; virtual IPCCommandResult IOCtlV(u32 _CommandAddress) override;
virtual bool IOCtl(u32 _CommandAddress) override; virtual IPCCommandResult IOCtl(u32 _CommandAddress) override;
virtual u32 Update() override; virtual u32 Update() override;

16
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_usb_kbd.cpp
View File

@ -20,7 +20,7 @@ CWII_IPC_HLE_Device_usb_kbd::CWII_IPC_HLE_Device_usb_kbd(u32 _DeviceID, const st
CWII_IPC_HLE_Device_usb_kbd::~CWII_IPC_HLE_Device_usb_kbd() CWII_IPC_HLE_Device_usb_kbd::~CWII_IPC_HLE_Device_usb_kbd()
{} {}
bool CWII_IPC_HLE_Device_usb_kbd::Open(u32 _CommandAddress, u32 _Mode) IPCCommandResult CWII_IPC_HLE_Device_usb_kbd::Open(u32 _CommandAddress, u32 _Mode)
{ {
INFO_LOG(WII_IPC_STM, "CWII_IPC_HLE_Device_usb_kbd: Open"); INFO_LOG(WII_IPC_STM, "CWII_IPC_HLE_Device_usb_kbd: Open");
IniFile ini; IniFile ini;
@ -37,10 +37,10 @@ bool CWII_IPC_HLE_Device_usb_kbd::Open(u32 _CommandAddress, u32 _Mode)
//m_MessageQueue.push(SMessageData(MSG_KBD_CONNECT, 0, nullptr)); //m_MessageQueue.push(SMessageData(MSG_KBD_CONNECT, 0, nullptr));
Memory::Write_U32(m_DeviceID, _CommandAddress+4); Memory::Write_U32(m_DeviceID, _CommandAddress+4);
m_Active = true; m_Active = true;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_usb_kbd::Close(u32 _CommandAddress, bool _bForce) IPCCommandResult CWII_IPC_HLE_Device_usb_kbd::Close(u32 _CommandAddress, bool _bForce)
{ {
INFO_LOG(WII_IPC_STM, "CWII_IPC_HLE_Device_usb_kbd: Close"); INFO_LOG(WII_IPC_STM, "CWII_IPC_HLE_Device_usb_kbd: Close");
while (!m_MessageQueue.empty()) while (!m_MessageQueue.empty())
@ -48,19 +48,19 @@ bool CWII_IPC_HLE_Device_usb_kbd::Close(u32 _CommandAddress, bool _bForce)
if (!_bForce) if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 4); Memory::Write_U32(0, _CommandAddress + 4);
m_Active = false; m_Active = false;
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_usb_kbd::Write(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_usb_kbd::Write(u32 _CommandAddress)
{ {
INFO_LOG(WII_IPC_STM, "Ignoring write to CWII_IPC_HLE_Device_usb_kbd"); INFO_LOG(WII_IPC_STM, "Ignoring write to CWII_IPC_HLE_Device_usb_kbd");
#if defined(_DEBUG) || defined(DEBUGFAST) #if defined(_DEBUG) || defined(DEBUGFAST)
DumpCommands(_CommandAddress, 10, LogTypes::WII_IPC_STM, LogTypes::LDEBUG); DumpCommands(_CommandAddress, 10, LogTypes::WII_IPC_STM, LogTypes::LDEBUG);
#endif #endif
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_usb_kbd::IOCtl(u32 _CommandAddress) IPCCommandResult CWII_IPC_HLE_Device_usb_kbd::IOCtl(u32 _CommandAddress)
{ {
u32 BufferOut = Memory::Read_U32(_CommandAddress + 0x18); u32 BufferOut = Memory::Read_U32(_CommandAddress + 0x18);
@ -71,7 +71,7 @@ bool CWII_IPC_HLE_Device_usb_kbd::IOCtl(u32 _CommandAddress)
} }
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
return true; return IPC_DEFAULT_REPLY;
} }
bool CWII_IPC_HLE_Device_usb_kbd::IsKeyPressed(int _Key) bool CWII_IPC_HLE_Device_usb_kbd::IsKeyPressed(int _Key)

8
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_usb_kbd.h
View File

@ -12,10 +12,10 @@ public:
CWII_IPC_HLE_Device_usb_kbd(u32 _DeviceID, const std::string& _rDeviceName); CWII_IPC_HLE_Device_usb_kbd(u32 _DeviceID, const std::string& _rDeviceName);
virtual ~CWII_IPC_HLE_Device_usb_kbd(); virtual ~CWII_IPC_HLE_Device_usb_kbd();
virtual bool Open(u32 _CommandAddress, u32 _Mode) override; virtual IPCCommandResult Open(u32 _CommandAddress, u32 _Mode) override;
virtual bool Close(u32 _CommandAddress, bool _bForce) override; virtual IPCCommandResult Close(u32 _CommandAddress, bool _bForce) override;
virtual bool Write(u32 _CommandAddress) override; virtual IPCCommandResult Write(u32 _CommandAddress) override;
virtual bool IOCtl(u32 _CommandAddress) override; virtual IPCCommandResult IOCtl(u32 _CommandAddress) override;
virtual u32 Update() override; virtual u32 Update() override;
private: private: