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

Wiimote: More work, don't ask, no answer 

nJoy: Maybe this could reactivate multi-pad?

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4729 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
ayuanx 2009-12-25 22:10:56 +00:00
parent 06218e9ebb
commit 4240cf9053
26 changed files with 336 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/Core/AudioCommon/Src/Mixer.h
View File

@ -41,7 +41,7 @@ public:
// I perfer speed so let's do down-sampling instead of up-sampling // I perfer speed so let's do down-sampling instead of up-sampling
// If you like better sound than speed, feel free to implement the up-sampling code // If you like better sound than speed, feel free to implement the up-sampling code
m_sampleRate = 32000; m_sampleRate = 32000;
NOTICE_LOG(AUDIO_INTERFACE, "Mixer is initialized (AISampleRate:%i, DACSampleRate:%i)", AISampleRate, DACSampleRate); INFO_LOG(AUDIO_INTERFACE, "Mixer is initialized (AISampleRate:%i, DACSampleRate:%i)", AISampleRate, DACSampleRate);
} }
// Called from audio threads // Called from audio threads

6
Source/Core/Common/Src/PluginWiimote.h
View File

@ -24,9 +24,9 @@
namespace Common { namespace Common {
typedef unsigned int (__cdecl* TPAD_GetAttachedPads)(); typedef unsigned int (__cdecl* TPAD_GetAttachedPads)();
typedef void (__cdecl* TWiimote_Update)(); typedef void (__cdecl* TWiimote_Update)(int _number);
typedef void (__cdecl* TWiimote_Output)(u16 _channelID, const void* _pData, u32 _Size); typedef void (__cdecl* TWiimote_Output)(int _number, u16 _channelID, const void* _pData, u32 _Size);
typedef void (__cdecl* TWiimote_Input)(u16 _channelID, const void* _pData, u32 _Size); typedef void (__cdecl* TWiimote_Input)(int _number, u16 _channelID, const void* _pData, u32 _Size);
typedef unsigned int (__cdecl* TWiimote_GetAttachedControllers)(); typedef unsigned int (__cdecl* TWiimote_GetAttachedControllers)();
class PluginWiimote : public CPlugin { class PluginWiimote : public CPlugin {

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

@ -79,7 +79,7 @@ const char *Callback_ISOName(void);
void Callback_DSPInterrupt(); void Callback_DSPInterrupt();
void Callback_PADLog(const TCHAR* _szMessage); void Callback_PADLog(const TCHAR* _szMessage);
void Callback_WiimoteLog(const TCHAR* _szMessage, int _v); void Callback_WiimoteLog(const TCHAR* _szMessage, int _v);
void Callback_WiimoteInput(u16 _channelID, const void* _pData, u32 _Size); void Callback_WiimoteInput(int _number, u16 _channelID, const void* _pData, u32 _Size);
// For keyboard shortcuts. // For keyboard shortcuts.
void Callback_KeyPress(int key, bool shift, bool control); void Callback_KeyPress(int key, bool shift, bool control);

4
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_stm.h
View File

@ -54,7 +54,7 @@ public:
virtual bool Open(u32 _CommandAddress, u32 _Mode) virtual bool Open(u32 _CommandAddress, u32 _Mode)
{ {
ERROR_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 true;
@ -62,7 +62,7 @@ public:
virtual bool Close(u32 _CommandAddress, bool _bForce) virtual bool Close(u32 _CommandAddress, bool _bForce)
{ {
ERROR_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;

186
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_usb.cpp
View File

@ -42,12 +42,11 @@ CWII_IPC_HLE_Device_usb_oh1_57e_305::CWII_IPC_HLE_Device_usb_oh1_57e_305(u32 _De
, m_ACLBuffer(NULL) , m_ACLBuffer(NULL)
, m_ACLPool(0) , m_ACLPool(0)
, m_LastCmd(0) , m_LastCmd(0)
, m_PacketCount(0)
, m_FreqDividerSync(0) , m_FreqDividerSync(0)
, m_FreqDividerMote(0)
{ {
// Connect one Wiimote by default // Activate the first one Wiimote by default
m_WiiMotes.push_back(CWII_IPC_HLE_WiiMote(this, 0)); m_WiiMotes.push_back(CWII_IPC_HLE_WiiMote(this, 0, true));
// m_WiiMotes.push_back(CWII_IPC_HLE_WiiMote(this, 1));
// The BCM2045's btaddr: // The BCM2045's btaddr:
m_ControllerBD.b[0] = 0x11; m_ControllerBD.b[0] = 0x11;
@ -63,6 +62,8 @@ CWII_IPC_HLE_Device_usb_oh1_57e_305::CWII_IPC_HLE_Device_usb_oh1_57e_305(u32 _De
m_ClassOfDevice[2] = 0x00; m_ClassOfDevice[2] = 0x00;
memset(m_LocalName, 0, HCI_UNIT_NAME_SIZE); memset(m_LocalName, 0, HCI_UNIT_NAME_SIZE);
memset(m_PacketCount, 0, sizeof(m_PacketCount));
memset(m_FreqDividerMote, 0, sizeof(m_FreqDividerMote));
Host_SetWiiMoteConnectionState(0); Host_SetWiiMoteConnectionState(0);
} }
@ -75,14 +76,18 @@ CWII_IPC_HLE_Device_usb_oh1_57e_305::~CWII_IPC_HLE_Device_usb_oh1_57e_305()
void CWII_IPC_HLE_Device_usb_oh1_57e_305::DoState(PointerWrap &p) void CWII_IPC_HLE_Device_usb_oh1_57e_305::DoState(PointerWrap &p)
{ {
p.Do(m_LastCmd); p.Do(m_LastCmd);
p.Do(m_PacketCount);
p.Do(m_CtrlSetup); p.Do(m_CtrlSetup);
p.Do(m_HCIBuffer); p.Do(m_HCIBuffer);
p.Do(m_HCIPool); p.Do(m_HCIPool);
p.Do(m_ACLBuffer); p.Do(m_ACLBuffer);
p.Do(m_ACLPool); p.Do(m_ACLPool);
p.Do(m_FreqDividerSync); p.Do(m_FreqDividerSync);
p.Do(m_FreqDividerMote);
for (int i = 0; i < 4; i++)
{
p.Do(m_PacketCount[i]);
p.Do(m_FreqDividerMote[i]);
}
} }
// =================================================== // ===================================================
@ -108,9 +113,9 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::Close(u32 _CommandAddress, bool _bForc
m_HostNumSCOPackets = 0; m_HostNumSCOPackets = 0;
m_LastCmd = 0; m_LastCmd = 0;
m_PacketCount = 0;
m_FreqDividerSync = 0; m_FreqDividerSync = 0;
m_FreqDividerMote = 0; memset(m_FreqDividerMote, 0, sizeof(m_FreqDividerMote));
memset(m_PacketCount, 0, sizeof(m_PacketCount));
m_HCIBuffer.m_address = NULL; m_HCIBuffer.m_address = NULL;
m_HCIPool.m_number = 0; m_HCIPool.m_number = 0;
@ -208,7 +213,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::IOCtlV(u32 _CommandAddress)
_dbg_assert_(WII_IPC_WIIMOTE, pACLHeader->PBFlag == 2); _dbg_assert_(WII_IPC_WIIMOTE, pACLHeader->PBFlag == 2);
SendToDevice(pACLHeader->ConnectionHandle, Memory::GetPointer(BulkBuffer.m_buffer + 4), pACLHeader->Size); SendToDevice(pACLHeader->ConnectionHandle, Memory::GetPointer(BulkBuffer.m_buffer + 4), pACLHeader->Size);
m_PacketCount++; m_PacketCount[pACLHeader->ConnectionHandle & 0x1]++;
// If ACLPool is not used, we can send a reply immediately // If ACLPool is not used, we can send a reply immediately
// or else we have to delay this reply // or else we have to delay this reply
@ -297,6 +302,8 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendToDevice(u16 _ConnectionHandle, u8
if (pWiiMote == NULL) if (pWiiMote == NULL)
return; return;
INFO_LOG(WII_IPC_WIIMOTE, "++++++++++++++++++++++++++++++++++++++");
INFO_LOG(WII_IPC_WIIMOTE, "Execute ACL Command: ConnectionHandle 0x%04x", _ConnectionHandle);
pWiiMote->ExecuteL2capCmd(_pData, _Size); pWiiMote->ExecuteL2capCmd(_pData, _Size);
} }
@ -316,7 +323,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendACLPacket(u16 _ConnectionHandle, u
{ {
if(m_ACLBuffer.m_address != NULL) if(m_ACLBuffer.m_address != NULL)
{ {
INFO_LOG(WII_IPC_WIIMOTE, "Sending ACL Packet: 0x%08x ....", m_ACLBuffer.m_address); INFO_LOG(WII_IPC_WIIMOTE, "Sending ACL Packet: 0x%08x .... (ConnectionHandle 0x%04x)", m_ACLBuffer.m_address, _ConnectionHandle);
UACLHeader* pHeader = (UACLHeader*)Memory::GetPointer(m_ACLBuffer.m_buffer); UACLHeader* pHeader = (UACLHeader*)Memory::GetPointer(m_ACLBuffer.m_buffer);
pHeader->ConnectionHandle = _ConnectionHandle; pHeader->ConnectionHandle = _ConnectionHandle;
@ -337,10 +344,10 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendACLPacket(u16 _ConnectionHandle, u
m_ACLBuffer.m_address = NULL; m_ACLBuffer.m_address = NULL;
m_ACLBuffer.m_buffer = NULL; m_ACLBuffer.m_buffer = NULL;
} }
else if ((sizeof(UACLHeader) + _Size) > 64 ) else if ((sizeof(UACLHeader) + _Size) > ACL_MAX_SIZE )
{ {
ERROR_LOG(WII_IPC_HLE, "ACL Packet size is too big! (>64B)"); ERROR_LOG(WII_IPC_HLE, "ACL Packet size is too big!");
PanicAlert("WII_IPC_HLE: ACL Packet size is too big! (>64B)"); PanicAlert("WII_IPC_HLE: ACL Packet size is too big!");
} }
else if (m_ACLPool.m_number >= 16) else if (m_ACLPool.m_number >= 16)
{ {
@ -349,7 +356,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendACLPacket(u16 _ConnectionHandle, u
} }
else else
{ {
UACLHeader* pHeader = (UACLHeader*)(m_ACLPool.m_data + m_ACLPool.m_number * 64); // I believe 64B is enough UACLHeader* pHeader = (UACLHeader*)(m_ACLPool.m_data + m_ACLPool.m_number * ACL_MAX_SIZE);
pHeader->ConnectionHandle = _ConnectionHandle; pHeader->ConnectionHandle = _ConnectionHandle;
pHeader->BCFlag = 0; pHeader->BCFlag = 0;
pHeader->PBFlag = 2; pHeader->PBFlag = 2;
@ -378,8 +385,8 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::PurgeACLPool()
{ {
m_ACLPool.m_number--; m_ACLPool.m_number--;
// Fill the buffer // Fill the buffer
u8* _Address = m_ACLPool.m_data + m_ACLPool.m_number * 64; u8* _Address = m_ACLPool.m_data + m_ACLPool.m_number * ACL_MAX_SIZE;
memcpy(Memory::GetPointer(m_ACLBuffer.m_buffer), _Address, 64); memcpy(Memory::GetPointer(m_ACLBuffer.m_buffer), _Address, ACL_MAX_SIZE);
// Write the packet size as return value // Write the packet size as return value
Memory::Write_U32(sizeof(UACLHeader) + ((UACLHeader*)_Address)->Size, m_ACLBuffer.m_address + 0x4); Memory::Write_U32(sizeof(UACLHeader) + ((UACLHeader*)_Address)->Size, m_ACLBuffer.m_address + 0x4);
// Send a reply to indicate ACL buffer is sent // Send a reply to indicate ACL buffer is sent
@ -395,7 +402,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::PurgeACLPool()
// ---------------- // ----------------
u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update() u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
{ {
// Check if HCI Pool is not purged // Check if HCI Pool is not purged
if (m_HCIPool.m_number > 0) if (m_HCIPool.m_number > 0)
{ {
@ -440,8 +446,9 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
{ {
counter--; counter--;
if (counter < 0) if (counter < 0)
for (size_t i=0; i < m_WiiMotes.size(); i++) {
if (m_WiiMotes[i].EventPagingChanged(2)) for (unsigned int i = 0; i < m_WiiMotes.size(); i++)
if (m_WiiMotes[i].EventPagingChanged(m_ScanEnable))
{ {
Host_SetWiiMoteConnectionState(1); Host_SetWiiMoteConnectionState(1);
// Create ACL connection // Create ACL connection
@ -449,6 +456,7 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
return true; return true;
} }
} }
}
// AyuanX: Actually we don't need to link channels so early // AyuanX: Actually we don't need to link channels so early
// We can wait until HCI command: CommandReadRemoteFeatures is finished // We can wait until HCI command: CommandReadRemoteFeatures is finished
@ -457,7 +465,7 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
// But ... whatever, either way works // But ... whatever, either way works
// //
// Link channels when connected // Link channels when connected
if (m_ACLBuffer.m_address) if (m_ACLBuffer.m_address && !m_LastCmd && !WII_IPCInterface::GetAddress())
{ {
for (size_t i = 0; i < m_WiiMotes.size(); i++) for (size_t i = 0; i < m_WiiMotes.size(); i++)
{ {
@ -469,16 +477,19 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
// The Real Wiimote sends report at a fixed frequency of 100Hz // The Real Wiimote sends report at a fixed frequency of 100Hz
// So let's make it also 100Hz here // So let's make it also 100Hz here
// Calculation: 15000Hz (IPC_HLE) / 100Hz (WiiMote) = 150 // Calculation: 15000Hz (IPC_HLE) / 100Hz (WiiMote) = 150
if (m_ACLBuffer.m_address && !m_LastCmd && m_WiiMotes[0].IsLinked()) if (m_ACLBuffer.m_address && !m_LastCmd)
{ {
m_FreqDividerMote++; for (unsigned int i = 0; i < m_WiiMotes.size(); i++)
if(m_FreqDividerMote >= 150)
{ {
m_FreqDividerMote = 0; m_FreqDividerMote[i]++;
CPluginManager::GetInstance().GetWiimote(0)->Wiimote_Update(); if (m_WiiMotes[i].IsLinked() && m_FreqDividerMote[i] >= 150)
{
m_FreqDividerMote[i] = 0;
CPluginManager::GetInstance().GetWiimote(0)->Wiimote_Update(i);
return true; return true;
} }
} }
}
// This event should be sent periodically after ACL connection is accepted // This event should be sent periodically after ACL connection is accepted
// or CPU will disconnect WiiMote automatically // or CPU will disconnect WiiMote automatically
@ -487,11 +498,11 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
if (m_HCIBuffer.m_address && !WII_IPCInterface::GetAddress() && m_WiiMotes[0].IsConnected()) if (m_HCIBuffer.m_address && !WII_IPCInterface::GetAddress() && m_WiiMotes[0].IsConnected())
{ {
m_FreqDividerSync++; m_FreqDividerSync++;
if ((m_PacketCount > 0) || (m_FreqDividerSync >= 100)) // Feel free to tweak it if (m_FreqDividerSync >= 500) // Feel free to tweak it
{ {
m_FreqDividerSync = 0; m_FreqDividerSync = 0;
SendEventNumberOfCompletedPackets(m_WiiMotes[0].GetConnectionHandle(), m_PacketCount); SendEventNumberOfCompletedPackets();
m_PacketCount = 0; memset(m_PacketCount, 0, sizeof(m_PacketCount));
return true; return true;
} }
} }
@ -528,10 +539,10 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::AddEventToQueue(const SQueuedEvent& _e
m_HCIBuffer.m_address = NULL; m_HCIBuffer.m_address = NULL;
m_HCIBuffer.m_buffer = NULL; m_HCIBuffer.m_buffer = NULL;
} }
else if (_event.m_size > 64) else if (_event.m_size > HCI_MAX_SIZE)
{ {
ERROR_LOG(WII_IPC_HLE, "HCI Packet size too big! (>64B)"); ERROR_LOG(WII_IPC_HLE, "HCI Packet size too big!");
PanicAlert("WII_IPC_HLE: HCI Packet size too big! (>64B)"); PanicAlert("WII_IPC_HLE: HCI Packet size too big!");
} }
else if (m_HCIPool.m_number >= 16) else if (m_HCIPool.m_number >= 16)
{ {
@ -540,7 +551,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::AddEventToQueue(const SQueuedEvent& _e
} }
else else
{ {
memcpy(m_HCIPool.m_data + m_HCIPool.m_number * 64, _event.m_buffer, _event.m_size); memcpy(m_HCIPool.m_data + m_HCIPool.m_number * HCI_MAX_SIZE, _event.m_buffer, _event.m_size);
// HCI Packet doesn't contain size info inside, so we have to store it somewhere // HCI Packet doesn't contain size info inside, so we have to store it somewhere
m_HCIPool.m_size[m_HCIPool.m_number] = _event.m_size; m_HCIPool.m_size[m_HCIPool.m_number] = _event.m_size;
m_HCIPool.m_number++; m_HCIPool.m_number++;
@ -636,7 +647,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventInquiryResponse()
return true; return true;
} }
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventConnectionComplete(bdaddr_t _bd) bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventConnectionComplete(const bdaddr_t& _bd)
{ {
CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_bd); CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_bd);
if (pWiiMote == NULL) if (pWiiMote == NULL)
@ -650,16 +661,12 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventConnectionComplete(bdaddr_t _
pConnectionComplete->PayloadLength = sizeof(SHCIEventConnectionComplete) - 2; pConnectionComplete->PayloadLength = sizeof(SHCIEventConnectionComplete) - 2;
pConnectionComplete->Status = 0x00; pConnectionComplete->Status = 0x00;
pConnectionComplete->Connection_Handle = pWiiMote->GetConnectionHandle(); pConnectionComplete->Connection_Handle = pWiiMote->GetConnectionHandle();
pConnectionComplete->bdaddr = pWiiMote->GetBD(); pConnectionComplete->bdaddr = _bd;
pConnectionComplete->LinkType = HCI_LINK_ACL; pConnectionComplete->LinkType = HCI_LINK_ACL;
pConnectionComplete->EncryptionEnabled = HCI_ENCRYPTION_MODE_NONE; pConnectionComplete->EncryptionEnabled = HCI_ENCRYPTION_MODE_NONE;
AddEventToQueue(Event); AddEventToQueue(Event);
CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(_bd);
if (pWiimote)
pWiimote->EventConnectionAccepted();
#if MAX_LOGLEVEL >= DEBUG_LEVEL #if MAX_LOGLEVEL >= DEBUG_LEVEL
static char s_szLinkType[][128] = static char s_szLinkType[][128] =
{ {
@ -683,9 +690,6 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventConnectionComplete(bdaddr_t _
/* This is called from Update() after ScanEnable has been enabled. */ /* This is called from Update() after ScanEnable has been enabled. */
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection(CWII_IPC_HLE_WiiMote& _rWiiMote) bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection(CWII_IPC_HLE_WiiMote& _rWiiMote)
{ {
// We have to disable scan now to avoid running this function over and over again
m_ScanEnable = 0;
SQueuedEvent Event(sizeof(SHCIEventRequestConnection), 0); SQueuedEvent Event(sizeof(SHCIEventRequestConnection), 0);
SHCIEventRequestConnection* pEventRequestConnection = (SHCIEventRequestConnection*)Event.m_buffer; SHCIEventRequestConnection* pEventRequestConnection = (SHCIEventRequestConnection*)Event.m_buffer;
@ -698,8 +702,6 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection(CWII_IPC_HL
pEventRequestConnection->uclass[2] = _rWiiMote.GetClass()[2]; pEventRequestConnection->uclass[2] = _rWiiMote.GetClass()[2];
pEventRequestConnection->LinkType = HCI_LINK_ACL; pEventRequestConnection->LinkType = HCI_LINK_ACL;
AddEventToQueue(Event);
// Log // Log
#if MAX_LOGLEVEL >= DEBUG_LEVEL #if MAX_LOGLEVEL >= DEBUG_LEVEL
static char LinkType[][128] = static char LinkType[][128] =
@ -720,6 +722,8 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection(CWII_IPC_HL
DEBUG_LOG(WII_IPC_WIIMOTE, " COD[2]: 0x%02x", pEventRequestConnection->uclass[2]); DEBUG_LOG(WII_IPC_WIIMOTE, " COD[2]: 0x%02x", pEventRequestConnection->uclass[2]);
//DEBUG_LOG(WII_IPC_WIIMOTE, " LinkType: %s", LinkType[pEventRequestConnection->LinkType]); //DEBUG_LOG(WII_IPC_WIIMOTE, " LinkType: %s", LinkType[pEventRequestConnection->LinkType]);
AddEventToQueue(Event);
return true; return true;
} }
@ -771,7 +775,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventAuthenticationCompleted(u16 _
return true; return true;
} }
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRemoteNameReq(bdaddr_t _bd) bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRemoteNameReq(const bdaddr_t& _bd)
{ {
CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_bd); CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_bd);
if (pWiiMote == NULL) if (pWiiMote == NULL)
@ -784,7 +788,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRemoteNameReq(bdaddr_t _bd)
pRemoteNameReq->EventType = HCI_EVENT_REMOTE_NAME_REQ_COMPL; pRemoteNameReq->EventType = HCI_EVENT_REMOTE_NAME_REQ_COMPL;
pRemoteNameReq->PayloadLength = sizeof(SHCIEventRemoteNameReq) - 2; pRemoteNameReq->PayloadLength = sizeof(SHCIEventRemoteNameReq) - 2;
pRemoteNameReq->Status = 0x00; pRemoteNameReq->Status = 0x00;
pRemoteNameReq->bdaddr = pWiiMote->GetBD(); pRemoteNameReq->bdaddr = _bd;
strcpy((char*)pRemoteNameReq->RemoteName, pWiiMote->GetName()); strcpy((char*)pRemoteNameReq->RemoteName, pWiiMote->GetName());
AddEventToQueue(Event); AddEventToQueue(Event);
@ -807,10 +811,8 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventReadRemoteFeatures(u16 _conne
SQueuedEvent Event(sizeof(SHCIEventReadRemoteFeatures), _connectionHandle); SQueuedEvent Event(sizeof(SHCIEventReadRemoteFeatures), _connectionHandle);
SHCIEventReadRemoteFeatures* pReadRemoteFeatures = (SHCIEventReadRemoteFeatures*)Event.m_buffer; SHCIEventReadRemoteFeatures* pReadRemoteFeatures = (SHCIEventReadRemoteFeatures*)Event.m_buffer;
// WTF CAN'T WE USE THE CORRECT VALUE HERE?!
// If you set EventType to HCI_EVENT_READ_REMOTE_FEATURES_COMPL, nintendo's BT stack will take a different path pReadRemoteFeatures->EventType = HCI_EVENT_READ_REMOTE_FEATURES_COMPL;
// try it and see :)
pReadRemoteFeatures->EventType = 0x0c; //HCI_EVENT_READ_REMOTE_FEATURES_COMPL;
pReadRemoteFeatures->PayloadLength = sizeof(SHCIEventReadRemoteFeatures) - 2; pReadRemoteFeatures->PayloadLength = sizeof(SHCIEventReadRemoteFeatures) - 2;
pReadRemoteFeatures->Status = 0x00; pReadRemoteFeatures->Status = 0x00;
pReadRemoteFeatures->ConnectionHandle = pWiiMote->GetConnectionHandle(); pReadRemoteFeatures->ConnectionHandle = pWiiMote->GetConnectionHandle();
@ -955,25 +957,29 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRoleChange(bdaddr_t _bd, bool
return true; return true;
} }
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventNumberOfCompletedPackets(u16 _connectionHandle, u16 _count) bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventNumberOfCompletedPackets()
{ {
CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_connectionHandle); int Num = m_WiiMotes.size();
if (pWiiMote == NULL) if (Num == NULL)
return false; return false;
SQueuedEvent Event(sizeof(SHCIEventNumberOfCompletedPackets), 0); // zero, so this packet isn't counted SQueuedEvent Event(sizeof(SHCIEventNumberOfCompletedPackets) + Num * 4, 0);
SHCIEventNumberOfCompletedPackets* pNumberOfCompletedPackets = (SHCIEventNumberOfCompletedPackets*)Event.m_buffer; SHCIEventNumberOfCompletedPackets* pNumberOfCompletedPackets = (SHCIEventNumberOfCompletedPackets*)Event.m_buffer;
pNumberOfCompletedPackets->EventType = HCI_EVENT_NUM_COMPL_PKTS; pNumberOfCompletedPackets->EventType = HCI_EVENT_NUM_COMPL_PKTS;
pNumberOfCompletedPackets->PayloadLength = sizeof(SHCIEventNumberOfCompletedPackets) - 2; pNumberOfCompletedPackets->PayloadLength = sizeof(SHCIEventNumberOfCompletedPackets) + Num * 4 - 2;
pNumberOfCompletedPackets->NumberOfHandles = 1; pNumberOfCompletedPackets->NumberOfHandles = Num;
pNumberOfCompletedPackets->Connection_Handle = _connectionHandle;
pNumberOfCompletedPackets->Number_Of_Completed_Packets = _count; u16 *pData = (u16 *)(Event.m_buffer + sizeof(SHCIEventNumberOfCompletedPackets));
for (int i = 0; i < Num; i++)
{
pData[i] = m_WiiMotes[i].GetConnectionHandle();
pData[Num + i] = m_PacketCount[i];
}
// Log // Log
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventNumberOfCompletedPackets"); INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventNumberOfCompletedPackets");
DEBUG_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x", pNumberOfCompletedPackets->Connection_Handle); DEBUG_LOG(WII_IPC_WIIMOTE, " NumberOfConnectionHandle: 0x%04x", pNumberOfCompletedPackets->NumberOfHandles);
DEBUG_LOG(WII_IPC_WIIMOTE, " Number_Of_Completed_Packets: %i", pNumberOfCompletedPackets->Number_Of_Completed_Packets);
AddEventToQueue(Event); AddEventToQueue(Event);
@ -1032,7 +1038,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventLinkKeyNotification(const CWI
return true; return true;
}; };
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestLinkKey(bdaddr_t _bd) bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestLinkKey(const bdaddr_t& _bd)
{ {
SQueuedEvent Event(sizeof(SHCIEventRequestLinkKey), 0); SQueuedEvent Event(sizeof(SHCIEventRequestLinkKey), 0);
@ -1042,13 +1048,13 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestLinkKey(bdaddr_t _bd)
pEventRequestLinkKey->PayloadLength = sizeof(SHCIEventRequestLinkKey) - 2; pEventRequestLinkKey->PayloadLength = sizeof(SHCIEventRequestLinkKey) - 2;
pEventRequestLinkKey->bdaddr = _bd; pEventRequestLinkKey->bdaddr = _bd;
AddEventToQueue(Event);
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventRequestLinkKey"); INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventRequestLinkKey");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pEventRequestLinkKey->bdaddr.b[0], pEventRequestLinkKey->bdaddr.b[1], pEventRequestLinkKey->bdaddr.b[2], pEventRequestLinkKey->bdaddr.b[0], pEventRequestLinkKey->bdaddr.b[1], pEventRequestLinkKey->bdaddr.b[2],
pEventRequestLinkKey->bdaddr.b[3], pEventRequestLinkKey->bdaddr.b[4], pEventRequestLinkKey->bdaddr.b[5]); pEventRequestLinkKey->bdaddr.b[3], pEventRequestLinkKey->bdaddr.b[4], pEventRequestLinkKey->bdaddr.b[5]);
AddEventToQueue(Event);
return true; return true;
}; };
@ -1121,7 +1127,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::ExecuteHCICommandMessage(const SHCICom
if(m_LastCmd == NULL) if(m_LastCmd == NULL)
{ {
INFO_LOG(WII_IPC_WIIMOTE, "**************************************************"); INFO_LOG(WII_IPC_WIIMOTE, "**************************************************");
INFO_LOG(WII_IPC_WIIMOTE, "ExecuteHCICommandMessage(0x%04x)(ocf: 0x%02x, ogf: 0x%02x)", pMsg->Opcode, ocf, ogf); INFO_LOG(WII_IPC_WIIMOTE, "Execute HCI Command: 0x%04x (ocf: 0x%02x, ogf: 0x%02x)", pMsg->Opcode, ocf, ogf);
} }
switch(pMsg->Opcode) switch(pMsg->Opcode)
@ -1508,7 +1514,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandChangeConPacketType(u8* _Input)
hci_change_con_pkt_type_cp* pChangePacketType = (hci_change_con_pkt_type_cp*)_Input; hci_change_con_pkt_type_cp* pChangePacketType = (hci_change_con_pkt_type_cp*)_Input;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_CHANGE_CON_PACKET_TYPE"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_CHANGE_CON_PACKET_TYPE");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pChangePacketType->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pChangePacketType->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " PacketType: 0x%04x", pChangePacketType->pkt_type); DEBUG_LOG(WII_IPC_WIIMOTE, " PacketType: 0x%04x", pChangePacketType->pkt_type);
@ -1524,7 +1529,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandAuthenticationRequested(u8* _In
hci_auth_req_cp* pAuthReq = (hci_auth_req_cp*)_Input; hci_auth_req_cp* pAuthReq = (hci_auth_req_cp*)_Input;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_AUTH_REQ"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_AUTH_REQ");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pAuthReq->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pAuthReq->con_handle);
SendEventAuthenticationCompleted(pAuthReq->con_handle); SendEventAuthenticationCompleted(pAuthReq->con_handle);
@ -1539,7 +1543,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandRemoteNameReq(u8* _Input)
hci_remote_name_req_cp* pRemoteNameReq = (hci_remote_name_req_cp*)_Input; hci_remote_name_req_cp* pRemoteNameReq = (hci_remote_name_req_cp*)_Input;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_REMOTE_NAME_REQ"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_REMOTE_NAME_REQ");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pRemoteNameReq->bdaddr.b[0], pRemoteNameReq->bdaddr.b[1], pRemoteNameReq->bdaddr.b[2], pRemoteNameReq->bdaddr.b[0], pRemoteNameReq->bdaddr.b[1], pRemoteNameReq->bdaddr.b[2],
pRemoteNameReq->bdaddr.b[3], pRemoteNameReq->bdaddr.b[4], pRemoteNameReq->bdaddr.b[5]); pRemoteNameReq->bdaddr.b[3], pRemoteNameReq->bdaddr.b[4], pRemoteNameReq->bdaddr.b[5]);
@ -1559,7 +1562,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadRemoteFeatures(u8* _Input)
hci_read_remote_features_cp* pReadRemoteFeatures = (hci_read_remote_features_cp*)_Input; hci_read_remote_features_cp* pReadRemoteFeatures = (hci_read_remote_features_cp*)_Input;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_REMOTE_FEATURES"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_REMOTE_FEATURES");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pReadRemoteFeatures->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pReadRemoteFeatures->con_handle);
SendEventReadRemoteFeatures(pReadRemoteFeatures->con_handle); SendEventReadRemoteFeatures(pReadRemoteFeatures->con_handle);
@ -1574,7 +1576,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadRemoteVerInfo(u8* _Input)
hci_read_remote_ver_info_cp* pReadRemoteVerInfo = (hci_read_remote_ver_info_cp*)_Input; hci_read_remote_ver_info_cp* pReadRemoteVerInfo = (hci_read_remote_ver_info_cp*)_Input;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_REMOTE_VER_INFO"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_REMOTE_VER_INFO");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%02x", pReadRemoteVerInfo->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%02x", pReadRemoteVerInfo->con_handle);
SendEventReadRemoteVerInfo(pReadRemoteVerInfo->con_handle); SendEventReadRemoteVerInfo(pReadRemoteVerInfo->con_handle);
@ -1589,7 +1590,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadClockOffset(u8* _Input)
hci_read_clock_offset_cp* pReadClockOffset = (hci_read_clock_offset_cp*)_Input; hci_read_clock_offset_cp* pReadClockOffset = (hci_read_clock_offset_cp*)_Input;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_CLOCK_OFFSET"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_CLOCK_OFFSET");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%02x", pReadClockOffset->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%02x", pReadClockOffset->con_handle);
SendEventReadClockOffsetComplete(pReadClockOffset->con_handle); SendEventReadClockOffsetComplete(pReadClockOffset->con_handle);
@ -1607,34 +1607,38 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandSniffMode(u8* _Input)
hci_sniff_mode_cp* pSniffMode = (hci_sniff_mode_cp*)_Input; hci_sniff_mode_cp* pSniffMode = (hci_sniff_mode_cp*)_Input;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_SNIFF_MODE"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_SNIFF_MODE");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:"); INFO_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pSniffMode->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pSniffMode->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " max_interval: 0x%04x", pSniffMode->max_interval); DEBUG_LOG(WII_IPC_WIIMOTE, " max_interval: 0x%04x", pSniffMode->max_interval);
DEBUG_LOG(WII_IPC_WIIMOTE, " min_interval: 0x%04x", pSniffMode->min_interval); DEBUG_LOG(WII_IPC_WIIMOTE, " min_interval: 0x%04x", pSniffMode->min_interval);
DEBUG_LOG(WII_IPC_WIIMOTE, " attempt: 0x%04x", pSniffMode->attempt); DEBUG_LOG(WII_IPC_WIIMOTE, " attempt: 0x%04x", pSniffMode->attempt);
DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: 0x%04x", pSniffMode->timeout); DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: 0x%04x", pSniffMode->timeout);
SendEventModeChange(pSniffMode->con_handle, 0x02, pSniffMode->max_interval); // 0x02 - sniff mode SendEventModeChange(pSniffMode->con_handle, 0x02, pSniffMode->max_interval); // 0x02 - sniff mode
// Now is a good time to activate next wiimote
u16 NextHandle = pSniffMode->con_handle + 1;
if ((NextHandle & 0x1u) < m_WiiMotes.size())
{
CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(NextHandle);
if (pWiimote)
pWiimote->Activate(true);
}
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLinkPolicy(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLinkPolicy(u8* _Input)
{ {
if(SendEventCommandStatus(HCI_CMD_WRITE_LINK_POLICY_SETTINGS))
return;
// command parameters // command parameters
hci_write_link_policy_settings_cp* pLinkPolicy = (hci_write_link_policy_settings_cp*)_Input; hci_write_link_policy_settings_cp* pLinkPolicy = (hci_write_link_policy_settings_cp*)_Input;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_LINK_POLICY_SETTINGS"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_LINK_POLICY_SETTINGS");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pLinkPolicy->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pLinkPolicy->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " Policy: 0x%04x", pLinkPolicy->settings); DEBUG_LOG(WII_IPC_WIIMOTE, " Policy: 0x%04x", pLinkPolicy->settings);
CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(pLinkPolicy->con_handle); hci_write_link_policy_settings_rp Reply;
if (pWiimote) Reply.status = 0x00;
{ Reply.con_handle = pLinkPolicy->con_handle;
pWiimote->EventCommandWriteLinkPolicy();
} SendEventCommandComplete(HCI_CMD_WRITE_LINK_POLICY_SETTINGS, &Reply, sizeof(hci_write_link_policy_settings_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReset(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReset(u8* _Input)
@ -1660,7 +1664,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandSetEventFilter(u8* _Input)
Reply.status = 0x00; Reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_SET_EVENT_FILTER:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_SET_EVENT_FILTER:");
DEBUG_LOG(WII_IPC_WIIMOTE, "write:");
DEBUG_LOG(WII_IPC_WIIMOTE, " filter_type: %i", pSetEventFilter->filter_type); DEBUG_LOG(WII_IPC_WIIMOTE, " filter_type: %i", pSetEventFilter->filter_type);
DEBUG_LOG(WII_IPC_WIIMOTE, " filter_condition_type: %i", pSetEventFilter->filter_condition_type); DEBUG_LOG(WII_IPC_WIIMOTE, " filter_condition_type: %i", pSetEventFilter->filter_condition_type);
@ -1678,7 +1681,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWritePinType(u8* _Input)
Reply.status = 0x00; Reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PIN_TYPE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PIN_TYPE:");
DEBUG_LOG(WII_IPC_WIIMOTE, "write:");
DEBUG_LOG(WII_IPC_WIIMOTE, " pin_type: %x", pWritePinType->pin_type); DEBUG_LOG(WII_IPC_WIIMOTE, " pin_type: %x", pWritePinType->pin_type);
SendEventCommandComplete(HCI_CMD_WRITE_PIN_TYPE, &Reply, sizeof(hci_write_pin_type_rp)); SendEventCommandComplete(HCI_CMD_WRITE_PIN_TYPE, &Reply, sizeof(hci_write_pin_type_rp));
@ -1735,7 +1737,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandDeleteStoredLinkKey(u8* _Input)
hci_delete_stored_link_key_cp* pDeleteStoredLinkKey = (hci_delete_stored_link_key_cp*)_Input; hci_delete_stored_link_key_cp* pDeleteStoredLinkKey = (hci_delete_stored_link_key_cp*)_Input;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_OCF_DELETE_STORED_LINK_KEY"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_OCF_DELETE_STORED_LINK_KEY");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pDeleteStoredLinkKey->bdaddr.b[0], pDeleteStoredLinkKey->bdaddr.b[1], pDeleteStoredLinkKey->bdaddr.b[2], pDeleteStoredLinkKey->bdaddr.b[0], pDeleteStoredLinkKey->bdaddr.b[1], pDeleteStoredLinkKey->bdaddr.b[2],
pDeleteStoredLinkKey->bdaddr.b[3], pDeleteStoredLinkKey->bdaddr.b[4], pDeleteStoredLinkKey->bdaddr.b[5]); pDeleteStoredLinkKey->bdaddr.b[3], pDeleteStoredLinkKey->bdaddr.b[4], pDeleteStoredLinkKey->bdaddr.b[5]);
@ -1767,7 +1768,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLocalName(u8* _Input)
Reply.status = 0x00; Reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_LOCAL_NAME:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_LOCAL_NAME:");
DEBUG_LOG(WII_IPC_WIIMOTE, "write:");
DEBUG_LOG(WII_IPC_WIIMOTE, " local_name: %s", pWriteLocalName->name); DEBUG_LOG(WII_IPC_WIIMOTE, " local_name: %s", pWriteLocalName->name);
SendEventCommandComplete(HCI_CMD_WRITE_LOCAL_NAME, &Reply, sizeof(hci_write_local_name_rp)); SendEventCommandComplete(HCI_CMD_WRITE_LOCAL_NAME, &Reply, sizeof(hci_write_local_name_rp));
@ -1787,7 +1787,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWritePageTimeOut(u8* _Input)
Reply.status = 0x00; Reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PAGE_TIMEOUT:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PAGE_TIMEOUT:");
DEBUG_LOG(WII_IPC_WIIMOTE, "write:");
DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: %i", pWritePageTimeOut->timeout); DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: %i", pWritePageTimeOut->timeout);
SendEventCommandComplete(HCI_CMD_WRITE_PAGE_TIMEOUT, &Reply, sizeof(hci_host_buffer_size_rp)); SendEventCommandComplete(HCI_CMD_WRITE_PAGE_TIMEOUT, &Reply, sizeof(hci_host_buffer_size_rp));
@ -1815,7 +1814,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteScanEnable(u8* _Input)
#endif #endif
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_SCAN_ENABLE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_SCAN_ENABLE:");
DEBUG_LOG(WII_IPC_WIIMOTE, "write:");
DEBUG_LOG(WII_IPC_WIIMOTE, " scan_enable: %s", Scanning[pWriteScanEnable->scan_enable]); DEBUG_LOG(WII_IPC_WIIMOTE, " scan_enable: %s", Scanning[pWriteScanEnable->scan_enable]);
SendEventCommandComplete(HCI_CMD_WRITE_SCAN_ENABLE, &Reply, sizeof(hci_write_scan_enable_rp)); SendEventCommandComplete(HCI_CMD_WRITE_SCAN_ENABLE, &Reply, sizeof(hci_write_scan_enable_rp));
@ -1834,7 +1832,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteUnitClass(u8* _Input)
Reply.status = 0x00; Reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_UNIT_CLASS:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_UNIT_CLASS:");
DEBUG_LOG(WII_IPC_WIIMOTE, "write:");
DEBUG_LOG(WII_IPC_WIIMOTE, " COD[0]: 0x%02x", pWriteUnitClass->uclass[0]); DEBUG_LOG(WII_IPC_WIIMOTE, " COD[0]: 0x%02x", pWriteUnitClass->uclass[0]);
DEBUG_LOG(WII_IPC_WIIMOTE, " COD[1]: 0x%02x", pWriteUnitClass->uclass[1]); DEBUG_LOG(WII_IPC_WIIMOTE, " COD[1]: 0x%02x", pWriteUnitClass->uclass[1]);
DEBUG_LOG(WII_IPC_WIIMOTE, " COD[2]: 0x%02x", pWriteUnitClass->uclass[2]); DEBUG_LOG(WII_IPC_WIIMOTE, " COD[2]: 0x%02x", pWriteUnitClass->uclass[2]);
@ -1856,8 +1853,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandHostBufferSize(u8* _Input)
Reply.status = 0x00; Reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_HOST_BUFFER_SIZE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_HOST_BUFFER_SIZE:");
DEBUG_LOG(WII_IPC_WIIMOTE, "write:");
DEBUG_LOG(WII_IPC_WIIMOTE, " max_acl_size: %i", pHostBufferSize->max_acl_size); DEBUG_LOG(WII_IPC_WIIMOTE, " max_acl_size: %i", pHostBufferSize->max_acl_size);
DEBUG_LOG(WII_IPC_WIIMOTE, " max_sco_size: %i", pHostBufferSize->max_sco_size); DEBUG_LOG(WII_IPC_WIIMOTE, " max_sco_size: %i", pHostBufferSize->max_sco_size);
DEBUG_LOG(WII_IPC_WIIMOTE, " num_acl_pkts: %i", pHostBufferSize->num_acl_pkts); DEBUG_LOG(WII_IPC_WIIMOTE, " num_acl_pkts: %i", pHostBufferSize->num_acl_pkts);
@ -1871,8 +1866,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLinkSupervisionTimeout(u8*
// command parameters // command parameters
hci_write_link_supervision_timeout_cp* pSuperVision = (hci_write_link_supervision_timeout_cp*)_Input; hci_write_link_supervision_timeout_cp* pSuperVision = (hci_write_link_supervision_timeout_cp*)_Input;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_OCF_WRITE_LINK_SUPERVISION_TIMEOUT"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_LINK_SUPERVISION_TIMEOUT");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " con_handle: 0x%04x", pSuperVision->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " con_handle: 0x%04x", pSuperVision->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: 0x%02x", pSuperVision->timeout); DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: 0x%02x", pSuperVision->timeout);
@ -1880,7 +1874,12 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLinkSupervisionTimeout(u8*
Reply.status = 0x00; Reply.status = 0x00;
Reply.con_handle = pSuperVision->con_handle; Reply.con_handle = pSuperVision->con_handle;
SendEventCommandComplete(HCI_OCF_WRITE_LINK_SUPERVISION_TIMEOUT, &Reply, sizeof(hci_write_link_supervision_timeout_rp)); SendEventCommandComplete(HCI_CMD_WRITE_LINK_SUPERVISION_TIMEOUT, &Reply, sizeof(hci_write_link_supervision_timeout_rp));
// Now is a good time to link channels
CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(pSuperVision->con_handle);
if (pWiimote)
pWiimote->EventConnectionAccepted();
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryScanType(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryScanType(u8* _Input)
@ -1894,7 +1893,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryScanType(u8* _Input
Reply.status = 0x00; Reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_INQUIRY_SCAN_TYPE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_INQUIRY_SCAN_TYPE:");
DEBUG_LOG(WII_IPC_WIIMOTE, "write:");
DEBUG_LOG(WII_IPC_WIIMOTE, " type: %i", pSetEventFilter->type); DEBUG_LOG(WII_IPC_WIIMOTE, " type: %i", pSetEventFilter->type);
SendEventCommandComplete(HCI_CMD_WRITE_INQUIRY_SCAN_TYPE, &Reply, sizeof(hci_write_inquiry_scan_type_rp)); SendEventCommandComplete(HCI_CMD_WRITE_INQUIRY_SCAN_TYPE, &Reply, sizeof(hci_write_inquiry_scan_type_rp));
@ -1920,7 +1918,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryMode(u8* _Input)
}; };
#endif #endif
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_INQUIRY_MODE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_INQUIRY_MODE:");
DEBUG_LOG(WII_IPC_WIIMOTE, "write:");
DEBUG_LOG(WII_IPC_WIIMOTE, " mode: %s", InquiryMode[pInquiryMode->mode]); DEBUG_LOG(WII_IPC_WIIMOTE, " mode: %s", InquiryMode[pInquiryMode->mode]);
SendEventCommandComplete(HCI_CMD_WRITE_INQUIRY_MODE, &Reply, sizeof(hci_write_inquiry_mode_rp)); SendEventCommandComplete(HCI_CMD_WRITE_INQUIRY_MODE, &Reply, sizeof(hci_write_inquiry_mode_rp));
@ -1946,7 +1943,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWritePageScanType(u8* _Input)
#endif #endif
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PAGE_SCAN_TYPE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PAGE_SCAN_TYPE:");
DEBUG_LOG(WII_IPC_WIIMOTE, "write:");
DEBUG_LOG(WII_IPC_WIIMOTE, " type: %s", PageScanType[pWritePageScanType->type]); DEBUG_LOG(WII_IPC_WIIMOTE, " type: %s", PageScanType[pWritePageScanType->type]);
SendEventCommandComplete(HCI_CMD_WRITE_PAGE_SCAN_TYPE, &Reply, sizeof(hci_write_page_scan_type_rp)); SendEventCommandComplete(HCI_CMD_WRITE_PAGE_SCAN_TYPE, &Reply, sizeof(hci_write_page_scan_type_rp));

18
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_usb.h
View File

@ -25,6 +25,8 @@
#include "WII_IPC_HLE_Device.h" #include "WII_IPC_HLE_Device.h"
#include "WII_IPC_HLE_WiiMote.h" #include "WII_IPC_HLE_WiiMote.h"
#define HCI_MAX_SIZE 128
#define ACL_MAX_SIZE 128
union UACLHeader union UACLHeader
{ {
@ -129,7 +131,7 @@ private:
struct ACLPool struct ACLPool
{ {
u32 m_number; u32 m_number;
u8 m_data[1024]; // Capacity: 64B x 16 u8 m_data[ACL_MAX_SIZE * 16];
ACLPool(int num) ACLPool(int num)
: m_number(num) : m_number(num)
@ -140,7 +142,7 @@ private:
struct HCIPool struct HCIPool
{ {
u32 m_number; u32 m_number;
u8 m_data[1024]; // Capacity: 64B x 16 u8 m_data[HCI_MAX_SIZE * 16];
u8 m_size[16]; u8 m_size[16];
HCIPool(int num) HCIPool(int num)
@ -191,9 +193,9 @@ private:
CtrlBuffer m_ACLBuffer; CtrlBuffer m_ACLBuffer;
ACLPool m_ACLPool; ACLPool m_ACLPool;
u32 m_LastCmd; u32 m_LastCmd;
int m_PacketCount; u32 m_PacketCount[4];
u32 m_FreqDividerMote[4];
u32 m_FreqDividerSync; u32 m_FreqDividerSync;
u32 m_FreqDividerMote;
// Events // Events
void AddEventToQueue(const SQueuedEvent& _event); void AddEventToQueue(const SQueuedEvent& _event);
@ -201,19 +203,19 @@ private:
void SendEventCommandComplete(u16 _OpCode, void* _pData, u32 _DataSize); void SendEventCommandComplete(u16 _OpCode, void* _pData, u32 _DataSize);
bool SendEventInquiryResponse(); bool SendEventInquiryResponse();
bool SendEventInquiryComplete(); bool SendEventInquiryComplete();
bool SendEventRemoteNameReq(bdaddr_t _bd); bool SendEventRemoteNameReq(const bdaddr_t& _bd);
bool SendEventRequestConnection(CWII_IPC_HLE_WiiMote& _rWiiMote); bool SendEventRequestConnection(CWII_IPC_HLE_WiiMote& _rWiiMote);
bool SendEventConnectionComplete(bdaddr_t _bd); bool SendEventConnectionComplete(const bdaddr_t& _bd);
bool SendEventReadClockOffsetComplete(u16 _connectionHandle); bool SendEventReadClockOffsetComplete(u16 _connectionHandle);
bool SendEventConPacketTypeChange(u16 _connectionHandle, u16 _packetType); bool SendEventConPacketTypeChange(u16 _connectionHandle, u16 _packetType);
bool SendEventReadRemoteVerInfo(u16 _connectionHandle); bool SendEventReadRemoteVerInfo(u16 _connectionHandle);
bool SendEventReadRemoteFeatures(u16 _connectionHandle); bool SendEventReadRemoteFeatures(u16 _connectionHandle);
bool SendEventRoleChange(bdaddr_t _bd, bool _master); bool SendEventRoleChange(bdaddr_t _bd, bool _master);
bool SendEventNumberOfCompletedPackets(u16 _connectionHandle, u16 _count); bool SendEventNumberOfCompletedPackets();
bool SendEventAuthenticationCompleted(u16 _connectionHandle); bool SendEventAuthenticationCompleted(u16 _connectionHandle);
bool SendEventModeChange(u16 _connectionHandle, u8 _mode, u16 _value); bool SendEventModeChange(u16 _connectionHandle, u8 _mode, u16 _value);
bool SendEventDisconnect(u16 _connectionHandle, u8 _Reason); bool SendEventDisconnect(u16 _connectionHandle, u8 _Reason);
bool SendEventRequestLinkKey(bdaddr_t _bd); bool SendEventRequestLinkKey(const bdaddr_t& _bd);
bool SendEventLinkKeyNotification(const CWII_IPC_HLE_WiiMote& _rWiiMote); bool SendEventLinkKeyNotification(const CWII_IPC_HLE_WiiMote& _rWiiMote);
// Execute HCI Message // Execute HCI Message

157
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_WiiMote.cpp
View File

@ -31,9 +31,8 @@
static CWII_IPC_HLE_Device_usb_oh1_57e_305* s_Usb; static CWII_IPC_HLE_Device_usb_oh1_57e_305* s_Usb;
CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305* _pHost, int _Number) CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305* _pHost, int _Number, bool ready)
: m_Connected(false) : m_Linked(false)
, m_Linked(false)
, m_HIDControlChannel_Connected(false) , m_HIDControlChannel_Connected(false)
, m_HIDControlChannel_ConnectedWait(false) , m_HIDControlChannel_ConnectedWait(false)
, m_HIDControlChannel_Config(false) , m_HIDControlChannel_Config(false)
@ -47,9 +46,14 @@ CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305*
{ {
s_Usb = _pHost;
INFO_LOG(WII_IPC_WIIMOTE, "Wiimote #%i constructed", _Number); INFO_LOG(WII_IPC_WIIMOTE, "Wiimote #%i constructed", _Number);
s_Usb = _pHost;
m_Connected = (ready) ? 0 : -1;
m_ConnectionHandle = 0x100 + _Number;
memset(m_LinkKey, 0xA0 + _Number, 16);
m_BD.b[0] = 0x11; m_BD.b[0] = 0x11;
m_BD.b[1] = 0x02; m_BD.b[1] = 0x02;
m_BD.b[2] = 0x19; m_BD.b[2] = 0x19;
@ -57,8 +61,6 @@ CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305*
m_BD.b[4] = 0x00; m_BD.b[4] = 0x00;
m_BD.b[5] = _Number; m_BD.b[5] = _Number;
m_ControllerConnectionHandle = 0x100 + _Number;
uclass[0]= 0x00; uclass[0]= 0x00;
uclass[1]= 0x04; uclass[1]= 0x04;
uclass[2]= 0x48; uclass[2]= 0x48;
@ -74,8 +76,6 @@ CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305*
lmp_version = 0x2; lmp_version = 0x2;
lmp_subversion = 0x229; lmp_subversion = 0x229;
memset(m_LinkKey, 0xA0 + _Number, 16);
} }
@ -92,7 +92,7 @@ CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305*
bool CWII_IPC_HLE_WiiMote::LinkChannel() bool CWII_IPC_HLE_WiiMote::LinkChannel()
{ {
if ((m_Connected == false) || (m_Linked == true)) if ((m_Connected <= 0) || (m_Linked == true))
return false; return false;
// try to connect HID_CONTROL_CHANNEL // try to connect HID_CONTROL_CHANNEL
@ -102,7 +102,6 @@ bool CWII_IPC_HLE_WiiMote::LinkChannel()
return false; return false;
m_HIDControlChannel_ConnectedWait = true; m_HIDControlChannel_ConnectedWait = true;
// The CID is fixed, other CID will be rejected
SendConnectionRequest(0x0040, HID_CONTROL_CHANNEL); SendConnectionRequest(0x0040, HID_CONTROL_CHANNEL);
return true; return true;
} }
@ -113,10 +112,8 @@ bool CWII_IPC_HLE_WiiMote::LinkChannel()
if (m_HIDControlChannel_ConfigWait) if (m_HIDControlChannel_ConfigWait)
return false; return false;
SChannel& rChannel = m_Channel[0x0040];
m_HIDControlChannel_ConfigWait = true; m_HIDControlChannel_ConfigWait = true;
SendConfigurationRequest(rChannel.DCID); SendConfigurationRequest(0x0040);
return true; return true;
} }
@ -127,7 +124,6 @@ bool CWII_IPC_HLE_WiiMote::LinkChannel()
return false; return false;
m_HIDInterruptChannel_ConnectedWait = true; m_HIDInterruptChannel_ConnectedWait = true;
// The CID is fixed, other CID will be rejected
SendConnectionRequest(0x0041, HID_INTERRUPT_CHANNEL); SendConnectionRequest(0x0041, HID_INTERRUPT_CHANNEL);
return true; return true;
} }
@ -139,9 +135,7 @@ bool CWII_IPC_HLE_WiiMote::LinkChannel()
return false; return false;
m_HIDInterruptChannel_ConfigWait = true; m_HIDInterruptChannel_ConfigWait = true;
SendConfigurationRequest(0x0041);
SChannel& rChannel = m_Channel[0x0041];
SendConfigurationRequest(rChannel.DCID);
return true; return true;
} }
@ -225,37 +219,43 @@ void CWII_IPC_HLE_WiiMote::UpdateStatus()
// //
// //
// //
void CWII_IPC_HLE_WiiMote::Activate(bool ready)
{
if (ready)
m_Connected = 0;
else
m_Connected = -1;
}
void CWII_IPC_HLE_WiiMote::EventConnectionAccepted() void CWII_IPC_HLE_WiiMote::EventConnectionAccepted()
{ {
m_Connected = true; m_Connected = 1;
m_Linked = false; m_Linked = false;
} }
void CWII_IPC_HLE_WiiMote::EventDisconnect() void CWII_IPC_HLE_WiiMote::EventDisconnect()
{ {
m_Connected = false; m_Connected = 0;
m_Linked = false; m_Linked = false;
// Clear channel flags // Clear channel flags
EventCommandWriteLinkPolicy(); ResetChannels();
} }
bool CWII_IPC_HLE_WiiMote::EventPagingChanged(u8 _pageMode) bool CWII_IPC_HLE_WiiMote::EventPagingChanged(u8 _pageMode)
{ {
if (m_Connected) if (m_Connected != 0)
return false; return false;
if ((_pageMode & 2) == 0) if ((_pageMode & 0x2) == 0)
return false; return false;
m_Connected = -1;
return true; return true;
} }
void CWII_IPC_HLE_WiiMote::EventCommandWriteLinkPolicy() void CWII_IPC_HLE_WiiMote::ResetChannels()
{ {
// reset connection process // reset connection process
m_HIDControlChannel_Connected = false; m_HIDControlChannel_Connected = false;
m_HIDControlChannel_Config = false; m_HIDControlChannel_Config = false;
m_HIDInterruptChannel_Connected = false; m_HIDInterruptChannel_Connected = false;
@ -291,8 +291,7 @@ void CWII_IPC_HLE_WiiMote::ExecuteL2capCmd(u8* _pData, u32 _Size)
SL2CAP_Header* pHeader = (SL2CAP_Header*)_pData; SL2CAP_Header* pHeader = (SL2CAP_Header*)_pData;
u8* pData = _pData + sizeof(SL2CAP_Header); u8* pData = _pData + sizeof(SL2CAP_Header);
u32 DataSize = _Size - sizeof(SL2CAP_Header); u32 DataSize = _Size - sizeof(SL2CAP_Header);
INFO_LOG(WII_IPC_WIIMOTE, "++++++++++++++++++++++++++++++++++++++"); INFO_LOG(WII_IPC_WIIMOTE, " CID 0x%04x, Len 0x%x, DataSize 0x%x", pHeader->CID, pHeader->Length, DataSize);
INFO_LOG(WII_IPC_WIIMOTE, "Execute L2CAP Command: Cid 0x%04x, Len 0x%x, DataSize 0x%x", pHeader->CID, pHeader->Length, DataSize);
if(pHeader->Length != DataSize) if(pHeader->Length != DataSize)
{ {
@ -322,13 +321,13 @@ void CWII_IPC_HLE_WiiMote::ExecuteL2capCmd(u8* _pData, u32 _Size)
break; break;
case HID_CONTROL_CHANNEL: case HID_CONTROL_CHANNEL:
mote->Wiimote_ControlChannel(rChannel.DCID, pData, DataSize); mote->Wiimote_ControlChannel(m_ConnectionHandle & 0x1, pHeader->CID, pData, DataSize);
// Call Wiimote Plugin // Call Wiimote Plugin
break; break;
case HID_INTERRUPT_CHANNEL: case HID_INTERRUPT_CHANNEL:
ShowStatus(pData); ShowStatus(pData);
mote->Wiimote_InterruptChannel(rChannel.DCID, pData, DataSize); mote->Wiimote_InterruptChannel(m_ConnectionHandle & 0x1, pHeader->CID, pData, DataSize);
// Call Wiimote Plugin // Call Wiimote Plugin
break; break;
@ -415,7 +414,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConnectionReq(u8 _Ident, u8* _pData, u32 _Size
rChannel.SCID = pCommandConnectionReq->scid; rChannel.SCID = pCommandConnectionReq->scid;
rChannel.DCID = pCommandConnectionReq->scid; rChannel.DCID = pCommandConnectionReq->scid;
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] ReceiveConnectionRequest"); INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConnectionRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident); DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident);
DEBUG_LOG(WII_IPC_WIIMOTE, " PSM: 0x%04x", rChannel.PSM); DEBUG_LOG(WII_IPC_WIIMOTE, " PSM: 0x%04x", rChannel.PSM);
DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", rChannel.SCID); DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", rChannel.SCID);
@ -428,7 +427,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConnectionReq(u8 _Ident, u8* _pData, u32 _Size
Rsp.result = 0x00; Rsp.result = 0x00;
Rsp.status = 0x00; Rsp.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] SendConnectionResponse"); INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConnectionResponse");
SendCommandToACL(_Ident, L2CAP_CONN_RSP, sizeof(SL2CAP_ConnectionResponse), (u8*)&Rsp); SendCommandToACL(_Ident, L2CAP_CONN_RSP, sizeof(SL2CAP_ConnectionResponse), (u8*)&Rsp);
} }
@ -438,7 +437,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConnectionResponse(u8 _Ident, u8* _pData, u32
_dbg_assert_(WII_IPC_WIIMOTE, _Size == sizeof(l2cap_conn_rsp)); _dbg_assert_(WII_IPC_WIIMOTE, _Size == sizeof(l2cap_conn_rsp));
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] ReceiveConnectionResponse"); INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConnectionResponse");
DEBUG_LOG(WII_IPC_WIIMOTE, " DCID: 0x%04x", rsp->dcid); DEBUG_LOG(WII_IPC_WIIMOTE, " DCID: 0x%04x", rsp->dcid);
DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", rsp->scid); DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", rsp->scid);
DEBUG_LOG(WII_IPC_WIIMOTE, " Result: 0x%04x", rsp->result); DEBUG_LOG(WII_IPC_WIIMOTE, " Result: 0x%04x", rsp->result);
@ -476,7 +475,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConfigurationReq(u8 _Ident, u8* _pData, u32 _S
SChannel& rChannel = m_Channel[pCommandConfigReq->dcid]; SChannel& rChannel = m_Channel[pCommandConfigReq->dcid];
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] ReceiveConfigurationRequest"); INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConfigurationRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident); DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident);
DEBUG_LOG(WII_IPC_WIIMOTE, " DCID: 0x%04x", pCommandConfigReq->dcid); DEBUG_LOG(WII_IPC_WIIMOTE, " DCID: 0x%04x", pCommandConfigReq->dcid);
DEBUG_LOG(WII_IPC_WIIMOTE, " Flags: 0x%04x", pCommandConfigReq->flags); DEBUG_LOG(WII_IPC_WIIMOTE, " Flags: 0x%04x", pCommandConfigReq->flags);
@ -506,7 +505,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConfigurationReq(u8 _Ident, u8* _pData, u32 _S
_dbg_assert_(WII_IPC_WIIMOTE, pOptions->length == 2); _dbg_assert_(WII_IPC_WIIMOTE, pOptions->length == 2);
SL2CAP_OptionsMTU* pMTU = (SL2CAP_OptionsMTU*)&_pData[Offset]; SL2CAP_OptionsMTU* pMTU = (SL2CAP_OptionsMTU*)&_pData[Offset];
rChannel.MTU = pMTU->MTU; rChannel.MTU = pMTU->MTU;
DEBUG_LOG(WII_IPC_WIIMOTE, " Config MTU: 0x%04x", pMTU->MTU); DEBUG_LOG(WII_IPC_WIIMOTE, " MTU: 0x%04x", pMTU->MTU);
// AyuanX: My experiment shows that the MTU is always set to 640 bytes // AyuanX: My experiment shows that the MTU is always set to 640 bytes
// This means that we only need temp_frame_size of 640B instead 1024B // This means that we only need temp_frame_size of 640B instead 1024B
// Actually I've never seen a frame bigger than 64B // Actually I've never seen a frame bigger than 64B
@ -519,7 +518,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConfigurationReq(u8 _Ident, u8* _pData, u32 _S
_dbg_assert_(WII_IPC_WIIMOTE, pOptions->length == 2); _dbg_assert_(WII_IPC_WIIMOTE, pOptions->length == 2);
SL2CAP_OptionsFlushTimeOut* pFlushTimeOut = (SL2CAP_OptionsFlushTimeOut*)&_pData[Offset]; SL2CAP_OptionsFlushTimeOut* pFlushTimeOut = (SL2CAP_OptionsFlushTimeOut*)&_pData[Offset];
rChannel.FlushTimeOut = pFlushTimeOut->TimeOut; rChannel.FlushTimeOut = pFlushTimeOut->TimeOut;
DEBUG_LOG(WII_IPC_WIIMOTE, " Config FlushTimeOut: 0x%04x", pFlushTimeOut->TimeOut); DEBUG_LOG(WII_IPC_WIIMOTE, " FlushTimeOut: 0x%04x", pFlushTimeOut->TimeOut);
} }
break; break;
@ -535,14 +534,13 @@ void CWII_IPC_HLE_WiiMote::ReceiveConfigurationReq(u8 _Ident, u8* _pData, u32 _S
RespLen += OptionSize; RespLen += OptionSize;
} }
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] SendConfigurationResponse"); INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConfigurationResponse");
SendCommandToACL(_Ident, L2CAP_CONF_RSP, RespLen, TempBuffer); SendCommandToACL(_Ident, L2CAP_CONF_RSP, RespLen, TempBuffer);
// update state machine // update state machine
if (rChannel.PSM == HID_CONTROL_CHANNEL) if (rChannel.PSM == HID_CONTROL_CHANNEL)
m_HIDControlChannel_Connected = true; m_HIDControlChannel_Connected = true;
else if (rChannel.PSM == HID_INTERRUPT_CHANNEL)
if (rChannel.PSM == HID_INTERRUPT_CHANNEL)
m_HIDInterruptChannel_Connected = true; m_HIDInterruptChannel_Connected = true;
} }
@ -551,9 +549,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConfigurationResponse(u8 _Ident, u8* _pData, u
{ {
l2cap_conf_rsp* rsp = (l2cap_conf_rsp*)_pData; l2cap_conf_rsp* rsp = (l2cap_conf_rsp*)_pData;
_dbg_assert_(WII_IPC_WIIMOTE, _Size == sizeof(l2cap_conf_rsp)); INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConfigurationResponse");
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] ReceiveConfigurationResponse");
DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", rsp->scid); DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", rsp->scid);
DEBUG_LOG(WII_IPC_WIIMOTE, " Flags: 0x%04x", rsp->flags); DEBUG_LOG(WII_IPC_WIIMOTE, " Flags: 0x%04x", rsp->flags);
DEBUG_LOG(WII_IPC_WIIMOTE, " Result: 0x%04x", rsp->result); DEBUG_LOG(WII_IPC_WIIMOTE, " Result: 0x%04x", rsp->result);
@ -564,30 +560,32 @@ void CWII_IPC_HLE_WiiMote::ReceiveConfigurationResponse(u8 _Ident, u8* _pData, u
SChannel& rChannel = m_Channel[rsp->scid]; SChannel& rChannel = m_Channel[rsp->scid];
if (rChannel.PSM == HID_CONTROL_CHANNEL) if (rChannel.PSM == HID_CONTROL_CHANNEL)
{
m_HIDControlChannel_Config = true; m_HIDControlChannel_Config = true;
INFO_LOG(WII_IPC_WIIMOTE, "Building HID_CONTROL_CHANNEL -- OK");
if (rChannel.PSM == HID_INTERRUPT_CHANNEL) }
else if (rChannel.PSM == HID_INTERRUPT_CHANNEL)
{
m_HIDInterruptChannel_Config = true; m_HIDInterruptChannel_Config = true;
INFO_LOG(WII_IPC_WIIMOTE, "Building HID_INTERRUPT_CHANNEL -- OK");
}
} }
void CWII_IPC_HLE_WiiMote::ReceiveDisconnectionReq(u8 _Ident, u8* _pData, u32 _Size) void CWII_IPC_HLE_WiiMote::ReceiveDisconnectionReq(u8 _Ident, u8* _pData, u32 _Size)
{ {
SL2CAP_CommandDisconnectionReq* pCommandDisconnectionReq = (SL2CAP_CommandDisconnectionReq*)_pData; SL2CAP_CommandDisconnectionReq* pCommandDisconnectionReq = (SL2CAP_CommandDisconnectionReq*)_pData;
_dbg_assert_(WII_IPC_WIIMOTE, m_Channel.find(pCommandDisconnectionReq->scid) != m_Channel.end()); INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveDisconnectionReq");
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] ReceiveDisconnectionReq");
DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident); DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident);
DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", pCommandDisconnectionReq->dcid); DEBUG_LOG(WII_IPC_WIIMOTE, " DCID: 0x%04x", pCommandDisconnectionReq->dcid);
DEBUG_LOG(WII_IPC_WIIMOTE, " DCID: 0x%04x", pCommandDisconnectionReq->scid); DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", pCommandDisconnectionReq->scid);
// response // response
SL2CAP_CommandDisconnectionResponse Rsp; SL2CAP_CommandDisconnectionResponse Rsp;
Rsp.scid = pCommandDisconnectionReq->scid;
Rsp.dcid = pCommandDisconnectionReq->dcid; Rsp.dcid = pCommandDisconnectionReq->dcid;
Rsp.scid = pCommandDisconnectionReq->scid;
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] SendDisconnectionResponse"); INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendDisconnectionResponse");
SendCommandToACL(_Ident, L2CAP_DISCONN_RSP, sizeof(SL2CAP_CommandDisconnectionResponse), (u8*)&Rsp); SendCommandToACL(_Ident, L2CAP_DISCONN_RSP, sizeof(SL2CAP_CommandDisconnectionResponse), (u8*)&Rsp);
} }
@ -614,7 +612,8 @@ void CWII_IPC_HLE_WiiMote::SendConnectionRequest(u16 scid, u16 psm)
cr.psm = psm; cr.psm = psm;
cr.scid = scid; cr.scid = scid;
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] SendConnectionRequest"); INFO_LOG(WII_IPC_WIIMOTE, "-------------------------------------");
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConnectionRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, " Psm: 0x%04x", cr.psm); DEBUG_LOG(WII_IPC_WIIMOTE, " Psm: 0x%04x", cr.psm);
DEBUG_LOG(WII_IPC_WIIMOTE, " Scid: 0x%04x", cr.scid); DEBUG_LOG(WII_IPC_WIIMOTE, " Scid: 0x%04x", cr.scid);
@ -631,14 +630,14 @@ void CWII_IPC_HLE_WiiMote::SendDisconnectRequest(u16 scid)
cr.dcid = rChannel.DCID; cr.dcid = rChannel.DCID;
cr.scid = rChannel.SCID; cr.scid = rChannel.SCID;
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] SendDisconnectionRequest"); INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendDisconnectionRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, " Dcid: 0x%04x", cr.dcid); DEBUG_LOG(WII_IPC_WIIMOTE, " Dcid: 0x%04x", cr.dcid);
DEBUG_LOG(WII_IPC_WIIMOTE, " Scid: 0x%04x", cr.scid); DEBUG_LOG(WII_IPC_WIIMOTE, " Scid: 0x%04x", cr.scid);
SendCommandToACL(L2CAP_DISCONN_REQ, L2CAP_DISCONN_REQ, sizeof(l2cap_disconn_req), (u8*)&cr); SendCommandToACL(L2CAP_DISCONN_REQ, L2CAP_DISCONN_REQ, sizeof(l2cap_disconn_req), (u8*)&cr);
} }
void CWII_IPC_HLE_WiiMote::SendConfigurationRequest(u16 scid, u16* MTU, u16* FlushTimeOut) void CWII_IPC_HLE_WiiMote::SendConfigurationRequest(u16 scid, u16 MTU, u16 FlushTimeOut)
{ {
_dbg_assert_(WII_IPC_WIIMOTE, DoesChannelExist(scid)); _dbg_assert_(WII_IPC_WIIMOTE, DoesChannelExist(scid));
SChannel& rChannel = m_Channel[scid]; SChannel& rChannel = m_Channel[scid];
@ -651,31 +650,29 @@ void CWII_IPC_HLE_WiiMote::SendConfigurationRequest(u16 scid, u16* MTU, u16* Flu
cr->flags = 0; cr->flags = 0;
Offset += sizeof(l2cap_conf_req); Offset += sizeof(l2cap_conf_req);
if (MTU != NULL) SL2CAP_Options* pOptions;
{
SL2CAP_Options* pOptions = (SL2CAP_Options*)&Buffer[Offset];
Offset += sizeof(SL2CAP_Options);
if (MTU == NULL) MTU = rChannel.MTU;
pOptions = (SL2CAP_Options*)&Buffer[Offset];
Offset += sizeof(SL2CAP_Options);
pOptions->type = 1; pOptions->type = 1;
pOptions->length = 2; pOptions->length = 2;
*(u16*)&Buffer[Offset] = MTU;
Offset += 2;
*(u16*)&Buffer[Offset] = *MTU; Offset += 2; if (FlushTimeOut == NULL) FlushTimeOut = rChannel.FlushTimeOut;
} pOptions = (SL2CAP_Options*)&Buffer[Offset];
if (FlushTimeOut != NULL)
{
SL2CAP_Options* pOptions = (SL2CAP_Options*)&Buffer[Offset];
Offset += sizeof(SL2CAP_Options); Offset += sizeof(SL2CAP_Options);
pOptions->type = 2; pOptions->type = 2;
pOptions->length = 2; pOptions->length = 2;
*(u16*)&Buffer[Offset] = FlushTimeOut;
Offset += 2;
*(u16*)&Buffer[Offset] = *FlushTimeOut; Offset += 2; INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConfigurationRequest");
}
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] SendConfigurationRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, " Dcid: 0x%04x", cr->dcid); DEBUG_LOG(WII_IPC_WIIMOTE, " Dcid: 0x%04x", cr->dcid);
DEBUG_LOG(WII_IPC_WIIMOTE, " Flags: 0x%04x", cr->flags); DEBUG_LOG(WII_IPC_WIIMOTE, " Flags: 0x%04x", cr->flags);
DEBUG_LOG(WII_IPC_WIIMOTE, " MTU: 0x%04x", MTU);
DEBUG_LOG(WII_IPC_WIIMOTE, " FlushTimeOut: 0x%04x", FlushTimeOut);
SendCommandToACL(L2CAP_CONF_REQ, L2CAP_CONF_REQ, Offset, Buffer); SendCommandToACL(L2CAP_CONF_REQ, L2CAP_CONF_REQ, Offset, Buffer);
} }
@ -885,17 +882,17 @@ void CWII_IPC_HLE_WiiMote::SendCommandToACL(u8 _Ident, u8 _Code, u8 _CommandLeng
u32 Offset = 0; u32 Offset = 0;
SL2CAP_Header* pHeader = (SL2CAP_Header*)&DataFrame[Offset]; Offset += sizeof(SL2CAP_Header); SL2CAP_Header* pHeader = (SL2CAP_Header*)&DataFrame[Offset]; Offset += sizeof(SL2CAP_Header);
pHeader->CID = 0x0001;
pHeader->Length = sizeof(SL2CAP_Command) + _CommandLength; pHeader->Length = sizeof(SL2CAP_Command) + _CommandLength;
pHeader->CID = 0x0001;
SL2CAP_Command* pCommand = (SL2CAP_Command*)&DataFrame[Offset]; Offset += sizeof(SL2CAP_Command); SL2CAP_Command* pCommand = (SL2CAP_Command*)&DataFrame[Offset]; Offset += sizeof(SL2CAP_Command);
pCommand->len = _CommandLength;
pCommand->ident = _Ident;
pCommand->code = _Code; pCommand->code = _Code;
pCommand->ident = _Ident;
pCommand->len = _CommandLength;
memcpy(&DataFrame[Offset], _pCommandData, _CommandLength); memcpy(&DataFrame[Offset], _pCommandData, _CommandLength);
DEBUG_LOG(WII_IPC_WIIMOTE, " SendCommandToACL (to CPU)"); INFO_LOG(WII_IPC_WIIMOTE, "Send ACL Command to CPU");
DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident); DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident);
DEBUG_LOG(WII_IPC_WIIMOTE, " Code: 0x%02x", _Code); DEBUG_LOG(WII_IPC_WIIMOTE, " Code: 0x%02x", _Code);
@ -944,16 +941,16 @@ namespace Core
{ {
/* This is called continuously from the Wiimote plugin as soon as it has received /* This is called continuously from the Wiimote plugin as soon as it has received
a reporting mode. _Size is the byte size of the report. */ a reporting mode. _Size is the byte size of the report. */
void Callback_WiimoteInput(u16 _channelID, const void* _pData, u32 _Size) void Callback_WiimoteInput(int _number, u16 _channelID, const void* _pData, u32 _Size)
{ {
DEBUG_LOG(WII_IPC_WIIMOTE, "=========================================================");
const u8* pData = (const u8*)_pData; const u8* pData = (const u8*)_pData;
DEBUG_LOG(WII_IPC_WIIMOTE, "Callback_WiimoteInput:");
DEBUG_LOG(WII_IPC_WIIMOTE, " Data: %s", ArrayToString(pData, _Size, 0, 50).c_str());
DEBUG_LOG(WII_IPC_WIIMOTE, " Channel: %u", _channelID);
s_Usb->m_WiiMotes[0].ReceiveL2capData(_channelID, _pData, _Size); INFO_LOG(WIIMOTE, "==========================");
DEBUG_LOG(WII_IPC_WIIMOTE, "========================================================="); INFO_LOG(WIIMOTE, "Callback_WiimoteInput: (Page: %i)", _number);
DEBUG_LOG(WIIMOTE, " Data: %s", ArrayToString(pData, _Size, 0, 50).c_str());
DEBUG_LOG(WIIMOTE, " Channel: %u", _channelID);
s_Usb->m_WiiMotes[_number].ReceiveL2capData(_channelID, _pData, _Size);
} }
} }

