izzy/dolphin
0
0
Fork 0
mirror of https://github.com/izzy2lost/dolphin.git synced 2026-06-19 01:16:48 -07:00
Code Issues Packages Projects Releases Wiki Activity

commit ayuanx's patch from issue 1634. Fixes quite a few IPC + IPC_HLE + IPC_HLE_USB + wiimote problems, see the issue for full details

Browse Source 
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4606 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
Shawn Hoffman
2009-11-24 05:03:47 +00:00
parent 55dc7efaa4
commit 6a46befc2a
20 changed files with 1171 additions and 1090 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/Core/Core/Src/HW/HW.cpp
+8 -3
View File
@@ -62,8 +62,8 @@ namespace HW
SystemTimers::Init();
if (SConfig::GetInstance().m_LocalCoreStartupParameter.bWii)
{
WII_IPC_HLE_Interface::Init();
WII_IPCInterface::Init();
WII_IPC_HLE_Interface::Init();
}
}
@@ -80,8 +80,8 @@ namespace HW
if (SConfig::GetInstance().m_LocalCoreStartupParameter.bWii)
{
WII_IPC_HLE_Interface::Shutdown();
WII_IPCInterface::Shutdown();
WII_IPC_HLE_Interface::Shutdown();
}
State_Shutdown();
@@ -100,12 +100,17 @@ namespace HW
GPFifo::DoState(p);
ExpansionInterface::DoState(p);
AudioInterface::DoState(p);
WII_IPCInterface::DoState(p);
if (SConfig::GetInstance().m_LocalCoreStartupParameter.bWii)
{
WII_IPCInterface::DoState(p);
WII_IPC_HLE_Interface::DoState(p);
}
}
// Restart Wiimote
void InitWiimote()
{
WII_IPCInterface::Init();
WII_IPC_HLE_Interface::Init();
}
}
Source/Core/Core/Src/HW/SystemTimers.cpp
+8 -5
View File
@@ -102,6 +102,7 @@ broadway: 729
// So, ratio is 1 / (1/4 * 1/3 = 1/12) = 12.
// note: ZWW is ok and faster with TIMER_RATIO=8 though.
// !!! POSSIBLE STABLE PERF BOOST HACK THERE !!!
enum
{
TIMER_RATIO = 12
@@ -174,15 +175,14 @@ void AudioFifoCallback(u64 userdata, int cyclesLate)
void IPC_HLE_UpdateCallback(u64 userdata, int cyclesLate)
{
WII_IPC_HLE_Interface::UpdateDevices();
CoreTiming::ScheduleEvent(IPC_HLE_PERIOD-cyclesLate, et_IPC_HLE);
if (Core::GetStartupParameter().bWii)
WII_IPC_HLE_Interface::Update();
CoreTiming::ScheduleEvent(VideoInterface::GetTicksPerLine()-cyclesLate, et_IPC_HLE);
}
void VICallback(u64 userdata, int cyclesLate)
{
if (Core::GetStartupParameter().bWii)
WII_IPC_HLE_Interface::Update();
VideoInterface::Update();
CoreTiming::ScheduleEvent(VideoInterface::GetTicksPerLine() - cyclesLate, et_VI);
}
@@ -252,6 +252,9 @@ void Init()
if (!UsingDSPLLE)
DSP_PERIOD = (int)(GetTicksPerSecond() * 0.003f);
// AyuanX: TO BE TWEAKED
// If this update frequency is too high, WiiMote could easily jam the IPC Bus
// but if it is too low, sometimes IPC gets overflown by CPU :~~~(
IPC_HLE_PERIOD = (int)(GetTicksPerSecond() * 0.003f);
}
else
Source/Core/Core/Src/HW/WII_IPC.cpp
+103 -55
View File
@@ -85,36 +85,46 @@ union UIPC_Config
};
// STATE_TO_SAVE
UIPC_Status g_IPC_Status;
UIPC_Config g_IPC_Config;
UIPC_Control g_IPC_Control;
u32 g_Address = 0;
u32 g_Reply = 0;
u32 g_SensorBarPower = 0;
bool g_ExeCmd = false;
u32 g_Address = NULL;
u32 g_Reply = NULL;
u32 g_ReplyHead = NULL;
u32 g_ReplyTail = NULL;
u32 g_SensorBarPower = NULL;
UIPC_Status g_IPC_Status(NULL);
UIPC_Config g_IPC_Config(NULL);
UIPC_Control g_IPC_Control(NULL);
void DoState(PointerWrap &p)
{
p.Do(g_ExeCmd);
p.Do(g_Address);
p.Do(g_Reply);
p.Do(g_ReplyHead);
p.Do(g_ReplyTail);
p.Do(g_SensorBarPower);
p.Do(g_IPC_Status);
p.Do(g_IPC_Config);
p.Do(g_IPC_Control);
p.Do(g_Address);
p.Do(g_Reply);
p.Do(g_SensorBarPower);
}
void UpdateInterrupts();
// Init
void Init()
{
g_Address = 0;
g_Reply = 0;
g_SensorBarPower = 0;
g_ExeCmd = false;
g_Address = NULL;
g_Reply = NULL;
g_ReplyHead = NULL;
g_ReplyTail = NULL;
g_SensorBarPower = NULL;
g_IPC_Status = UIPC_Status(NULL);
g_IPC_Config = UIPC_Config(NULL);
g_IPC_Control = UIPC_Control(NULL);
}
g_IPC_Status = UIPC_Status();
g_IPC_Config = UIPC_Config();
g_IPC_Control = UIPC_Control();
void Reset()
{
Init();
}
void Shutdown()
@@ -127,16 +137,16 @@ void Read32(u32& _rReturnValue, const u32 _Address)
{
case IPC_CONTROL_REGISTER:
_rReturnValue = g_IPC_Control.Hex;
INFO_LOG(WII_IPC, "IOP: Read32 from IPC_CONTROL_REGISTER(0x04) = 0x%08x", _rReturnValue);
INFO_LOG(WII_IPC, "IOP: Read32, IPC_CONTROL_REGISTER(0x04) = 0x%08x [R:%i A:%i E:%i]",
_rReturnValue, (_rReturnValue>>2)&1, (_rReturnValue>>1)&1, _rReturnValue&1);
// if ((REASON_REG & 0x14) == 0x14) CALL IPCReplayHanlder
// if ((REASON_REG & 0x22) != 0x22) Jumps to the end
break;
case IPC_REPLY_REGISTER: // looks a little bit like a callback function
_rReturnValue = g_Reply;
INFO_LOG(WII_IPC, "IOP: Write32 to IPC_REPLAY_REGISTER(0x08) = 0x%08x ", _rReturnValue);
INFO_LOG(WII_IPC, "IOP: Read32, IPC_REPLY_REGISTER(0x08) = 0x%08x ", _rReturnValue);
break;
case IPC_SENSOR_BAR_POWER_REGISTER:
@@ -146,7 +156,7 @@ void Read32(u32& _rReturnValue, const u32 _Address)
default:
_dbg_assert_msg_(WII_IPC, 0, "IOP: Read32 from 0x%08x", _Address);
break;
}
}
}
void Write32(const u32 _Value, const u32 _Address)
@@ -157,30 +167,36 @@ void Write32(const u32 _Value, const u32 _Address)
case IPC_COMMAND_REGISTER: // __ios_Ipc2 ... a value from __responses is loaded
{
g_Address = _Value;
INFO_LOG(WII_IPC, "IOP: Write32 to IPC_ADDRESS_REGISTER(0x00) = 0x%08x", g_Address);
INFO_LOG(WII_IPC, "IOP: Write32, IPC_ADDRESS_REGISTER(0x00) = 0x%08x", g_Address);
}
break;
case IPC_CONTROL_REGISTER:
{
INFO_LOG(WII_IPC, "IOP: Write32 to IPC_CONTROL_REGISTER(0x04) = 0x%08x (old: 0x%08x)", _Value, g_IPC_Control.Hex);
INFO_LOG(WII_IPC, "IOP: Write32, IPC_CONTROL_REGISTER(0x04) = 0x%08x [R:%i A:%i E:%i] (old: 0x%08x) ",
_Value, (_Value>>2)&1, (_Value>>1)&1, _Value&1, g_IPC_Control.Hex);
UIPC_Control TempControl(_Value);
_dbg_assert_msg_(WII_IPC, TempControl.pad == 0, "IOP: Write to UIPC_Control.pad", _Address);
if (TempControl.AckReady) { g_IPC_Control.AckReady = 0; }
if (TempControl.ReplyReady) { g_IPC_Control.ReplyReady = 0; }
if (TempControl.Relaunch) { g_IPC_Control.Relaunch = 0; }
// Ayuanx: What is this Relaunch bit used for ???
// I have done considerable amount of tests that show no use of it at all
// So I'm commenting this out
//
//if (TempControl.Relaunch) { g_IPC_Control.Relaunch = 0; }
g_IPC_Control.Relaunch = TempControl.Relaunch;
g_IPC_Control.unk5 = TempControl.unk5;
g_IPC_Control.unk6 = TempControl.unk6;
g_IPC_Control.pad = TempControl.pad;
if (TempControl.ExecuteCmd)
{
WII_IPC_HLE_Interface::AckCommand(g_Address);
}
g_ExeCmd = true;
}
}
break;
@@ -189,21 +205,22 @@ void Write32(const u32 _Value, const u32 _Address)
UIPC_Status NewStatus(_Value);
if (NewStatus.INTERRUPT) g_IPC_Status.INTERRUPT = 0; // clear interrupt
INFO_LOG(WII_IPC, "IOP: Write32 to IPC_STATUS_REGISTER(0x30) = 0x%08x", _Value);
INFO_LOG(WII_IPC, "IOP: Write32, IPC_STATUS_REGISTER(0x30) = 0x%08x", _Value);
}
break;
case IPC_CONFIG_REGISTER: // __OSInterruptInit (0x40000000)
{
INFO_LOG(WII_IPC, "IOP: Write32 to IPC_CONFIG_REGISTER(0x33) = 0x%08x", _Value);
INFO_LOG(WII_IPC, "IOP: Write32, IPC_CONFIG_REGISTER(0x33) = 0x%08x", _Value);
g_IPC_Config.Hex = _Value;
if (_Value&0x40000000)
{
WII_IPC_HLE_Interface::Reset();
}
if (_Value&0x40000000)
{
INFO_LOG(WII_IPC, "Reset triggered, Resetting ...");
Reset();
WII_IPC_HLE_Interface::Reset();
}
}
break;
@@ -217,11 +234,58 @@ void Write32(const u32 _Value, const u32 _Address)
}
break;
}
// update the interrupts
UpdateInterrupts();
}
u32 GetAddress()
{
return ((g_ExeCmd) ? g_Address : NULL);
}
void GenerateAck()
{
g_ExeCmd = false;
g_IPC_Control.AckReady = 1;
UpdateInterrupts();
}
void GenerateReply(u32 _Address)
{
g_Reply = _Address;
g_IPC_Control.ReplyReady = 1;
UpdateInterrupts();
}
void EnqReply(u32 _Address)
{
// AyuanX: Replies are stored in a FIFO (depth 2), like ping-pong, and 2 is fairly enough
// Simple structure of fixed length will do good for DoState
//
if (g_ReplyHead == NULL)
{
g_ReplyHead = g_ReplyTail;
g_ReplyTail = _Address;
}
else
{
ERROR_LOG(WII_IPC, "Reply FIFO is full, something must be wrong!");
PanicAlert("WII_IPC: Reply FIFO is full, something must be wrong!");
}
}
u32 DeqReply()
{
u32 _Address = (g_ReplyHead) ? g_ReplyHead : g_ReplyTail;
if (g_ReplyHead)
g_ReplyHead = NULL;
else
g_ReplyTail = NULL;
return _Address;
}
void UpdateInterrupts()
{
if ((g_IPC_Control.AckReady == 1) ||
@@ -246,22 +310,6 @@ bool IsReady()
return ((g_IPC_Control.ReplyReady == 0) && (g_IPC_Control.AckReady == 0) && (g_IPC_Status.INTERRUPT == 0));
}
void GenerateAck(u32 _AnswerAddress)
{
g_Reply = _AnswerAddress;
g_IPC_Control.AckReady = 1;
UpdateInterrupts();
}
void GenerateReply(u32 _AnswerAddress)
{
g_Reply = _AnswerAddress;
g_IPC_Control.ReplyReady = 1;
UpdateInterrupts();
}
} // end of namespace IPC
Source/Core/Core/Src/HW/WII_IPC.h
+11 -6
View File
@@ -24,18 +24,23 @@ namespace WII_IPCInterface
{
void Init();
void Reset();
void Shutdown();
void DoState(PointerWrap &p);
void Update();
bool IsReady();
void GenerateReply(u32 _AnswerAddress);
void GenerateAck(u32 _AnswerAddress);
void Read32(u32& _rReturnValue, const u32 _Address);
void Write32(const u32 _Value, const u32 _Address);
u32 GetAddress();
void GenerateAck();
void GenerateReply(u32 _Address);
void InsertReply(u32 _Address);
void EnqReply(u32 _Address);
u32 DeqReply();
void UpdateInterrupts();
bool IsReady();
} // end of namespace AudioInterface
#endif
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE.cpp
+120 -134
View File
@@ -66,6 +66,7 @@
#include "../Debugger/Debugger_SymbolMap.h"
#include "../PowerPC/PowerPC.h"
namespace WII_IPC_HLE_Interface
{
@@ -74,11 +75,6 @@ TDeviceMap g_DeviceMap;
// STATE_TO_SAVE
u32 g_LastDeviceID = 0x13370000;
std::list<u32> g_Ack;
u32 g_AckNumber = 0;
std::queue<std::pair<u32,std::string> > g_ReplyQueue;
void ExecuteCommand(u32 _Address);
std::string g_DefaultContentFile;
// General IPC functions
@@ -89,27 +85,22 @@ void Init()
void Reset()
{
// AyuanX: We really should save this to state or build the map and devices statically
// Mem dynamic allocation is too risky when doing state save/load
TDeviceMap::const_iterator itr = g_DeviceMap.begin();
while (itr != g_DeviceMap.end())
{
delete itr->second;
++itr;
if (itr->second)
delete itr->second;
++itr;
}
g_DeviceMap.clear();
while (!g_ReplyQueue.empty())
{
g_ReplyQueue.pop();
}
g_Ack.clear();
}
void Shutdown()
{
Reset();
g_LastDeviceID = 0x13370000;
g_AckNumber = 0;
g_DefaultContentFile.clear();
}
@@ -237,31 +228,7 @@ IWII_IPC_HLE_Device* CreateDevice(u32 _DeviceID, const std::string& _rDeviceName
debugging I also noticed that the Ioctl arguments are stored temporarily in
0x933e.... with the same .... as in the _CommandAddress. */
// ----------------
bool AckCommand(u32 _Address)
{
#if MAX_LOG_LEVEL >= DEBUG_LEVEL
Debugger::PrintCallstack(LogTypes::WII_IPC_HLE, LogTypes::LDEBUG);
#endif
INFO_LOG(WII_IPC_HLE, "AckCommand: 0%08x (num: %i) PC=0x%08x", _Address, g_AckNumber, PC);
std::list<u32>::iterator itr = g_Ack.begin();
while (itr != g_Ack.end())
{
if (*itr == _Address)
{
ERROR_LOG(WII_IPC_HLE, "execute a command two times");
PanicAlert("execute a command two times");
return false;
}
itr++;
}
g_Ack.push_back(_Address);
g_AckNumber++;
return true;
}
// Let the game read the setting.txt file
void CopySettingsFile(std::string DeviceName)
@@ -289,12 +256,30 @@ void CopySettingsFile(std::string DeviceName)
}
}
void DoState(PointerWrap &p)
{
p.Do(g_LastDeviceID);
//p.Do(g_DefaultContentFile);
// AyuanX: I think maybe we really should create devices statically at initilization
IWII_IPC_HLE_Device* pDevice = AccessDeviceByID(GetDeviceIDByName(std::string("/dev/usb/oh1/57e/305")));
if (pDevice)
pDevice->DoState(p);
else
PanicAlert("WII_IPC_HLE: Save/Load State failed, /dev/usb/oh1/57e/305 doesn't exist!");
}
void ExecuteCommand(u32 _Address)
{
bool GenerateReply = false;
bool CmdSuccess = false;
u32 ClosedDeviceID = 0;
ECommandType Command = static_cast<ECommandType>(Memory::Read_U32(_Address));
u32 DeviceID = Memory::Read_U32(_Address + 8);
IWII_IPC_HLE_Device* pDevice = AccessDeviceByID(DeviceID);
INFO_LOG(WII_IPC_HLE, "-->> Execute Command Address: 0x%08x (code: %x, device: %x) ", _Address, Command, DeviceID);
switch (Command)
{
case COMMAND_OPEN_DEVICE:
@@ -308,7 +293,7 @@ void ExecuteCommand(u32 _Address)
if(DeviceName.find("setting.txt") != std::string::npos) CopySettingsFile(DeviceName);
u32 Mode = Memory::Read_U32(_Address + 0x10);
u32 DeviceID = GetDeviceIDByName(DeviceName);
DeviceID = GetDeviceIDByName(DeviceName);
// check if a device with this name has been created already
if (DeviceID == 0)
@@ -317,16 +302,16 @@ void ExecuteCommand(u32 _Address)
// alternatively we could pre create all devices and put them in a directory tree structure
// then this would just return a pointer to the wanted device.
u32 CurrentDeviceID = g_LastDeviceID;
IWII_IPC_HLE_Device* pDevice = CreateDevice(CurrentDeviceID, DeviceName);
pDevice = CreateDevice(CurrentDeviceID, DeviceName);
g_DeviceMap[CurrentDeviceID] = pDevice;
g_LastDeviceID++;
GenerateReply = pDevice->Open(_Address, Mode);
CmdSuccess = pDevice->Open(_Address, Mode);
if(pDevice->GetDeviceName().find("/dev/") == std::string::npos
|| pDevice->GetDeviceName().c_str() == std::string("/dev/fs"))
{
INFO_LOG(WII_IPC_FILEIO, "IOP: Open (Device=%s, DeviceID=%08x, Mode=%i, GenerateReply=%i)",
pDevice->GetDeviceName().c_str(), CurrentDeviceID, Mode, (int)GenerateReply);
INFO_LOG(WII_IPC_FILEIO, "IOP: Open (Device=%s, DeviceID=%08x, Mode=%i, CmdSuccess=%i)",
pDevice->GetDeviceName().c_str(), CurrentDeviceID, Mode, (int)CmdSuccess);
}
else
{
@@ -337,13 +322,13 @@ void ExecuteCommand(u32 _Address)
else
{
// The device has already been opened and was not closed, reuse the same DeviceID.
pDevice = AccessDeviceByID(DeviceID);
IWII_IPC_HLE_Device* pDevice = AccessDeviceByID(DeviceID);
// If we return -6 here after a Open > Failed > CREATE_FILE > ReOpen call
// If we return -6 here after a Open > Failed > CREATE_FILE > ReOpen call
// sequence Mario Galaxy and Mario Kart Wii will not start writing to the file,
// it will just (seemingly) wait for one or two seconds and then give an error
// message. So I'm trying to return the DeviceID instead to make it write to the file.
// (Which was most likely the reason it created the file in the first place.) */
// (Which was most likely the reason it created the file in the first place.)
// F|RES: prolly the re-open is just a mode change
@@ -359,81 +344,69 @@ void ExecuteCommand(u32 _Address)
// Open > Failed > ... other stuff > ReOpen call sequence, in that case
// we have no file and no file handle, so we call Open again to basically
// get a -106 error so that the game call CreateFile and then ReOpen again.
if(pDevice->ReturnFileHandle())
Memory::Write_U32(DeviceID, _Address + 4);
else
GenerateReply = pDevice->Open(_Address, newMode);
pDevice->Open(_Address, newMode);
}
else
{
// We have already opened this device, return -6
Memory::Write_U32(u32(-6), _Address + 4);
}
GenerateReply = true;
}
CmdSuccess = true;
}
}
break;
case COMMAND_CLOSE_DEVICE:
{
u32 DeviceID = Memory::Read_U32(_Address + 8);
IWII_IPC_HLE_Device* pDevice = AccessDeviceByID(DeviceID);
{
if (pDevice != NULL)
{
pDevice->Close(_Address);
// Delete the device when CLOSE is called, this does not effect
// GenerateReply() for any other purpose than the logging because
// it's a true / false only function //
// it's a true / false only function
ClosedDeviceID = DeviceID;
GenerateReply = true;
CmdSuccess = true;
}
}
break;
case COMMAND_READ:
{
u32 DeviceID = Memory::Read_U32(_Address+8);
IWII_IPC_HLE_Device* pDevice = AccessDeviceByID(DeviceID);
if (pDevice != NULL)
GenerateReply = pDevice->Read(_Address);
CmdSuccess = pDevice->Read(_Address);
}
break;
case COMMAND_WRITE:
{
u32 DeviceID = Memory::Read_U32(_Address+8);
IWII_IPC_HLE_Device* pDevice = AccessDeviceByID(DeviceID);
if (pDevice != NULL)
GenerateReply = pDevice->Write(_Address);
CmdSuccess = pDevice->Write(_Address);
}
break;
case COMMAND_SEEK:
{
u32 DeviceID = Memory::Read_U32(_Address+8);
IWII_IPC_HLE_Device* pDevice = AccessDeviceByID(DeviceID);
if (pDevice != NULL)
GenerateReply = pDevice->Seek(_Address);
CmdSuccess = pDevice->Seek(_Address);
}
break;
case COMMAND_IOCTL:
{
u32 DeviceID = Memory::Read_U32(_Address+8);
IWII_IPC_HLE_Device* pDevice = AccessDeviceByID(DeviceID);
if (pDevice != NULL)
GenerateReply = pDevice->IOCtl(_Address);
CmdSuccess = pDevice->IOCtl(_Address);
}
break;
case COMMAND_IOCTLV:
{
u32 DeviceID = Memory::Read_U32(_Address+8);
IWII_IPC_HLE_Device* pDevice = AccessDeviceByID(DeviceID);
if (pDevice)
GenerateReply = pDevice->IOCtlV(_Address);
CmdSuccess = pDevice->IOCtlV(_Address);
}
break;
@@ -443,88 +416,101 @@ void ExecuteCommand(u32 _Address)
break;
}
// It seems that the original hardware overwrites the command after it has been
// executed. We write 8 which is not any valid command.
Memory::Write_U32(8, _Address);
//
// AyuanX: Is this really necessary?
// My experiment says no, so I'm just commenting this out
//
//Memory::Write_U32(8, _Address);
// Generate a reply to the IPC command
if (GenerateReply)
if (CmdSuccess)
{
// Get device id
// Generate a reply to the IPC command
WII_IPCInterface::EnqReply(_Address);
u32 DeviceID = Memory::Read_U32(_Address + 8);
IWII_IPC_HLE_Device* pDevice = NULL;
// Get the device from the device map
if (DeviceID != 0) {
if (g_DeviceMap.find(DeviceID) != g_DeviceMap.end())
pDevice = g_DeviceMap[DeviceID];
if (pDevice != NULL) {
// Write reply, this will later be executed in Update()
g_ReplyQueue.push(std::pair<u32, std::string>(_Address, pDevice->GetDeviceName()));
} else {
// DeviceID == 0 means it's used for devices that weren't created yet
if (DeviceID != 0)
{
if (g_DeviceMap.find(DeviceID) == g_DeviceMap.end())
ERROR_LOG(WII_IPC_HLE, "IOP: Reply to unknown device ID (DeviceID=%i)", DeviceID);
g_ReplyQueue.push(std::pair<u32, std::string>(_Address, "unknown"));
}
if (ClosedDeviceID > 0 && ClosedDeviceID == DeviceID)
if (ClosedDeviceID > 0 && (ClosedDeviceID == DeviceID))
DeleteDeviceByID(DeviceID);
} else {
// 0 is ok, as it's used for devices that weren't created yet
g_ReplyQueue.push(std::pair<u32, std::string>(_Address, "unknown"));
}
}
else
{
//INFO_LOG(WII_IPC_HLE, "<<-- Failed or Not Ready to Reply to Command Address: 0x%08x ", _Address);
}
}
// ===================================================
/* This is called continuously from SystemTimers.cpp and WII_IPCInterface::IsReady()
is controlled from WII_IPC.cpp. */
// ----------------
void UpdateDevices()
{
if (WII_IPCInterface::IsReady())
{
// check if an executed must be updated
TDeviceMap::const_iterator itr = g_DeviceMap.begin();
while(itr != g_DeviceMap.end())
{
u32 CommandAddr = itr->second->Update();
if (CommandAddr != 0)
{
g_ReplyQueue.push(std::pair<u32, std::string>(CommandAddr, itr->second->GetDeviceName()));
}
++itr;
}
}
}
// This is called continuously from SystemTimers.cpp
// ---------------------------------------------------
void Update()
{
if (WII_IPCInterface::IsReady())
if (WII_IPCInterface::IsReady() == false)
return;
UpdateDevices();
// if we have a reply to send
u32 _Reply = WII_IPCInterface::DeqReply();
if (_Reply != NULL)
{
// Check if we have to execute an acknowledge command...
if (!g_ReplyQueue.empty())
{
WII_IPCInterface::GenerateReply(g_ReplyQueue.front().first);
g_ReplyQueue.pop();
return;
}
WII_IPCInterface::GenerateReply(_Reply);
INFO_LOG(WII_IPC_HLE, "<<-- Reply to Command Address: 0x%08x", _Reply);
return;
}
// ...no we don't, we can now execute the IPC command
if (g_ReplyQueue.empty() && !g_Ack.empty())
{
u32 _Address = g_Ack.front();
g_Ack.pop_front();
DEBUG_LOG(WII_IPC_HLE, "-- Execute Ack (0x%08x)", _Address);
ExecuteCommand(_Address);
DEBUG_LOG(WII_IPC_HLE, "-- End of ExecuteAck (0x%08x)", _Address);
// If there is a a new command
u32 _Address = WII_IPCInterface::GetAddress();
if (_Address != NULL)
{
WII_IPCInterface::GenerateAck();
INFO_LOG(WII_IPC_HLE, "||-- Acknowledge Command Address: 0x%08x", _Address);
// Go back to WII_IPC.cpp and generate an acknowledgement
WII_IPCInterface::GenerateAck(_Address);
}
ExecuteCommand(_Address);
// AyuanX: Since current HLE time slot is empty, we can piggyback a reply
// Besides, this trick makes a Ping-Pong Reply FIFO never get full
// I don't know whether original hardware supports this feature or not
// but it works here and we gain 1/3 extra bandwidth
//
u32 _Reply = WII_IPCInterface::DeqReply();
if (_Reply != NULL)
{
WII_IPCInterface::GenerateReply(_Reply);
INFO_LOG(WII_IPC_HLE, "<<-- Reply to Command Address: 0x%08x", _Reply);
}
#if MAX_LOG_LEVEL >= DEBUG_LEVEL
Debugger::PrintCallstack(LogTypes::WII_IPC_HLE, LogTypes::LDEBUG);
#endif
return;
}
}
void UpdateDevices()
{
// check if a device must be updated
TDeviceMap::const_iterator itr = g_DeviceMap.begin();
while(itr != g_DeviceMap.end())
{
if (itr->second->Update())
{
break;
}
++itr;
}
}
} // end of namespace IPC
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE.h
+6 -3
View File
@@ -18,9 +18,10 @@
#ifndef _WII_IPC_HLE_H_
#define _WII_IPC_HLE_H_
#include "ChunkFile.h"
namespace WII_IPC_HLE_Interface
{
// Init
void Init();
@@ -30,6 +31,9 @@ void Shutdown();
// Reset
void Reset();
// Do State
void DoState(PointerWrap &p);
// Set default content file
void SetDefaultContentFile(const std::string& _rFilename);
@@ -39,8 +43,7 @@ void Update();
// Update Devices
void UpdateDevices();
// Acknowledge command
bool AckCommand(u32 _Address);
void ExecuteCommand(u32 _Address);
enum ECommandType
{
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device.h
+6 -6
View File
@@ -22,6 +22,8 @@
#include "../HW/Memmap.h"
#include "../HW/CPU.h"
class PointerWrap;
class IWII_IPC_HLE_Device
{
public:
@@ -34,6 +36,9 @@ public:
virtual ~IWII_IPC_HLE_Device()
{}
virtual void DoState(PointerWrap &p)
{}
const std::string& GetDeviceName() const { return m_Name; }
u32 GetDeviceID() const { return m_DeviceID; }
@@ -114,14 +119,12 @@ protected:
}
}
// STATE_TO_SAVE
const u32 m_Address;
u32 Parameter;
u32 NumberInBuffer;
u32 NumberPayloadBuffer;
u32 BufferVector;
u32 BufferSize;
struct SBuffer { u32 m_Address, m_Size; };
std::vector<SBuffer> InBuffer;
@@ -152,9 +155,8 @@ protected:
LogTypes::LOG_LEVELS Verbosity = LogTypes::LDEBUG)
{
GENERIC_LOG(LogType, Verbosity, "======= DumpAsync ======");
// write return value
u32 BufferOffset = BufferVector;
Memory::Write_U32(1, _CommandAddress + 0x4);
for (u32 i = 0; i < NumberInBuffer; i++)
{
@@ -180,8 +182,6 @@ protected:
u32 OutBuffer = Memory::Read_U32(BufferOffset); BufferOffset += 4;
u32 OutBufferSize = Memory::Read_U32(BufferOffset); BufferOffset += 4;
Memory::Write_U32(1, _CommandAddress + 0x4);
GENERIC_LOG(LogType, LogTypes::LINFO, "%s - IOCtlV OutBuffer[%i]:", GetDeviceName().c_str(), i);
GENERIC_LOG(LogType, LogTypes::LINFO, " OutBuffer: 0x%08x (0x%x):", OutBuffer, OutBufferSize);
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_usb.cpp
+404 -286
View File
File diff suppressed because it is too large Load Diff
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_usb.h
+48 -18
View File
@@ -18,11 +18,11 @@
#ifndef _WII_IPC_HLE_DEVICE_USB_H_
#define _WII_IPC_HLE_DEVICE_USB_H_
#include "WII_IPC_HLE_Device.h"
#include "hci.h"
#include <vector>
#include <queue>
#include "WII_IPC_HLE.h"
#include "WII_IPC_HLE_Device.h"
#include "WII_IPC_HLE_WiiMote.h"
@@ -38,13 +38,6 @@ union UACLHeader
u32 Hex;
};
struct ACLFrame
{
u16 ConnectionHandle;
u8* data;
u32 size;
};
struct SQueuedEvent
{
u8 m_buffer[1024];
@@ -58,7 +51,7 @@ struct SQueuedEvent
if (m_size > 1024)
{
// i know this code sux...
PanicAlert("SQueuedEvent: allocate a to big buffer!!");
PanicAlert("SQueuedEvent: allocate too big buffer!!");
}
}
};
@@ -79,7 +72,8 @@ public:
virtual u32 Update();
void SendACLFrame(u16 _ConnectionHandle, u8* _pData, u32 _Size);
void SendACLPacket(u16 _ConnectionHandle, u8* _pData, u32 _Size);
void PurgeACLFrame();
//hack for wiimote plugin
@@ -89,6 +83,8 @@ public:
CWII_IPC_HLE_WiiMote* AccessWiiMote(const bdaddr_t& _rAddr);
CWII_IPC_HLE_WiiMote* AccessWiiMote(u16 _ConnectionHandle);
void DoState(PointerWrap &p);
private:
enum
@@ -106,7 +102,7 @@ private:
enum
{
HCI_EVENT_ENDPOINT = 0x81,
ACL_DATA_ENDPOINT_READ = 0x02,
ACL_DATA_BLK_OUT = 0x02,
ACL_DATA_ENDPOINT = 0x82,
};
@@ -121,6 +117,39 @@ private:
u32 m_PayLoadAddr;
u32 m_PayLoadSize;
u32 m_Address;
};
struct ACLFrame
{
u32 m_number;
u8 m_data[1024];
ACLFrame(int num)
: m_number(num)
{
}
};
struct CtrlBuffer
{
u32 m_address;
u32 m_buffer;
CtrlBuffer(u32 _Address)
: m_address(_Address)
{
if(_Address == NULL)
{
m_buffer = NULL;
}
else
{
u32 _BufferVector = Memory::Read_U32(_Address + 0x18);
u32 _InBufferNum = Memory::Read_U32(_Address + 0x10);
m_buffer = Memory::Read_U32(_BufferVector + _InBufferNum * 8);
}
}
};
bdaddr_t m_ControllerBD;
@@ -138,13 +167,14 @@ private:
u16 m_HostNumSCOPackets;
typedef std::queue<SQueuedEvent> CEventQueue;
typedef std::queue<ACLFrame> CACLFrameQueue;
CEventQueue m_EventQueue;
CACLFrameQueue m_AclFrameQue;
SIOCtlVBuffer* m_pACLBuffer;
SIOCtlVBuffer* m_pHCIBuffer;
// STATE_TO_SAVE
SHCICommandMessage m_CtrlSetup;
CtrlBuffer m_HCIBuffer;
CtrlBuffer m_ACLBuffer;
ACLFrame m_ACLFrame;
u32 m_LastCmd;
int m_PacketCount;
// Events
void AddEventToQueue(const SQueuedEvent& _event);
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_WiiMote.cpp
+185 -177
View File
File diff suppressed because it is too large Load Diff
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_WiiMote.h
+13 -34
View File
@@ -26,7 +26,7 @@ class CWII_IPC_HLE_Device_usb_oh1_57e_305;
enum
{
SDP_CHANNEL = 0x01,
HIDP_CONTROL_CHANNEL = 0x11,
HID_CONTROL_CHANNEL = 0x11,
HID_INTERRUPT_CHANNEL= 0x13,
// L2CAP command codes
@@ -192,9 +192,13 @@ public:
// ugly Host handling....
// we really have to clean all this code
bool Update();
bool LinkChannel();
bool IsConnected() const { return m_Connected; }
bool IsLinked() const { return m_Linked; }
void ShowStatus(const void* _pData); // Show status
void UpdateStatus(); // Update status
void ExecuteL2capCmd(u8* _pData, u32 _Size); // From CPU
void ReceiveL2capData(u16 scid, const void* _pData, u32 _Size); // From wiimote
void EventConnectionAccepted();
void EventDisconnect();
@@ -202,33 +206,20 @@ public:
void EventCommandWriteLinkPolicy();
const bdaddr_t& GetBD() const { return m_BD; }
const uint8_t* GetClass() const { return uclass; }
u16 GetConnectionHandle() const { return m_ControllerConnectionHandle; }
const u8* GetFeatures() const { return features; }
const char* GetName() const { return m_Name.c_str(); }
u8 GetLMPVersion() const { return lmp_version; }
u16 GetLMPSubVersion() const { return lmp_subversion; }
u8 GetManufactorID() const { return 0xF; } // Broadcom Corporation
void SendACLFrame(u8* _pData, u32 _Size); // To wiimote
void ShowStatus(const void* _pData); // Show status
void UpdateStatus(); // Update status
void SendL2capData(u16 scid, const void* _pData, u32 _Size); // From wiimote
const u8* GetLinkKey() const { return m_LinkKey; }
private:
// state machine
bool m_Connected;
bool m_Linked;
bool m_HIDControlChannel_Connected;
bool m_HIDControlChannel_ConnectedWait;
bool m_HIDControlChannel_Config;
@@ -238,25 +229,15 @@ private:
bool m_HIDInterruptChannel_Config;
bool m_HIDInterruptChannel_ConfigWait;
// STATE_TO_SAVE
bdaddr_t m_BD;
u16 m_ControllerConnectionHandle;
uint8_t uclass[HCI_CLASS_SIZE];
u8 features[HCI_FEATURES_SIZE];
u8 lmp_version;
u16 lmp_subversion;
u8 m_LinkKey[16];
std::string m_Name;
CWII_IPC_HLE_Device_usb_oh1_57e_305* m_pHost;
struct SChannel
@@ -285,13 +266,11 @@ private:
void SendConfigurationRequest(u16 _SCID, u16* _pMTU = NULL, u16* _pFlushTimeOut = NULL);
void SendDisconnectRequest(u16 _SCID);
void CommandConnectionReq(u8 _Ident, u8* _pData, u32 _Size);
void CommandCofigurationReq(u8 _Ident, u8* _pData, u32 _Size);
void CommandConnectionResponse(u8 _Ident, u8* _pData, u32 _Size);
void CommandDisconnectionReq(u8 _Ident, u8* _pData, u32 _Size);
void CommandConfigurationResponse(u8 _Ident, u8* _pData, u32 _Size);
void ReceiveConnectionReq(u8 _Ident, u8* _pData, u32 _Size);
void ReceiveConnectionResponse(u8 _Ident, u8* _pData, u32 _Size);
void ReceiveDisconnectionReq(u8 _Ident, u8* _pData, u32 _Size);
void ReceiveConfigurationReq(u8 _Ident, u8* _pData, u32 _Size);
void ReceiveConfigurationResponse(u8 _Ident, u8* _pData, u32 _Size);
// some new ugly stuff
//
Source/Plugins/Plugin_Wiimote/Src/DataReports.cpp
+32 -32
View File
@@ -37,7 +37,7 @@
Callback_WiimoteInput()
CWII_IPC_HLE_WiiMote::SendL2capData()
WII_IPC_HLE_Device_usb.cpp:
CWII_IPC_HLE_Device_usb_oh1_57e_305::SendACLFrame()
CWII_IPC_HLE_Device_usb_oh1_57e_305::SendACLPacket()
at that point the message is queued and will be sent by the next
CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
*/
@@ -69,22 +69,20 @@ namespace WiiMoteEmu
// Update the data reporting mode
void WmDataReporting(u16 _channelID, wm_data_reporting* dr)
void WmReportMode(u16 _channelID, wm_report_mode* dr)
{
DEBUG_LOG(WIIMOTE, " Set Data reporting mode");
INFO_LOG(WIIMOTE, "Set data report mode");
DEBUG_LOG(WIIMOTE, " Rumble: %x", dr->rumble);
DEBUG_LOG(WIIMOTE, " Continuous: %x", dr->continuous);
DEBUG_LOG(WIIMOTE, " All The Time: %x (not only on data change)", dr->all_the_time);
DEBUG_LOG(WIIMOTE, " Mode: 0x%02x", dr->mode);
DEBUG_LOG(WIIMOTE, "Data reporting:");
DEBUG_LOG(WIIMOTE, " Continuous: %x", dr->continuous);
DEBUG_LOG(WIIMOTE, " All The Time: %x (not only on data change)", dr->all_the_time);
DEBUG_LOG(WIIMOTE, " Mode: 0x%02x", dr->mode);
DEBUG_LOG(WIIMOTE, " Channel: 0x%04x", _channelID);
g_ReportingAuto = dr->all_the_time;
g_ReportingMode = dr->mode;
g_ReportingChannel = _channelID;
switch(dr->mode) // See Wiimote_Update()
// Validation check
switch(dr->mode)
{
case WM_REPORT_CORE:
case WM_REPORT_CORE_ACCEL:
@@ -95,9 +93,6 @@ void WmDataReporting(u16 _channelID, wm_data_reporting* dr)
default:
PanicAlert("Wiimote: Unsupported reporting mode 0x%x", dr->mode);
}
// WmSendAck(_channelID, WM_DATA_REPORTING);
}
@@ -106,7 +101,7 @@ void WmDataReporting(u16 _channelID, wm_data_reporting* dr)
void SendReportCore(u16 _channelID)
{
u8 DataFrame[1024];
u32 Offset = WriteWmReport(DataFrame, WM_REPORT_CORE);
u32 Offset = WriteWmReportHdr(DataFrame, WM_REPORT_CORE);
wm_report_core* pReport = (wm_report_core*)(DataFrame + Offset);
Offset += sizeof(wm_report_core);
@@ -115,12 +110,14 @@ void SendReportCore(u16 _channelID)
FillReportInfo(pReport->c);
#endif
INFO_LOG(WIIMOTE, " SendReportCore()");
INFO_LOG(WIIMOTE, " SendReportCore(0x30)");
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
// Debugging
ReadDebugging(true, DataFrame, Offset);
//ReadDebugging(true, DataFrame, Offset);
}
@@ -128,7 +125,7 @@ void SendReportCore(u16 _channelID)
void SendReportCoreAccel(u16 _channelID)
{
u8 DataFrame[1024];
u32 Offset = WriteWmReport(DataFrame, WM_REPORT_CORE_ACCEL);
u32 Offset = WriteWmReportHdr(DataFrame, WM_REPORT_CORE_ACCEL);
wm_report_core_accel* pReport = (wm_report_core_accel*)(DataFrame + Offset);
Offset += sizeof(wm_report_core_accel);
@@ -140,20 +137,20 @@ void SendReportCoreAccel(u16 _channelID)
#endif
INFO_LOG(WIIMOTE, " SendReportCoreAccel (0x31)");
INFO_LOG(WIIMOTE, " Channel: %04x", _channelID);
INFO_LOG(WIIMOTE, " Offset: %08x", Offset);
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
// Debugging
ReadDebugging(true, DataFrame, Offset);
//ReadDebugging(true, DataFrame, Offset);
}
/* Case 0x33: Core Buttons and Accelerometer with 12 IR bytes */
void SendReportCoreAccelIr12(u16 _channelID) {
u8 DataFrame[1024];
u32 Offset = WriteWmReport(DataFrame, WM_REPORT_CORE_ACCEL_IR12);
u32 Offset = WriteWmReportHdr(DataFrame, WM_REPORT_CORE_ACCEL_IR12);
wm_report_core_accel_ir12* pReport = (wm_report_core_accel_ir12*)(DataFrame + Offset);
Offset += sizeof(wm_report_core_accel_ir12);
@@ -169,13 +166,14 @@ void SendReportCoreAccelIr12(u16 _channelID) {
memset(&pReport->ir[2], 0xff, sizeof(wm_ir_extended));
memset(&pReport->ir[3], 0xff, sizeof(wm_ir_extended));
INFO_LOG(WIIMOTE, " SendReportCoreAccelIr12()");
INFO_LOG(WIIMOTE, " Offset: %08x", Offset);
INFO_LOG(WIIMOTE, " SendReportCoreAccelIr12(0x33)");
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
// Debugging
ReadDebugging(true, DataFrame, Offset);
//ReadDebugging(true, DataFrame, Offset);
}
@@ -183,7 +181,7 @@ void SendReportCoreAccelIr12(u16 _channelID) {
void SendReportCoreAccelExt16(u16 _channelID)
{
u8 DataFrame[1024];
u32 Offset = WriteWmReport(DataFrame, WM_REPORT_CORE_ACCEL_EXT16);
u32 Offset = WriteWmReportHdr(DataFrame, WM_REPORT_CORE_ACCEL_EXT16);
wm_report_core_accel_ext16* pReport = (wm_report_core_accel_ext16*)(DataFrame + Offset);
Offset += sizeof(wm_report_core_accel_ext16);
@@ -209,18 +207,18 @@ void SendReportCoreAccelExt16(u16 _channelID)
#if defined(HAVE_WX) && HAVE_WX
FillReportClassicExtension(_ext);
#endif
//TODO // Copy _ext to pReport->ext
// Copy _ext to pReport->ext
memcpy(&pReport->ext, &_ext, sizeof(_ext));
}
INFO_LOG(WIIMOTE, " SendReportCoreAccelExt16 (0x35)");
INFO_LOG(WIIMOTE, " Channel: %04x", _channelID);
INFO_LOG(WIIMOTE, " Offset: %08x", Offset);
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
// Debugging
ReadDebugging(true, DataFrame, Offset);
//ReadDebugging(true, DataFrame, Offset);
}
@@ -228,7 +226,7 @@ void SendReportCoreAccelExt16(u16 _channelID)
void SendReportCoreAccelIr10Ext(u16 _channelID)
{
u8 DataFrame[1024];
u32 Offset = WriteWmReport(DataFrame, WM_REPORT_CORE_ACCEL_IR10_EXT6);
u32 Offset = WriteWmReportHdr(DataFrame, WM_REPORT_CORE_ACCEL_IR10_EXT6);
wm_report_core_accel_ir10_ext6* pReport = (wm_report_core_accel_ir10_ext6*)(DataFrame + Offset);
Offset += sizeof(wm_report_core_accel_ir10_ext6);
@@ -267,12 +265,14 @@ void SendReportCoreAccelIr10Ext(u16 _channelID)
memcpy(&pReport->ext, &_GH3_ext, sizeof(_GH3_ext));
}
INFO_LOG(WIIMOTE, " SendReportCoreAccelIr10Ext()");
INFO_LOG(WIIMOTE, " SendReportCoreAccelIr10Ext(0x37)");
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
// Debugging
ReadDebugging(true, DataFrame, Offset);
//ReadDebugging(true, DataFrame, Offset);
}
Source/Plugins/Plugin_Wiimote/Src/EmuDefinitions.cpp
+1
View File
@@ -48,6 +48,7 @@ u8 g_RegExt[WIIMOTE_REG_EXT_SIZE];
u8 g_RegExtTmp[WIIMOTE_REG_EXT_SIZE];
u8 g_RegIr[WIIMOTE_REG_IR_SIZE];
bool g_ReportingAuto; // Auto report or passive report
u8 g_ReportingMode; // The reporting mode and channel id
u16 g_ReportingChannel;
Source/Plugins/Plugin_Wiimote/Src/EmuDefinitions.h
+1
View File
@@ -80,6 +80,7 @@ extern u8 g_RegExt[WIIMOTE_REG_EXT_SIZE];
extern u8 g_RegExtTmp[WIIMOTE_REG_EXT_SIZE];
extern u8 g_RegIr[WIIMOTE_REG_IR_SIZE];
extern bool g_ReportingAuto;
extern u8 g_ReportingMode;
extern u16 g_ReportingChannel;
Source/Plugins/Plugin_Wiimote/Src/EmuMain.cpp
+58 -94
View File
@@ -373,6 +373,7 @@ void ExtensionChecksum(u8 * Calibration)
// Set initial valuesm this done both in Init and Shutdown
void ResetVariables()
{
g_ReportingAuto = false;
g_ReportingMode = 0;
g_ReportingChannel = 0;
g_Encryption = false;
@@ -465,11 +466,10 @@ void Initialize()
void DoState(PointerWrap &p)
{
return;
// TODO: Shorten the list
p.Do(g_Leds);
//p.Do(g_Speaker);
//p.Do(g_SpeakerVoice);
p.Do(g_Speaker);
p.Do(g_SpeakerVoice);
p.Do(g_IR);
p.DoArray(g_Eeprom, WIIMOTE_EEPROM_SIZE);
p.DoArray(g_RegSpeaker, WIIMOTE_REG_SPEAKER_SIZE);
@@ -477,23 +477,23 @@ void DoState(PointerWrap &p)
p.DoArray(g_RegExtTmp, WIIMOTE_REG_EXT_SIZE);
p.DoArray(g_RegIr, WIIMOTE_REG_IR_SIZE);
p.Do(g_ReportingAuto);
p.Do(g_ReportingMode);
p.Do(g_ReportingChannel);
p.Do(AckDelay);
p.Do(g_ExtKey);
p.Do(g_Encryption);
p.Do(NumPads);
p.Do(NumGoodPads);
p.Do(joyinfo);
p.DoArray(PadState, 4);
p.DoArray(PadMapping, 4);
//p.Do(NumPads);
//p.Do(NumGoodPads);
//p.Do(joyinfo);
//p.DoArray(PadState, 4);
//p.DoArray(PadMapping, 4);
p.Do(g_Wiimote_kbd);
p.Do(g_NunchuckExt);
p.Do(g_ClassicContExt);
//p.Do(g_Wiimote_kbd);
//p.Do(g_NunchuckExt);
//p.Do(g_ClassicContExt);
return;
}
/* This is not needed if we call FreeLibrary() when we stop a game, but if it's
@@ -528,62 +528,19 @@ void Shutdown(void)
if (SDL_WasInit(0)) SDL_Quit();
}
/* An ack delay of 1 was not small enough, but 2 seemed to work, that was about
between 20 ms and 100 ms in my case in Zelda - TP. You may have to increase
this value for other things to work, for example in the wpad demo I had to
set it to at least 3 for the Sound to be able to turned on (I have an update
rate of around 150 fps in the wpad demo) */
void CreateAckDelay(u8 _ChannelID, u16 _ReportID)
{
// Settings
int GlobalDelay = 2;
// Queue an acknowledgment
wm_ackdelay Tmp;
Tmp.Delay = GlobalDelay;
Tmp.ChannelID = _ChannelID;
Tmp.ReportID = (u8)_ReportID;
AckDelay.push_back(Tmp);
}
void CheckAckDelay()
{
for (int i = 0; i < (int)AckDelay.size(); i++)
{
// See if there are any acks to send
if (AckDelay.at(i).Delay >= 0)
{
if(AckDelay.at(i).Delay == 0)
{
WmSendAck(AckDelay.at(i).ChannelID, AckDelay.at(i).ReportID, 0);
AckDelay.erase(AckDelay.begin() + i);
continue;
}
AckDelay.at(i).Delay--;
//INFO_LOG(WIIMOTE, "%i 0x%04x 0x%02x", i, AckDelay.at(i).ChannelID, AckDelay.at(i).ReportID);
}
}
}
/* This function produce Wiimote Input, i.e. reports from the Wiimote in
response to Output from the Wii. */
void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
{
//INFO_LOG(WIIMOTE, "Emu InterruptChannel");
DEBUG_LOG(WIIMOTE, "Wiimote_Input");
const u8* data = (const u8*)_pData;
/* Debugging. We have not yet decided how much of 'data' we will use, it's
not determined by sizeof(data). We have to determine it by looking at
the data cases. */
InterruptDebugging(true, data);
//InterruptDebugging(true, (const void*)_pData);
hid_packet* hidp = (hid_packet*)_pData;
INFO_LOG(WIIMOTE, "Emu InterruptChannel (type: 0x%02x, param: 0x%02x)", hidp->type, hidp->param);
hid_packet* hidp = (hid_packet*) data;
switch(hidp->type)
{
case HID_TYPE_DATA:
@@ -612,11 +569,20 @@ void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
// that, also if we do *we should update the 0x22 to have
// the core keys* otherwise the game will think we release
// the key every time it rumbles
// AyuanX: Since I've rewritten the whole WII_IPC & WII_IPC_HLE & USB & BT
// finally we can get rid of this AckDelay issue, HAHA!
//
/*
const u8* data = (const u8*)_pData;
if(!(data[1] == WM_READ_DATA && data[2] == 0x00)
&& !(data[1] == WM_REQUEST_STATUS)
&& !(data[1] == WM_WRITE_SPEAKER_DATA)
&& !(data[1] == WM_RUMBLE))
if (!g_Config.bUseRealWiimote || !g_RealWiiMotePresent) CreateAckDelay((u8)_channelID, (u16)sr->channel);
if (!g_Config.bUseRealWiimote || !g_RealWiiMotePresent)
CreateAckDelay((u8)_channelID, (u16)sr->wm);
*/
}
break;
@@ -636,47 +602,36 @@ void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
void ControlChannel(u16 _channelID, const void* _pData, u32 _Size)
{
//INFO_LOG(WIIMOTE, "Emu ControlChannel");
hid_packet* hidp = (hid_packet*)_pData;
const u8* data = (const u8*)_pData;
// Dump raw data
{
INFO_LOG(WIIMOTE, "Wiimote_ControlChannel");
std::string Temp = ArrayToString(data, 0, _Size);
DEBUG_LOG(WIIMOTE, " Data: %s", Temp.c_str());
}
INFO_LOG(WIIMOTE, "Emu ControlChannel (type: 0x%02x, param: 0x%02x)", hidp->type, hidp->param);
hid_packet* hidp = (hid_packet*) data;
switch(hidp->type)
{
case HID_TYPE_HANDSHAKE:
if (hidp->param == HID_PARAM_INPUT)
{
PanicAlert("HID_TYPE_HANDSHAKE - HID_PARAM_INPUT");
}
else
{
PanicAlert("HID_TYPE_HANDSHAKE - HID_PARAM_OUTPUT");
}
PanicAlert("HID_TYPE_HANDSHAKE - %s", (hidp->param == HID_PARAM_INPUT) ? "INPUT" : "OUPUT");
break;
case HID_TYPE_SET_REPORT:
if (hidp->param == HID_PARAM_INPUT)
{
PanicAlert("HID_TYPE_SET_REPORT input");
PanicAlert("HID_TYPE_SET_REPORT - INPUT");
}
else
{
HidOutputReport(_channelID, (wm_report*)hidp->data);
// Return handshake
// AyuanX: My experiment shows Control Channel is never used
// In case it happens, we will send back a handshake which means report failed/rejected
// (TO_BE_VERIFIED)
//
u8 handshake = 0;
g_WiimoteInitialize.pWiimoteInput(_channelID, &handshake, 1);
PanicAlert("HID_TYPE_DATA - OUTPUT: Ambiguous Control Channel Report!");
}
break;
case HID_TYPE_DATA:
PanicAlert("HID_TYPE_DATA %s", hidp->type, hidp->param == HID_PARAM_INPUT ? "input" : "output");
PanicAlert("HID_TYPE_DATA - %s", (hidp->param == HID_PARAM_INPUT) ? "INPUT" : "OUTPUT");
break;
default:
@@ -693,9 +648,10 @@ void ControlChannel(u16 _channelID, const void* _pData, u32 _Size)
of times per second. */
void Update()
{
if(g_ReportingAuto == false)
return;
readKeyboard();
//LOG(WIIMOTE, "Wiimote_Update");
//INFO_LOG(WIIMOTE, "Emu Update: %i", g_ReportingMode);
// Check if the pad state should be updated
if ((g_Config.Trigger.Type == g_Config.Trigger.TRIGGER || g_Config.Trigger.Type == g_Config.Trigger.ANALOG1 || g_Config.Trigger.Type == g_Config.Trigger.ANALOG2
@@ -712,17 +668,25 @@ void Update()
{
case 0:
break;
case WM_REPORT_CORE: SendReportCore(g_ReportingChannel); break;
case WM_REPORT_CORE_ACCEL: SendReportCoreAccel(g_ReportingChannel); break;
case WM_REPORT_CORE_ACCEL_IR12: SendReportCoreAccelIr12(g_ReportingChannel); break;
case WM_REPORT_CORE_ACCEL_EXT16: SendReportCoreAccelExt16(g_ReportingChannel); break;
case WM_REPORT_CORE_ACCEL_IR10_EXT6: SendReportCoreAccelIr10Ext(g_ReportingChannel);break;
case WM_REPORT_CORE:
SendReportCore(g_ReportingChannel);
break;
case WM_REPORT_CORE_ACCEL:
SendReportCoreAccel(g_ReportingChannel);
break;
case WM_REPORT_CORE_ACCEL_IR12:
SendReportCoreAccelIr12(g_ReportingChannel);
break;
case WM_REPORT_CORE_ACCEL_EXT16:
SendReportCoreAccelExt16(g_ReportingChannel);
break;
case WM_REPORT_CORE_ACCEL_IR10_EXT6:
SendReportCoreAccelIr10Ext(g_ReportingChannel);
break;
}
// Potentially send a delayed acknowledgement to an InterruptChannel() Output
CheckAckDelay();
}
void readKeyboard()
{
#if defined(HAVE_X11) && HAVE_X11
Source/Plugins/Plugin_Wiimote/Src/EmuSubroutines.cpp
+141 -205
View File
File diff suppressed because it is too large Load Diff
Source/Plugins/Plugin_Wiimote/Src/EmuSubroutines.h
+4 -4
View File
@@ -42,17 +42,17 @@ void WmReadData(u16 _channelID, wm_read_data* rd);
void WmWriteData(u16 _channelID, wm_write_data* wd);
void WmRequestStatus(u16 _channelID, wm_request_status* rs, int Extension = -1);
void WmRequestStatus_(u16 _channelID, int a);
void WmDataReporting(u16 _channelID, wm_data_reporting* dr);
void WmReportMode(u16 _channelID, wm_report_mode* dr);
void SendReadDataReply(u16 _channelID, void* _Base, u16 _Address, u8 _Size);
void SendReportCoreAccel(u16 _channelID);
void SendReportCoreAccelIr12(u16 _channelID);
void SendReportCore(u16 _channelID);
void SendReportCoreAccelExt16(u16 _channelID);
void SendReportCoreAccelIr10Ext(u16 _channelID);
int WriteWmReport(u8* dst, u8 channel);
void WmSendAck(u16 _channelID, u8 _reportID, u32 address);
int WriteWmReportHdr(u8* dst, u8 wm);
void WmSendAck(u16 _channelID, u8 _reportID);
void SendReadDataReply(u16 _channelID, void* _Base, u16 _Address, int _Size);
void FillReportAcc(wm_accel& _acc);
void FillReportInfo(wm_core& _core);
Source/Plugins/Plugin_Wiimote/Src/FillReport.cpp
+2 -6
View File
@@ -343,10 +343,6 @@ int IsKey(int Key)
// Wiimote core buttons
void FillReportInfo(wm_core& _core)
{
/* This has to be filled with zeroes (and not for example 0xff) because when no buttons are pressed the
value is 00 00 */
memset(&_core, 0x00, sizeof(wm_core));
// Check that Dolphin is in focus
if (!IsFocus()) return;
@@ -436,7 +432,7 @@ void SingleShake(u8 &_y, u8 &_z, int i)
/* Tilting Wiimote with gamepad. We can guess that the game will calculate a
Wiimote pitch and use it as a measure of the tilting of the Wiimote. We are
interested in this tilting range 90° to -90° */
interested in this tilting range 90?to -90?*/
void TiltWiimoteGamepad(float &Roll, float &Pitch)
{
// Return if we have no pads
@@ -460,7 +456,7 @@ void TiltWiimoteGamepad(float &Roll, float &Pitch)
float Tl = (float)_Tl;
float Tr = (float)_Tr;
// Save the Range in degrees, 45° and 90° are good values in some games
// Save the Range in degrees, 45?and 90?are good values in some games
float RollRange = (float)g_Config.Trigger.Range.Roll;
float PitchRange = (float)g_Config.Trigger.Range.Pitch;
Source/Plugins/Plugin_Wiimote/Src/main.cpp
+15 -15
View File
@@ -269,10 +269,9 @@ void Shutdown(void)
void DoState(unsigned char **ptr, int mode)
{
PointerWrap p(ptr, mode);
return;
// TODO: Shorten the list
//p.Do(g_EmulatorRunning);
//p.Do(g_ISOId);
p.Do(g_FrameOpen);
@@ -280,16 +279,18 @@ void DoState(unsigned char **ptr, int mode)
p.Do(g_RealWiiMoteInitialized);
p.Do(g_EmulatedWiiMoteInitialized);
p.Do(g_WiimoteUnexpectedDisconnect);
p.Do(g_UpdateCounter);
p.Do(g_UpdateTime);
p.Do(g_UpdateRate);
p.Do(g_UpdateWriteScreen);
p.Do(g_UpdateTimeList);
//p.Do(g_UpdateCounter);
//p.Do(g_UpdateTime);
//p.Do(g_UpdateRate);
//p.Do(g_UpdateWriteScreen);
//p.Do(g_UpdateTimeList);
#if HAVE_WIIUSE
WiiMoteReal::DoState(p);
#endif
WiiMoteEmu::DoState(p);
return;
}
@@ -305,7 +306,7 @@ void Wiimote_InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
// Debugging
{
DEBUG_LOG(WIIMOTE, "Wiimote_Input");
DEBUG_LOG(WIIMOTE, "Wiimote_InterruptChannel");
DEBUG_LOG(WIIMOTE, " Channel ID: %04x", _channelID);
std::string Temp = ArrayToString(data, _Size);
DEBUG_LOG(WIIMOTE, " Data: %s", Temp.c_str());
@@ -333,6 +334,7 @@ void Wiimote_ControlChannel(u16 _channelID, const void* _pData, u32 _Size)
DEBUG_LOG(WIIMOTE, "Wiimote Disconnected");
g_EmulatorRunning = false;
g_WiimoteUnexpectedDisconnect = true;
#if defined(HAVE_WX) && HAVE_WX
if (m_BasicConfigFrame) m_BasicConfigFrame->UpdateGUI();
#endif
@@ -344,7 +346,6 @@ void Wiimote_ControlChannel(u16 _channelID, const void* _pData, u32 _Size)
DEBUG_LOG(WIIMOTE, "Wiimote_ControlChannel");
std::string Temp = ArrayToString(data, _Size);
DEBUG_LOG(WIIMOTE, " Data: %s", Temp.c_str());
//PanicAlert("Wiimote_ControlChannel");
}
//if (!g_RealWiiMotePresent)
@@ -372,8 +373,8 @@ void Wiimote_Update()
}
g_UpdateWriteScreen++;
}
#endif
// This functions will send:
// Emulated Wiimote: Only data reports 0x30-0x37
// Real Wiimote: Both data reports 0x30-0x37 and all other read reports
@@ -638,7 +639,7 @@ void ReadDebugging(bool Emu, const void* _pData, int Size)
}
break;
case WM_WRITE_DATA_REPLY: // 0x22
case WM_ACK_DATA: // 0x22
size = sizeof(wm_acknowledge) - 1;
Name = "REPLY";
break;
@@ -820,7 +821,6 @@ void ReadDebugging(bool Emu, const void* _pData, int Size)
void InterruptDebugging(bool Emu, const void* _pData)
{
//
const u8* data = (const u8*)_pData;
std::string Name;
@@ -840,9 +840,9 @@ void InterruptDebugging(bool Emu, const void* _pData)
size = sizeof(wm_leds);
if (g_DebugComm) Name.append("WM_LEDS");
break;
case WM_DATA_REPORTING: // 0x12
size = sizeof(wm_data_reporting);
if (g_DebugComm) Name.append("WM_DATA_REPORTING");
case WM_REPORT_MODE: // 0x12
size = sizeof(wm_report_mode);
if (g_DebugComm) Name.append("WM_REPORT_MODE");
break;
case WM_REQUEST_STATUS: // 0x15
size = sizeof(wm_request_status);
Source/Plugins/Plugin_Wiimote/Src/wiimote_hid.h
+5 -7
View File
@@ -45,7 +45,7 @@ struct hid_packet {
//source: http://wiibrew.org/wiki/Wiimote
struct wm_report {
u8 channel;
u8 wm;
u8 data[0];
};
@@ -57,8 +57,8 @@ struct wm_leds {
u8 leds : 4;
};
#define WM_DATA_REPORTING 0x12
struct wm_data_reporting {
#define WM_REPORT_MODE 0x12
struct wm_report_mode {
u8 rumble : 1;
u8 continuous : 1;
u8 all_the_time : 1;
@@ -98,12 +98,10 @@ struct wm_write_data
u8 data[16];
};
#define WM_WRITE_DATA_REPLY 0x22 //empty, afaik
#define WM_ACK_DATA 0x22
struct wm_acknowledge
{
u8 Channel;
u8 unk0; // Core buttons state (wm_core), can be zero
u8 unk1;
u16 buttons;
u8 reportID;
u8 errorID;
};