15
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_WiiMote.h
View File

@ -183,7 +183,7 @@ class CWII_IPC_HLE_WiiMote
{ {
public: public:
CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305* _pHost, int _Number); CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305* _pHost, int _Number, bool ready = false);
virtual ~CWII_IPC_HLE_WiiMote() virtual ~CWII_IPC_HLE_WiiMote()
{} {}
@ -193,7 +193,9 @@ public:
// we really have to clean all this code // we really have to clean all this code
bool LinkChannel(); bool LinkChannel();
bool IsConnected() const { return m_Connected; } void ResetChannels();
void Activate(bool ready);
bool IsConnected() const { return (m_Connected > 0) ? true : false; }
bool IsLinked() const { return m_Linked; } bool IsLinked() const { return m_Linked; }
void ShowStatus(const void* _pData); // Show status void ShowStatus(const void* _pData); // Show status
void UpdateStatus(); // Update status void UpdateStatus(); // Update status
@ -203,11 +205,10 @@ public:
void EventConnectionAccepted(); void EventConnectionAccepted();
void EventDisconnect(); void EventDisconnect();
bool EventPagingChanged(u8 _pageMode); bool EventPagingChanged(u8 _pageMode);
void EventCommandWriteLinkPolicy();
const bdaddr_t& GetBD() const { return m_BD; } const bdaddr_t& GetBD() const { return m_BD; }
const uint8_t* GetClass() const { return uclass; } const uint8_t* GetClass() const { return uclass; }
u16 GetConnectionHandle() const { return m_ControllerConnectionHandle; } u16 GetConnectionHandle() const { return m_ConnectionHandle; }
const u8* GetFeatures() const { return features; } const u8* GetFeatures() const { return features; }
const char* GetName() const { return m_Name.c_str(); } const char* GetName() const { return m_Name.c_str(); }
u8 GetLMPVersion() const { return lmp_version; } u8 GetLMPVersion() const { return lmp_version; }
@ -218,7 +219,7 @@ public:
private: private:
// state machine // state machine
bool m_Connected; int m_Connected; // 0: ready, -1: inactive/connecting, 1: connected
bool m_Linked; bool m_Linked;
bool m_HIDControlChannel_Connected; bool m_HIDControlChannel_Connected;
bool m_HIDControlChannel_ConnectedWait; bool m_HIDControlChannel_ConnectedWait;
@ -231,7 +232,7 @@ private:
// STATE_TO_SAVE // STATE_TO_SAVE
bdaddr_t m_BD; bdaddr_t m_BD;
u16 m_ControllerConnectionHandle; u16 m_ConnectionHandle;
uint8_t uclass[HCI_CLASS_SIZE]; uint8_t uclass[HCI_CLASS_SIZE];
u8 features[HCI_FEATURES_SIZE]; u8 features[HCI_FEATURES_SIZE];
u8 lmp_version; u8 lmp_version;
@ -263,7 +264,7 @@ private:
void SignalChannel(u8* _pData, u32 _Size); void SignalChannel(u8* _pData, u32 _Size);
void SendConnectionRequest(u16 _SCID, u16 _PSM); void SendConnectionRequest(u16 _SCID, u16 _PSM);
void SendConfigurationRequest(u16 _SCID, u16* _pMTU = NULL, u16* _pFlushTimeOut = NULL); void SendConfigurationRequest(u16 _SCID, u16 _pMTU = NULL, u16 _pFlushTimeOut = NULL);
void SendDisconnectRequest(u16 _SCID); void SendDisconnectRequest(u16 _SCID);
void ReceiveConnectionReq(u8 _Ident, u8* _pData, u32 _Size); void ReceiveConnectionReq(u8 _Ident, u8* _pData, u32 _Size);

2
Source/Core/DolphinWX/Src/ConfigMain.cpp
View File

@ -286,7 +286,7 @@ void CConfigMain::CreateGUIControls()
wxT("\nIt can be convenient in a Wii game that already has a cursor.")); wxT("\nIt can be convenient in a Wii game that already has a cursor."));
WiimoteStatusLEDs->SetToolTip(wxT("Show which wiimotes are connected in the statusbar.")); WiimoteStatusLEDs->SetToolTip(wxT("Show which wiimotes are connected in the statusbar."));
WiimoteStatusSpeakers->SetToolTip(wxT("Show wiimote speaker status in the statusbar.")); WiimoteStatusSpeakers->SetToolTip(wxT("Show wiimote speaker status in the statusbar."));
DSPThread->SetToolTip(wxT("Run DSPLLE on a dedicate thread, this has no affect on DSPHLE.")); DSPThread->SetToolTip(wxT("Run DSPLLE on a dedicate thread, this has no effects on DSPHLE."));
CPUThread->SetToolTip(wxT("This splits the Video and CPU threads, so they can be run on separate cores.") CPUThread->SetToolTip(wxT("This splits the Video and CPU threads, so they can be run on separate cores.")
wxT("\nCauses major speed improvements on PCs with more than one core,") wxT("\nCauses major speed improvements on PCs with more than one core,")
wxT("\nbut can also cause occasional crashes/glitches.")); wxT("\nbut can also cause occasional crashes/glitches."));

8
Source/PluginSpecs/pluginspecs_wiimote.h
View File

@ -13,7 +13,7 @@ typedef void (*TLogv)(const char* _pMessage, int _v);
// This is called when the Wiimote sends input reports to the Core. // This is called when the Wiimote sends input reports to the Core.
// Payload: an L2CAP packet. // Payload: an L2CAP packet.
typedef void (*TWiimoteInput)(u16 _channelID, const void* _pData, u32 _Size); typedef void (*TWiimoteInput)(int _number, u16 _channelID, const void* _pData, u32 _Size);
// This data is passed from the core on initialization. // This data is passed from the core on initialization.
typedef struct typedef struct
@ -35,7 +35,7 @@ typedef struct
// input: Da pakket. // input: Da pakket.
// output: none // output: none
// //
EXPORT void CALL Wiimote_ControlChannel(u16 _channelID, const void* _pData, u32 _Size); EXPORT void CALL Wiimote_ControlChannel(int _number, u16 _channelID, const void* _pData, u32 _Size);
// __________________________________________________________________________________________________ // __________________________________________________________________________________________________
// Function: Wiimote_Input // Function: Wiimote_Input
@ -44,7 +44,7 @@ EXPORT void CALL Wiimote_ControlChannel(u16 _channelID, const void* _pData, u32
// input: Da pakket. // input: Da pakket.
// output: none // output: none
// //
EXPORT void CALL Wiimote_InterruptChannel(u16 _channelID, const void* _pData, u32 _Size); EXPORT void CALL Wiimote_InterruptChannel(int _number, u16 _channelID, const void* _pData, u32 _Size);
// __________________________________________________________________________________________________ // __________________________________________________________________________________________________
// Function: Wiimote_Update // Function: Wiimote_Update
@ -52,7 +52,7 @@ EXPORT void CALL Wiimote_InterruptChannel(u16 _channelID, const void* _pData, u3
// input: none // input: none
// output: none // output: none
// //
EXPORT void CALL Wiimote_Update(); EXPORT void CALL Wiimote_Update(int _number);
// __________________________________________________________________________________________________ // __________________________________________________________________________________________________
// Function: PAD_GetAttachedPads // Function: PAD_GetAttachedPads

6
Source/Plugins/Plugin_Wiimote/Src/Config.cpp
View File

@ -21,7 +21,7 @@
#include "Common.h" #include "Common.h"
#include "IniFile.h" #include "IniFile.h"
#include "StringUtil.h" #include "StringUtil.h"
#include "wiimote_hid.h"
#include "Config.h" #include "Config.h"
#include "EmuDefinitions.h" // for PadMapping #include "EmuDefinitions.h" // for PadMapping
#include "main.h" #include "main.h"
@ -293,7 +293,7 @@ void Config::Load(bool ChangePad)
iniFile.Get("Real", "AccNunNeutralY", &iAccNunNeutralY, 0); iniFile.Get("Real", "AccNunNeutralY", &iAccNunNeutralY, 0);
iniFile.Get("Real", "AccNunNeutralZ", &iAccNunNeutralZ, 0); iniFile.Get("Real", "AccNunNeutralZ", &iAccNunNeutralZ, 0);
for (int i = 0; i < 1; i++) // Only got 1 wiimote yet for (int i = 0; i < MAX_WIIMOTES; i++)
{ {
// Slot specific settings // Slot specific settings
char SectionName[32]; char SectionName[32];
@ -404,7 +404,7 @@ void Config::Save(int Slot)
iniFile.Set("Real", "AccNunNeutralY", iAccNunNeutralY); iniFile.Set("Real", "AccNunNeutralY", iAccNunNeutralY);
iniFile.Set("Real", "AccNunNeutralZ", iAccNunNeutralZ); iniFile.Set("Real", "AccNunNeutralZ", iAccNunNeutralZ);
for (int i = 0; i < 1; i++) // Only got 1 wiimote yet for (int i = 0; i < MAX_WIIMOTES; i++)
{ {
// Slot specific settings // Slot specific settings
char SectionName[32]; char SectionName[32];

4
Source/Plugins/Plugin_Wiimote/Src/ConfigPadDlg.cpp
View File

@ -261,7 +261,7 @@ void WiimotePadConfigDialog::DoSave(bool ChangePad, int Slot)
if(ChangePad) if(ChangePad)
{ {
// Since we are selecting the pad to save to by the Id we can't update it when we change the pad // Since we are selecting the pad to save to by the Id we can't update it when we change the pad
for(int i = 0; i < 1; i++) // Only got 1 wiimote yet for(int i = 0; i < MAX_WIIMOTES; i++)
SaveButtonMapping(i, true); SaveButtonMapping(i, true);
// Save the settings for the current pad // Save the settings for the current pad
// g_Config.Save(Slot); // g_Config.Save(Slot);
@ -271,7 +271,7 @@ void WiimotePadConfigDialog::DoSave(bool ChangePad, int Slot)
else else
{ {
// Update PadMapping[] from the GUI controls // Update PadMapping[] from the GUI controls
for(int i = 0; i < 1; i++) // Only got 1 wiimote yet for(int i = 0; i < MAX_WIIMOTES; i++)
SaveButtonMapping(i); SaveButtonMapping(i);
// g_Config.Save(Slot); // g_Config.Save(Slot);
} }

13
Source/Plugins/Plugin_Wiimote/Src/DataReports.cpp
View File

@ -77,7 +77,7 @@ void WmReportMode(u16 _channelID, wm_report_mode* dr)
DEBUG_LOG(WIIMOTE, " All The Time: %x (not only on data change)", dr->all_the_time); 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, " Mode: 0x%02x", dr->mode);
g_ReportingAuto = dr->all_the_time; g_ReportingAuto[g_RefreshWiimote] = dr->all_the_time;
g_ReportingMode = dr->mode; g_ReportingMode = dr->mode;
g_ReportingChannel = _channelID; g_ReportingChannel = _channelID;
@ -114,8 +114,7 @@ void SendReportCore(u16 _channelID)
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID); DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset); DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging // Debugging
//ReadDebugging(true, DataFrame, Offset); //ReadDebugging(true, DataFrame, Offset);
} }
@ -140,7 +139,7 @@ void SendReportCoreAccel(u16 _channelID)
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID); DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset); DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging // Debugging
//ReadDebugging(true, DataFrame, Offset); //ReadDebugging(true, DataFrame, Offset);
@ -170,7 +169,7 @@ void SendReportCoreAccelIr12(u16 _channelID) {
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID); DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset); DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging // Debugging
//ReadDebugging(true, DataFrame, Offset); //ReadDebugging(true, DataFrame, Offset);
@ -215,7 +214,7 @@ void SendReportCoreAccelExt16(u16 _channelID)
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID); DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset); DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging // Debugging
//ReadDebugging(true, DataFrame, Offset); //ReadDebugging(true, DataFrame, Offset);
@ -269,7 +268,7 @@ void SendReportCoreAccelIr10Ext(u16 _channelID)
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID); DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset); DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging // Debugging
//ReadDebugging(true, DataFrame, Offset); //ReadDebugging(true, DataFrame, Offset);

6
Source/Plugins/Plugin_Wiimote/Src/EmuDefinitions.cpp
View File

@ -36,7 +36,7 @@ namespace WiiMoteEmu
// Definitions and variable declarations // Definitions and variable declarations
//****************************************************************************** //******************************************************************************
u8 g_Leds; u8 g_Leds[4];
u8 g_Speaker; u8 g_Speaker;
u8 g_SpeakerVoice; u8 g_SpeakerVoice;
u8 g_IR; u8 g_IR;
@ -48,7 +48,8 @@ u8 g_RegExt[WIIMOTE_REG_EXT_SIZE];
u8 g_RegExtTmp[WIIMOTE_REG_EXT_SIZE]; u8 g_RegExtTmp[WIIMOTE_REG_EXT_SIZE];
u8 g_RegIr[WIIMOTE_REG_IR_SIZE]; u8 g_RegIr[WIIMOTE_REG_IR_SIZE];
bool g_ReportingAuto; // Auto report or passive report int g_RefreshWiimote; // Current refreshing Wiimote
bool g_ReportingAuto[4]; // Auto report or passive report
u8 g_ReportingMode; // The reporting mode and channel id u8 g_ReportingMode; // The reporting mode and channel id
u16 g_ReportingChannel; u16 g_ReportingChannel;
@ -69,6 +70,7 @@ KeyboardNunchuck g_NunchuckExt;
KeyboardClassicController g_ClassicContExt; KeyboardClassicController g_ClassicContExt;
KeyboardGH3GLP g_GH3Ext; KeyboardGH3GLP g_GH3Ext;
bool KeyStatus[64]; bool KeyStatus[64];
SWiimoteData g_WiimoteData[4];
} // namespace } // namespace
#endif //_EMU_DECLARATIONS_ #endif //_EMU_DECLARATIONS_

34
Source/Plugins/Plugin_Wiimote/Src/EmuDefinitions.h
View File

@ -68,7 +68,7 @@ extern double g_RecordingCurrentTime[3];
#define WIIMOTE_REG_EXT_SIZE 0x100 #define WIIMOTE_REG_EXT_SIZE 0x100
#define WIIMOTE_REG_IR_SIZE 0x34 #define WIIMOTE_REG_IR_SIZE 0x34
extern u8 g_Leds; extern u8 g_Leds[4];
extern u8 g_Speaker; extern u8 g_Speaker;
extern u8 g_SpeakerVoice; extern u8 g_SpeakerVoice;
extern u8 g_IR; extern u8 g_IR;
@ -80,7 +80,8 @@ extern u8 g_RegExt[WIIMOTE_REG_EXT_SIZE];
extern u8 g_RegExtTmp[WIIMOTE_REG_EXT_SIZE]; extern u8 g_RegExtTmp[WIIMOTE_REG_EXT_SIZE];
extern u8 g_RegIr[WIIMOTE_REG_IR_SIZE]; extern u8 g_RegIr[WIIMOTE_REG_IR_SIZE];
extern bool g_ReportingAuto; extern int g_RefreshWiimote;
extern bool g_ReportingAuto[4];
extern u8 g_ReportingMode; extern u8 g_ReportingMode;
extern u16 g_ReportingChannel; extern u16 g_ReportingChannel;
@ -187,6 +188,14 @@ struct STiltData
} }
}; };
struct SWiimoteData
{
// Raw X and Y coordinate and processed X and Y coordinates
SIR IR;
STiltData TiltWM;
STiltData TiltNC;
};
extern SWiimoteData g_WiimoteData[4];
// Keyboard input // Keyboard input
struct KeyboardWiimote struct KeyboardWiimote
@ -204,10 +213,6 @@ struct KeyboardWiimote
MA, MB, MA, MB,
LAST_CONSTANT LAST_CONSTANT
}; };
// Raw X and Y coordinate and processed X and Y coordinates
SIR IR;
STiltData TiltData;
}; };
extern KeyboardWiimote g_Wiimote_kbd; extern KeyboardWiimote g_Wiimote_kbd;
@ -215,12 +220,7 @@ struct KeyboardNunchuck
{ {
enum EKeyboardNunchuck enum EKeyboardNunchuck
{ {
// This is not allowed in Linux so we have to set the starting value manually
#ifdef _WIN32
Z = g_Wiimote_kbd.LAST_CONSTANT,
#else
Z = 18, Z = 18,
#endif
C, C,
L, R, U, D, L, R, U, D,
ROLL_L, ROLL_R, ROLL_L, ROLL_R,
@ -228,8 +228,6 @@ struct KeyboardNunchuck
SHAKE, SHAKE,
LAST_CONSTANT LAST_CONSTANT
}; };
STiltData TiltData;
}; };
extern KeyboardNunchuck g_NunchuckExt; extern KeyboardNunchuck g_NunchuckExt;
@ -237,12 +235,7 @@ struct KeyboardClassicController
{ {
enum EKeyboardClassicController enum EKeyboardClassicController
{ {
// This is not allowed in Linux so we have to set the starting value manually
#ifdef _WIN32
A = g_NunchuckExt.LAST_CONSTANT,
#else
A = 29, A = 29,
#endif
B, X, Y, B, X, Y,
P, M, H, P, M, H,
Tl, Tr, Zl, Zr, Tl, Tr, Zl, Zr,
@ -258,12 +251,7 @@ struct KeyboardGH3GLP
{ {
enum EKeyboardGH3GLP enum EKeyboardGH3GLP
{ {
// This is not allowed in Linux so we have to set the starting value manually
#ifdef _WIN32
Green = g_ClassicContExt.LAST_CONSTANT,
#else
Green = 52, Green = 52,
#endif
Red, Yellow, Blue, Orange, Red, Yellow, Blue, Orange,
Plus, Minus, Whammy, Plus, Minus, Whammy,
Al, Ar, Au, Ad, Al, Ar, Au, Ad,

22
Source/Plugins/Plugin_Wiimote/Src/EmuDynamics.cpp
View File

@ -243,6 +243,7 @@ void PitchAccelerometerToDegree(u8 _x, u8 _y, u8 _z, int &_Roll, int &_Pitch, in
// IR data functions // IR data functions
//****************************************************************************** //******************************************************************************
/*
// Calculate dot positions from the basic 10 byte IR data // Calculate dot positions from the basic 10 byte IR data
void IRData2DotsBasic(u8 *Data) void IRData2DotsBasic(u8 *Data)
{ {
@ -260,7 +261,7 @@ void IRData2DotsBasic(u8 *Data)
Dot[3].Rx = 1023 - (Data[8] | ((Data[7] & 0x03) << 8)); Dot[3].Rx = 1023 - (Data[8] | ((Data[7] & 0x03) << 8));
Dot[3].Ry = Data[9] | ((Data[7] & 0x0c) << 6); Dot[3].Ry = Data[9] | ((Data[7] & 0x0c) << 6);
/* set each IR spot to visible if spot is in range */ // set each IR spot to visible if spot is in range
for (int i = 0; i < 4; ++i) for (int i = 0; i < 4; ++i)
{ {
if (Dot[i].Ry == 1023) if (Dot[i].Ry == 1023)
@ -270,7 +271,7 @@ void IRData2DotsBasic(u8 *Data)
else else
{ {
Dot[i].Visible = 1; Dot[i].Visible = 1;
Dot[i].Size = 0; /* since we don't know the size, set it as 0 */ Dot[i].Size = 0; // since we don't know the size, set it as 0
} }
// For now we let our virtual resolution be the same as the default one // For now we let our virtual resolution be the same as the default one
@ -281,8 +282,9 @@ void IRData2DotsBasic(u8 *Data)
ReorderIRDots(); ReorderIRDots();
IRData2Distance(); IRData2Distance();
} }
*/
/*
// Calculate dot positions from the extented 12 byte IR data // Calculate dot positions from the extented 12 byte IR data
void IRData2Dots(u8 *Data) void IRData2Dots(u8 *Data)
{ {
@ -297,7 +299,7 @@ void IRData2Dots(u8 *Data)
Dot[i].Size = Data[(3*i)+2] & 0x0f; Dot[i].Size = Data[(3*i)+2] & 0x0f;
/* if in range set to visible */ // if in range set to visible
if (Dot[i].Ry == 1023) if (Dot[i].Ry == 1023)
Dot[i].Visible = false; Dot[i].Visible = false;
else else
@ -313,8 +315,9 @@ void IRData2Dots(u8 *Data)
ReorderIRDots(); ReorderIRDots();
IRData2Distance(); IRData2Distance();
} }
*/
/*
// Reorder the IR dots according to their x-axis value // Reorder the IR dots according to their x-axis value
void ReorderIRDots() void ReorderIRDots()
{ {
@ -347,8 +350,9 @@ void ReorderIRDots()
Dot[i].Order = order; Dot[i].Order = order;
} }
} }
*/
/*
// Calculate dot positions from the extented 12 byte IR data // Calculate dot positions from the extented 12 byte IR data
void IRData2Distance() void IRData2Distance()
{ {
@ -371,15 +375,15 @@ void IRData2Distance()
// Only one dot was visible, we can not calculate the distance // Only one dot was visible, we can not calculate the distance
if (i2 == 4) { g_Wiimote_kbd.IR.Distance = 0; return; } if (i2 == 4) { g_Wiimote_kbd.IR.Distance = 0; return; }
/* For the emulated Wiimote the y distance is always zero so then the distance is the // For the emulated Wiimote the y distance is always zero so then the distance is the
simple distance between the x dots, i.e. the sensor bar width */ // simple distance between the x dots, i.e. the sensor bar width
int xd = Dot[i2].X - Dot[i1].X; int xd = Dot[i2].X - Dot[i1].X;
int yd = Dot[i2].Y - Dot[i1].Y; int yd = Dot[i2].Y - Dot[i1].Y;
// Save the distance // Save the distance
g_Wiimote_kbd.IR.Distance = (int)sqrt((float)(xd*xd) + (float)(yd*yd)); g_Wiimote_kbd.IR.Distance = (int)sqrt((float)(xd*xd) + (float)(yd*yd));
} }
*/
//****************************************************************************** //******************************************************************************
// Classic Controller functions // Classic Controller functions

43
Source/Plugins/Plugin_Wiimote/Src/EmuMain.cpp
View File

@ -374,11 +374,17 @@ void ExtensionChecksum(u8 * Calibration)
// Set initial valuesm this done both in Init and Shutdown // Set initial valuesm this done both in Init and Shutdown
void ResetVariables() void ResetVariables()
{ {
g_ReportingAuto = false; g_RefreshWiimote = 0;
g_ReportingMode = 0; g_ReportingMode = 0;
g_ReportingChannel = 0; g_ReportingChannel = 0;
g_Encryption = false; g_Encryption = false;
for (int i = 0; i < 4; i++)
{
g_ReportingAuto[i] = false;
memset(&g_WiimoteData[i], 0, sizeof(g_WiimoteData));
}
// Set default recording values // Set default recording values
#if defined(HAVE_WX) && HAVE_WX #if defined(HAVE_WX) && HAVE_WX
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
@ -469,7 +475,6 @@ void Initialize()
void DoState(PointerWrap &p) void DoState(PointerWrap &p)
{ {
// TODO: Shorten the list // TODO: Shorten the list
p.Do(g_Leds);
p.Do(g_Speaker); p.Do(g_Speaker);
p.Do(g_SpeakerVoice); p.Do(g_SpeakerVoice);
p.Do(g_IR); p.Do(g_IR);
@ -480,7 +485,6 @@ void DoState(PointerWrap &p)
p.DoArray(g_RegExtTmp, WIIMOTE_REG_EXT_SIZE); p.DoArray(g_RegExtTmp, WIIMOTE_REG_EXT_SIZE);
p.DoArray(g_RegIr, WIIMOTE_REG_IR_SIZE); p.DoArray(g_RegIr, WIIMOTE_REG_IR_SIZE);
p.Do(g_ReportingAuto);
p.Do(g_ReportingMode); p.Do(g_ReportingMode);
p.Do(g_ReportingChannel); p.Do(g_ReportingChannel);
@ -492,10 +496,16 @@ void DoState(PointerWrap &p)
//p.Do(joyinfo); //p.Do(joyinfo);
//p.DoArray(PadState, 4); //p.DoArray(PadState, 4);
//p.DoArray(PadMapping, 4); //p.DoArray(PadMapping, 4);
//p.Do(g_Wiimote_kbd); //p.Do(g_Wiimote_kbd);
//p.Do(g_NunchuckExt); //p.Do(g_NunchuckExt);
//p.Do(g_ClassicContExt); //p.Do(g_ClassicContExt);
for (int i = 0; i < 4; i++)
{
p.Do(g_ReportingAuto[i]);
p.Do(g_Leds[i]);
p.Do(g_WiimoteData[i]);
}
return; return;
} }
@ -515,8 +525,9 @@ void Shutdown()
/* This function produce Wiimote Input, i.e. reports from the Wiimote in /* This function produce Wiimote Input, i.e. reports from the Wiimote in
response to Output from the Wii. */ response to Output from the Wii. */
void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size) void InterruptChannel(int _number, u16 _channelID, const void* _pData, u32 _Size)
{ {
g_RefreshWiimote = _number;
/* Debugging. We have not yet decided how much of 'data' we will use, it's /* 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 not determined by sizeof(data). We have to determine it by looking at
the data cases. */ the data cases. */
@ -524,7 +535,7 @@ void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
hid_packet* hidp = (hid_packet*)_pData; hid_packet* hidp = (hid_packet*)_pData;
INFO_LOG(WIIMOTE, "Emu InterruptChannel (type: 0x%02x, param: 0x%02x)", hidp->type, hidp->param); INFO_LOG(WIIMOTE, "Emu InterruptChannel (page: %i, type: 0x%02x, param: 0x%02x)", _number, hidp->type, hidp->param);
switch(hidp->type) switch(hidp->type)
{ {
@ -562,11 +573,13 @@ void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
} }
void ControlChannel(u16 _channelID, const void* _pData, u32 _Size) void ControlChannel(int _number, u16 _channelID, const void* _pData, u32 _Size)
{ {
g_RefreshWiimote = _number;
hid_packet* hidp = (hid_packet*)_pData; hid_packet* hidp = (hid_packet*)_pData;
INFO_LOG(WIIMOTE, "Emu ControlChannel (type: 0x%02x, param: 0x%02x)", hidp->type, hidp->param); INFO_LOG(WIIMOTE, "Emu ControlChannel (page: %i, type: 0x%02x, param: 0x%02x)", _number, hidp->type, hidp->param);
switch(hidp->type) switch(hidp->type)
{ {
@ -586,7 +599,7 @@ void ControlChannel(u16 _channelID, const void* _pData, u32 _Size)
// (TO_BE_VERIFIED) // (TO_BE_VERIFIED)
// //
u8 handshake = 0; u8 handshake = 0;
g_WiimoteInitialize.pWiimoteInput(_channelID, &handshake, 1); g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, &handshake, 1);
PanicAlert("HID_TYPE_DATA - OUTPUT: Ambiguous Control Channel Report!"); PanicAlert("HID_TYPE_DATA - OUTPUT: Ambiguous Control Channel Report!");
} }
@ -608,13 +621,14 @@ void ControlChannel(u16 _channelID, const void* _pData, u32 _Size)
documentation. I'm not sure exactly how often this function is called but I documentation. I'm not sure exactly how often this function is called but I
think it's tied to the frame rate of the game rather than a certain amount think it's tied to the frame rate of the game rather than a certain amount
of times per second. */ of times per second. */
void Update() void Update(int _number)
{ {
if(g_ReportingAuto == false) if (g_ReportingAuto[_number] == false)
return; return;
// Read input or not g_RefreshWiimote = _number;
// Read input or not
if (g_Config.bInputActive) if (g_Config.bInputActive)
{ {
ReadLinuxKeyboard(); ReadLinuxKeyboard();
@ -626,9 +640,8 @@ void Update()
&& NumGoodPads > 0 && joyinfo.size() > (u32)PadMapping[0].ID) && NumGoodPads > 0 && joyinfo.size() > (u32)PadMapping[0].ID)
*/ */
// Check if the pad state should be updated // Check if the pad state should be updated
const int Page = 0; if (NumGoodPads > 0 && joyinfo.size() > (u32)PadMapping[g_RefreshWiimote].ID)
if (NumGoodPads > 0 && joyinfo.size() > (u32)PadMapping[Page].ID) WiiMoteEmu::GetJoyState(PadState[g_RefreshWiimote], PadMapping[g_RefreshWiimote], g_RefreshWiimote, joyinfo[PadMapping[g_RefreshWiimote].ID].NumButtons);
WiiMoteEmu::GetJoyState(PadState[Page], PadMapping[Page], Page, joyinfo[PadMapping[Page].ID].NumButtons);
} }
switch(g_ReportingMode) switch(g_ReportingMode)

10
Source/Plugins/Plugin_Wiimote/Src/EmuMain.h
View File

@ -38,9 +38,9 @@ void GetMousePos(float& x, float& y);
void Initialize(); void Initialize();
void DoState(PointerWrap &p); void DoState(PointerWrap &p);
void Shutdown(); void Shutdown();
void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size); void InterruptChannel(int _number, u16 _channelID, const void* _pData, u32 _Size);
void ControlChannel(u16 _channelID, const void* _pData, u32 _Size) ; void ControlChannel(int _number, u16 _channelID, const void* _pData, u32 _Size) ;
void Update(); void Update(int _number);
void ReadLinuxKeyboard(); void ReadLinuxKeyboard();
// Recordings // Recordings
@ -68,8 +68,8 @@ void AdjustAngles(int &Roll, int &Pitch);
void RotateIRDots(int &_x, int &_y, STiltData &_TiltData); void RotateIRDots(int &_x, int &_y, STiltData &_TiltData);
void IRData2Dots(u8 *Data); void IRData2Dots(u8 *Data);
void IRData2DotsBasic(u8 *Data); void IRData2DotsBasic(u8 *Data);
void ReorderIRDots(); //void ReorderIRDots();
void IRData2Distance(); //void IRData2Distance();
// Classic Controller data // Classic Controller data
std::string CCData2Values(u8 *Data); std::string CCData2Values(u8 *Data);

12
Source/Plugins/Plugin_Wiimote/Src/EmuSubroutines.cpp
View File

@ -164,7 +164,7 @@ void WmLeds(u16 _channelID, wm_leds* leds)
{ {
INFO_LOG(WIIMOTE, "Set LEDs: %x, Rumble: %x", leds->leds, leds->rumble); INFO_LOG(WIIMOTE, "Set LEDs: %x, Rumble: %x", leds->leds, leds->rumble);
g_Leds = leds->leds; g_Leds[g_RefreshWiimote] = leds->leds;
} }
@ -190,7 +190,7 @@ void WmSendAck(u16 _channelID, u8 _reportID)
DEBUG_LOG(WIIMOTE, "WMSendAck"); DEBUG_LOG(WIIMOTE, "WMSendAck");
DEBUG_LOG(WIIMOTE, " Report ID: %02x", _reportID); DEBUG_LOG(WIIMOTE, " Report ID: %02x", _reportID);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging // Debugging
//ReadDebugging(true, DataFrame, Offset); //ReadDebugging(true, DataFrame, Offset);
@ -360,11 +360,11 @@ void SendReadDataReply(u16 _channelID, void* _Base, u16 _Address, int _Size)
#if defined(_DEBUG) || defined(DEBUGFAST) #if defined(_DEBUG) || defined(DEBUGFAST)
std::string Temp = ArrayToString(DataFrame, Offset); std::string Temp = ArrayToString(DataFrame, Offset);
ERROR_LOG(WIIMOTE, "Data: %s", Temp.c_str()); DEBUG_LOG(WIIMOTE, "Data: %s", Temp.c_str());
#endif #endif
// Send a piece // Send a piece
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Update the size that is left // Update the size that is left
_Size -= copySize; _Size -= copySize;
@ -482,7 +482,7 @@ void WmRequestStatus(u16 _channelID, wm_request_status* rs, int Extension)
#if defined(HAVE_WX) && HAVE_WX #if defined(HAVE_WX) && HAVE_WX
FillReportInfo(pStatus->buttons); FillReportInfo(pStatus->buttons);
#endif #endif
pStatus->leds = g_Leds; // leds are 4 bit pStatus->leds = g_Leds[g_RefreshWiimote]; // leds are 4 bit
pStatus->ir = g_IR; // 1 bit pStatus->ir = g_IR; // 1 bit
pStatus->speaker = g_Speaker; // 1 bit pStatus->speaker = g_Speaker; // 1 bit
pStatus->battery_low = 0; // battery is okay pStatus->battery_low = 0; // battery is okay
@ -514,7 +514,7 @@ void WmRequestStatus(u16 _channelID, wm_request_status* rs, int Extension)
DEBUG_LOG(WIIMOTE, " Extension: %x", pStatus->extension); DEBUG_LOG(WIIMOTE, " Extension: %x", pStatus->extension);
DEBUG_LOG(WIIMOTE, " Buttons: 0x%04x", pStatus->buttons); DEBUG_LOG(WIIMOTE, " Buttons: 0x%04x", pStatus->buttons);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging // Debugging
//ReadDebugging(true, DataFrame, Offset); //ReadDebugging(true, DataFrame, Offset);

46
Source/Plugins/Plugin_Wiimote/Src/FillReport.cpp
View File

@ -686,16 +686,16 @@ void TiltWiimote(int &_x, int &_y, int &_z)
return; return;
// Select input method and return the x, y, x values // Select input method and return the x, y, x values
else if (g_Config.Tilt.TypeWM == g_Config.Tilt.KEYBOARD) else if (g_Config.Tilt.TypeWM == g_Config.Tilt.KEYBOARD)
TiltByKeyboardWM(g_Wiimote_kbd.TiltData); TiltByKeyboardWM(g_WiimoteData[g_RefreshWiimote].TiltWM);
else else
TiltByGamepad(g_Wiimote_kbd.TiltData, g_Config.Tilt.TypeWM); TiltByGamepad(g_WiimoteData[g_RefreshWiimote].TiltWM, g_Config.Tilt.TypeWM);
// Adjust angles, it's only needed if both roll and pitch is used together // Adjust angles, it's only needed if both roll and pitch is used together
if (g_Config.Tilt.Range.Roll != 0 && g_Config.Tilt.Range.Pitch != 0) if (g_Config.Tilt.Range.Roll != 0 && g_Config.Tilt.Range.Pitch != 0)
AdjustAngles(g_Wiimote_kbd.TiltData.Roll, g_Wiimote_kbd.TiltData.Pitch); AdjustAngles(g_WiimoteData[g_RefreshWiimote].TiltWM.Roll, g_WiimoteData[g_RefreshWiimote].TiltWM.Pitch);
// Calculate the accelerometer value from this tilt angle // Calculate the accelerometer value from this tilt angle
TiltToAccelerometer(_x, _y, _z, g_Wiimote_kbd.TiltData); TiltToAccelerometer(_x, _y, _z, g_WiimoteData[g_RefreshWiimote].TiltWM);
//DEBUG_LOG(WIIMOTE, "Roll:%i, Pitch:%i, _x:%u, _y:%u, _z:%u", g_Wiimote_kbd.TiltData.Roll, g_Wiimote_kbd.TiltData.Pitch, _x, _y, _z); //DEBUG_LOG(WIIMOTE, "Roll:%i, Pitch:%i, _x:%u, _y:%u, _z:%u", g_Wiimote_kbd.TiltData.Roll, g_Wiimote_kbd.TiltData.Pitch, _x, _y, _z);
} }
@ -708,16 +708,16 @@ void TiltNunchuck(int &_x, int &_y, int &_z)
return; return;
// Select input method and return the x, y, x values // Select input method and return the x, y, x values
else if (g_Config.Tilt.TypeNC == g_Config.Tilt.KEYBOARD) else if (g_Config.Tilt.TypeNC == g_Config.Tilt.KEYBOARD)
TiltByKeyboardNC(g_NunchuckExt.TiltData); TiltByKeyboardNC(g_WiimoteData[g_RefreshWiimote].TiltNC);
else else
TiltByGamepad(g_NunchuckExt.TiltData, g_Config.Tilt.TypeNC); TiltByGamepad(g_WiimoteData[g_RefreshWiimote].TiltNC, g_Config.Tilt.TypeNC);
// Adjust angles, it's only needed if both roll and pitch is used together // Adjust angles, it's only needed if both roll and pitch is used together
if (g_Config.Tilt.Range.Roll != 0 && g_Config.Tilt.Range.Pitch != 0) if (g_Config.Tilt.Range.Roll != 0 && g_Config.Tilt.Range.Pitch != 0)
AdjustAngles(g_NunchuckExt.TiltData.Roll, g_NunchuckExt.TiltData.Pitch); AdjustAngles(g_WiimoteData[g_RefreshWiimote].TiltNC.Roll, g_WiimoteData[g_RefreshWiimote].TiltNC.Pitch);
// Calculate the accelerometer value from this tilt angle // Calculate the accelerometer value from this tilt angle
TiltToAccelerometer(_x, _y, _z, g_NunchuckExt.TiltData); TiltToAccelerometer(_x, _y, _z, g_WiimoteData[g_RefreshWiimote].TiltNC);
//DEBUG_LOG(WIIMOTE, "Roll:%i, Pitch:%i, _x:%u, _y:%u, _z:%u", g_NunchuckExt.TiltData.Roll, g_NunchuckExt.TiltData.Pitch, _x, _y, _z); //DEBUG_LOG(WIIMOTE, "Roll:%i, Pitch:%i, _x:%u, _y:%u, _z:%u", g_NunchuckExt.TiltData.Roll, g_NunchuckExt.TiltData.Pitch, _x, _y, _z);
} }
@ -745,11 +745,11 @@ void FillReportAcc(wm_accel& _acc)
// Adjust position, also add some noise to prevent disconnection // Adjust position, also add some noise to prevent disconnection
if (!g_Config.bUpright) if (!g_Config.bUpright)
_acc.z += g_wm.cal_g.z + g_Wiimote_kbd.TiltData.FakeNoise; _acc.z += g_wm.cal_g.z + g_WiimoteData[g_RefreshWiimote].TiltWM.FakeNoise;
else // Upright wiimote else // Upright wiimote
_acc.y -= g_wm.cal_g.y + g_Wiimote_kbd.TiltData.FakeNoise; _acc.y -= g_wm.cal_g.y + g_WiimoteData[g_RefreshWiimote].TiltWM.FakeNoise;
g_Wiimote_kbd.TiltData.FakeNoise = -g_Wiimote_kbd.TiltData.FakeNoise; g_WiimoteData[g_RefreshWiimote].TiltWM.FakeNoise = -g_WiimoteData[g_RefreshWiimote].TiltWM.FakeNoise;
if (IsFocus()) if (IsFocus())
{ {
@ -757,14 +757,14 @@ void FillReportAcc(wm_accel& _acc)
int acc_y = _acc.y; int acc_y = _acc.y;
int acc_z = _acc.z; int acc_z = _acc.z;
if (IsKey(g_Wiimote_kbd.SHAKE) && g_Wiimote_kbd.TiltData.Shake == 0) if (IsKey(g_Wiimote_kbd.SHAKE) && g_WiimoteData[g_RefreshWiimote].TiltWM.Shake == 0)
g_Wiimote_kbd.TiltData.Shake = 1; g_WiimoteData[g_RefreshWiimote].TiltWM.Shake = 1;
// Step the shake simulation one step // Step the shake simulation one step
ShakeToAccelerometer(acc_x, acc_y, acc_z, g_Wiimote_kbd.TiltData); ShakeToAccelerometer(acc_x, acc_y, acc_z, g_WiimoteData[g_RefreshWiimote].TiltWM);
// Tilt Wiimote, allow the shake function to interrupt it // Tilt Wiimote, allow the shake function to interrupt it
if (g_Wiimote_kbd.TiltData.Shake == 0) if (g_WiimoteData[g_RefreshWiimote].TiltWM.Shake == 0)
TiltWiimote(acc_x, acc_y, acc_z); TiltWiimote(acc_x, acc_y, acc_z);
// Boundary check // Boundary check
@ -916,8 +916,8 @@ void FillReportIR(wm_ir_extended& _ir0, wm_ir_extended& _ir1)
int x0 = 1023 - g_Config.iIRLeft - g_Config.iIRWidth * MouseX - SENSOR_BAR_WIDTH / 2; int x0 = 1023 - g_Config.iIRLeft - g_Config.iIRWidth * MouseX - SENSOR_BAR_WIDTH / 2;
int x1 = x0 + SENSOR_BAR_WIDTH; int x1 = x0 + SENSOR_BAR_WIDTH;
RotateIRDot(x0, y0, g_Wiimote_kbd.TiltData); RotateIRDot(x0, y0, g_WiimoteData[g_RefreshWiimote].TiltWM);
RotateIRDot(x1, y1, g_Wiimote_kbd.TiltData); RotateIRDot(x1, y1, g_WiimoteData[g_RefreshWiimote].TiltWM);
// Converted to IR data // Converted to IR data
_ir0.x = x0 & 0xff; _ir0.xHi = x0 >> 8; _ir0.x = x0 & 0xff; _ir0.xHi = x0 >> 8;
@ -993,8 +993,8 @@ void FillReportIRBasic(wm_ir_basic& _ir0, wm_ir_basic& _ir1)
int x1 = 1023 - g_Config.iIRLeft - g_Config.iIRWidth * MouseX - SENSOR_BAR_WIDTH / 2; int x1 = 1023 - g_Config.iIRLeft - g_Config.iIRWidth * MouseX - SENSOR_BAR_WIDTH / 2;
int x2 = x1 + SENSOR_BAR_WIDTH; int x2 = x1 + SENSOR_BAR_WIDTH;
RotateIRDot(x1, y1, g_Wiimote_kbd.TiltData); RotateIRDot(x1, y1, g_WiimoteData[g_RefreshWiimote].TiltWM);
RotateIRDot(x2, y2, g_Wiimote_kbd.TiltData); RotateIRDot(x2, y2, g_WiimoteData[g_RefreshWiimote].TiltWM);
/* As with the extented report we settle with emulating two out of four /* As with the extented report we settle with emulating two out of four
possible objects the only difference is that we don't report any size of possible objects the only difference is that we don't report any size of
@ -1082,14 +1082,14 @@ if (IsFocus())
int acc_y = _ext.ay; int acc_y = _ext.ay;
int acc_z = _ext.az; int acc_z = _ext.az;
if (IsKey(g_NunchuckExt.SHAKE) && g_NunchuckExt.TiltData.Shake == 0) if (IsKey(g_NunchuckExt.SHAKE) && g_WiimoteData[g_RefreshWiimote].TiltNC.Shake == 0)
g_NunchuckExt.TiltData.Shake = 1; g_WiimoteData[g_RefreshWiimote].TiltNC.Shake = 1;
// Step the shake simulation one step // Step the shake simulation one step
ShakeToAccelerometer(acc_x, acc_y, acc_z, g_NunchuckExt.TiltData); ShakeToAccelerometer(acc_x, acc_y, acc_z, g_WiimoteData[g_RefreshWiimote].TiltNC);
// Tilt Nunchuck, allow the shake function to interrupt it // Tilt Nunchuck, allow the shake function to interrupt it
if (g_NunchuckExt.TiltData.Shake == 0) if (g_WiimoteData[g_RefreshWiimote].TiltNC.Shake == 0)
TiltNunchuck(acc_x, acc_y, acc_z); TiltNunchuck(acc_x, acc_y, acc_z);
// Boundary check // Boundary check

39
Source/Plugins/Plugin_Wiimote/Src/main.cpp
View File

@ -305,7 +305,7 @@ void DoState(unsigned char **ptr, int mode)
Switch between real and emulated wiimote: We send all this Input to WiiMoteEmu::InterruptChannel() Switch between real and emulated wiimote: We send all this Input to WiiMoteEmu::InterruptChannel()
so that it knows the channel ID and the data reporting mode at all times. so that it knows the channel ID and the data reporting mode at all times.
*/ */
void Wiimote_InterruptChannel(u16 _channelID, const void* _pData, u32 _Size) void Wiimote_InterruptChannel(int _number, u16 _channelID, const void* _pData, u32 _Size)
{ {
const u8* data = (const u8*)_pData; const u8* data = (const u8*)_pData;
@ -319,17 +319,17 @@ void Wiimote_InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
// Decice where to send the message // Decice where to send the message
if (!g_Config.bUseRealWiimote || !g_RealWiiMotePresent) if (!g_Config.bUseRealWiimote || !g_RealWiiMotePresent)
WiiMoteEmu::InterruptChannel(_channelID, _pData, _Size); WiiMoteEmu::InterruptChannel(_number, _channelID, _pData, _Size);
#if HAVE_WIIUSE #if HAVE_WIIUSE
else if (g_RealWiiMotePresent) else if (g_RealWiiMotePresent)
WiiMoteReal::InterruptChannel(_channelID, _pData, _Size); WiiMoteReal::InterruptChannel(_channelID, _pData, _Size); // TODO: Multi-Wiimote
#endif #endif
} }
// Function: Used for the initial Bluetooth HID handshake. // Function: Used for the initial Bluetooth HID handshake.
void Wiimote_ControlChannel(u16 _channelID, const void* _pData, u32 _Size) void Wiimote_ControlChannel(int _number, u16 _channelID, const void* _pData, u32 _Size)
{ {
const u8* data = (const u8*)_pData; const u8* data = (const u8*)_pData;
@ -354,17 +354,17 @@ void Wiimote_ControlChannel(u16 _channelID, const void* _pData, u32 _Size)
} }
if (!g_Config.bUseRealWiimote || !g_RealWiiMotePresent) if (!g_Config.bUseRealWiimote || !g_RealWiiMotePresent)
WiiMoteEmu::ControlChannel(_channelID, _pData, _Size); WiiMoteEmu::ControlChannel(_number, _channelID, _pData, _Size);
#if HAVE_WIIUSE #if HAVE_WIIUSE
else if (g_RealWiiMotePresent) else if (g_RealWiiMotePresent)
WiiMoteReal::ControlChannel(_channelID, _pData, _Size); WiiMoteReal::ControlChannel(_channelID, _pData, _Size); // TODO: Multi-Wiimote
#endif #endif
} }
/* This sends a Data Report from the Wiimote. See SystemTimers.cpp for the documentation of this /* This sends a Data Report from the Wiimote. See SystemTimers.cpp for the documentation of this
update. */ update. */
void Wiimote_Update() void Wiimote_Update(int _number)
{ {
// Tell us about the update rate, but only about once every second to avoid a major slowdown // Tell us about the update rate, but only about once every second to avoid a major slowdown
#if defined(HAVE_WX) && HAVE_WX #if defined(HAVE_WX) && HAVE_WX
@ -384,10 +384,10 @@ void Wiimote_Update()
// Emulated Wiimote: Only data reports 0x30-0x37 // Emulated Wiimote: Only data reports 0x30-0x37
// Real Wiimote: Both data reports 0x30-0x37 and all other read reports // Real Wiimote: Both data reports 0x30-0x37 and all other read reports
if (!g_Config.bUseRealWiimote || !g_RealWiiMotePresent) if (!g_Config.bUseRealWiimote || !g_RealWiiMotePresent)
WiiMoteEmu::Update(); WiiMoteEmu::Update(_number);
#if HAVE_WIIUSE #if HAVE_WIIUSE
else if (g_RealWiiMotePresent) else if (g_RealWiiMotePresent)
WiiMoteReal::Update(); WiiMoteReal::Update(); // TODO: Multi-Wiimote
#endif #endif
// Debugging // Debugging
@ -445,7 +445,7 @@ void DisableExtensions()
g_Config.iExtensionConnected = EXT_NONE; g_Config.iExtensionConnected = EXT_NONE;
} }
/*
void ReadDebugging(bool Emu, const void* _pData, int Size) void ReadDebugging(bool Emu, const void* _pData, int Size)
{ {
// //
@ -484,8 +484,8 @@ void ReadDebugging(bool Emu, const void* _pData, int Size)
//(pStatus->leds >> 3), //(pStatus->leds >> 3),
pStatus->battery_low pStatus->battery_low
); );
/* Update the global (for both the real and emulated) extension settings from whatever // Update the global (for both the real and emulated) extension settings from whatever
the real Wiimote use. We will enable the extension from the 0x21 report. */ // the real Wiimote use. We will enable the extension from the 0x21 report.
if(!Emu && !pStatus->extension) if(!Emu && !pStatus->extension)
{ {
DisableExtensions(); DisableExtensions();
@ -518,8 +518,8 @@ void ReadDebugging(bool Emu, const void* _pData, int Size)
wiimote_decrypt(&WiiMoteEmu::g_ExtKey, &data[0x07], 0x02, (data[4] >> 0x04) + 1); wiimote_decrypt(&WiiMoteEmu::g_ExtKey, &data[0x07], 0x02, (data[4] >> 0x04) + 1);
} }
/* Update the global extension settings. Enable the emulated extension from reading // Update the global extension settings. Enable the emulated extension from reading
what the real Wiimote has connected. To keep the emulated and real Wiimote in sync. */ // what the real Wiimote has connected. To keep the emulated and real Wiimote in sync.
if(data[4] == 0x10) if(data[4] == 0x10)
{ {
if (!Emu) DisableExtensions(); if (!Emu) DisableExtensions();
@ -553,9 +553,9 @@ void ReadDebugging(bool Emu, const void* _pData, int Size)
} }
// Show the Wiimote neutral values // Show the Wiimote neutral values
/* The only difference between the Nunchuck and Wiimote that we go // The only difference between the Nunchuck and Wiimote that we go
after is calibration here is the offset in memory. If needed we can // after is calibration here is the offset in memory. If needed we can
check the preceding 0x17 request to. */ // check the preceding 0x17 request to.
if(data[4] == 0xf0 && data[5] == 0x00 && data[6] == 0x10) if(data[4] == 0xf0 && data[5] == 0x00 && data[6] == 0x10)
{ {
if(data[6] == 0x10) if(data[6] == 0x10)
@ -763,7 +763,6 @@ void ReadDebugging(bool Emu, const void* _pData, int Size)
// --------------------------------------------- // ---------------------------------------------
// Test the angles to x, y, z values formula by calculating the values back and forth // Test the angles to x, y, z values formula by calculating the values back and forth
// ----------- // -----------
/*
ConsoleListener* Console = LogManager::GetInstance()->getConsoleListener(); ConsoleListener* Console = LogManager::GetInstance()->getConsoleListener();
Console->ClearScreen(); Console->ClearScreen();
// Show a test of our calculations // Show a test of our calculations
@ -771,7 +770,7 @@ void ReadDebugging(bool Emu, const void* _pData, int Size)
u8 x, y, z; u8 x, y, z;
//WiiMoteEmu::Tilt(x, y, z); //WiiMoteEmu::Tilt(x, y, z);
//WiiMoteEmu::TiltTest(x, y, z); //WiiMoteEmu::TiltTest(x, y, z);
*/
// ------------------------- // -------------------------
// --------------------------------------------- // ---------------------------------------------
@ -825,7 +824,7 @@ void ReadDebugging(bool Emu, const void* _pData, int Size)
DEBUG_LOG(WIIMOTE, "Accel x, y, z: %03u %03u %03u", data[4], data[5], data[6]); DEBUG_LOG(WIIMOTE, "Accel x, y, z: %03u %03u %03u", data[4], data[5], data[6]);
} }
} }
*/
void InterruptDebugging(bool Emu, const void* _pData) void InterruptDebugging(bool Emu, const void* _pData)
{ {

2
Source/Plugins/Plugin_Wiimote/Src/wiimote_hid.h
View File

@ -25,6 +25,8 @@
#endif #endif
#pragma pack(push, 1) #pragma pack(push, 1)
#define MAX_WIIMOTES 2
// Source: HID_010_SPC_PFL/1.0 (official HID specification) // Source: HID_010_SPC_PFL/1.0 (official HID specification)
struct hid_packet { struct hid_packet {

2
Source/Plugins/Plugin_Wiimote/Src/wiimote_real.cpp
View File

@ -235,7 +235,7 @@ void SendEvent(SEvent& _rEvent)
Offset += sizeof(_rEvent.m_PayLoad); Offset += sizeof(_rEvent.m_PayLoad);
// Send it // Send it
g_WiimoteInitialize.pWiimoteInput(m_channelID, Buffer, Offset); g_WiimoteInitialize.pWiimoteInput(0, m_channelID, Buffer, Offset); // TODO: Multi-Wiimote
// Debugging // Debugging
// ReadDebugging(false, Buffer, Offset); // ReadDebugging(false, Buffer, Offset);

2
Source/Plugins/Plugin_Wiimote/Src/wiimote_real.h
View File

@ -26,8 +26,6 @@
namespace WiiMoteReal namespace WiiMoteReal
{ {
#define MAX_WIIMOTES 1
int Initialize(); int Initialize();
void DoState(PointerWrap &p); void DoState(PointerWrap &p);
void Shutdown(void); void Shutdown(void);

1
Source/Plugins/Plugin_nJoy_SDL/Src/GUI/ConfigJoypad.cpp
View File

@ -119,6 +119,7 @@ void PADConfigDialognJoy::SaveButtonMapping(int controller, bool DontChangeId, i
// Set other settings // Set other settings
if(!DontChangeId) PadMapping[controller].ID = m_Joyname[FromSlot]->GetSelection(); if(!DontChangeId) PadMapping[controller].ID = m_Joyname[FromSlot]->GetSelection();
PadMapping[controller].enable = m_Enable[FromSlot]->IsChecked();
PadMapping[controller].controllertype = m_ControlType[FromSlot]->GetSelection(); PadMapping[controller].controllertype = m_ControlType[FromSlot]->GetSelection();
PadMapping[controller].triggertype = m_TriggerType[FromSlot]->GetSelection(); PadMapping[controller].triggertype = m_TriggerType[FromSlot]->GetSelection();
PadMapping[controller].deadzone = m_Deadzone[FromSlot]->GetSelection(); PadMapping[controller].deadzone = m_Deadzone[FromSlot]->GetSelection();

5
Source/Plugins/Plugin_nJoy_SDL/Src/nJoy.cpp
View File

@ -259,6 +259,9 @@ void PAD_Input(u16 _Key, u8 _UpDown)
// Check if the keys are interesting, and then update it // Check if the keys are interesting, and then update it
for(int i = 0; i < 4; i++) for(int i = 0; i < 4; i++)
{ {
if (!PadMapping[i].enable)
continue;
for(int j = InputCommon::CTL_L_SHOULDER; j <= InputCommon::CTL_START; j++) for(int j = InputCommon::CTL_L_SHOULDER; j <= InputCommon::CTL_START; j++)
{ {
if (PadMapping[i].buttons[j] == _Key) if (PadMapping[i].buttons[j] == _Key)
@ -292,7 +295,7 @@ void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
{ {
// Check if the pad is avaliable, currently we don't disable pads just because they are // Check if the pad is avaliable, currently we don't disable pads just because they are
// disconnected // disconnected
if (!PadState[_numPAD].joy || !PadMapping[_numPAD].enable) if (!PadState[_numPAD].joy)
return; return;
// Clear pad status // Clear pad status