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
// If you like better sound than speed, feel free to implement the up-sampling code
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

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

@ -24,9 +24,9 @@
namespace Common {
typedef unsigned int (__cdecl* TPAD_GetAttachedPads)();
typedef void (__cdecl* TWiimote_Update)();
typedef void (__cdecl* TWiimote_Output)(u16 _channelID, const void* _pData, u32 _Size);
typedef void (__cdecl* TWiimote_Input)(u16 _channelID, const void* _pData, u32 _Size);
typedef void (__cdecl* TWiimote_Update)(int _number);
typedef void (__cdecl* TWiimote_Output)(int _number, 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)();
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_PADLog(const TCHAR* _szMessage);
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.
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)
{
ERROR_LOG(WII_IPC_STM, "STM immediate: Open");
INFO_LOG(WII_IPC_STM, "STM immediate: Open");
Memory::Write_U32(GetDeviceID(), _CommandAddress+4);
m_Active = true;
return true;
@ -62,7 +62,7 @@ public:
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)
Memory::Write_U32(0, _CommandAddress+4);
m_Active = false;

188
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_ACLPool(0)
, m_LastCmd(0)
, m_PacketCount(0)
, m_FreqDividerSync(0)
, m_FreqDividerMote(0)
{
// Connect one Wiimote by default
m_WiiMotes.push_back(CWII_IPC_HLE_WiiMote(this, 0));
// Activate the first one Wiimote by default
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:
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;
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);
}
@ -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)
{
p.Do(m_LastCmd);
p.Do(m_PacketCount);
p.Do(m_CtrlSetup);
p.Do(m_HCIBuffer);
p.Do(m_HCIPool);
p.Do(m_ACLBuffer);
p.Do(m_ACLPool);
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_LastCmd = 0;
m_PacketCount = 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_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);
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
// 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)
return;
INFO_LOG(WII_IPC_WIIMOTE, "++++++++++++++++++++++++++++++++++++++");
INFO_LOG(WII_IPC_WIIMOTE, "Execute ACL Command: ConnectionHandle 0x%04x", _ConnectionHandle);
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)
{
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);
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_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)");
PanicAlert("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!");
}
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
{
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->BCFlag = 0;
pHeader->PBFlag = 2;
@ -378,8 +385,8 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::PurgeACLPool()
{
m_ACLPool.m_number--;
// Fill the buffer
u8* _Address = m_ACLPool.m_data + m_ACLPool.m_number * 64;
memcpy(Memory::GetPointer(m_ACLBuffer.m_buffer), _Address, 64);
u8* _Address = m_ACLPool.m_data + m_ACLPool.m_number * ACL_MAX_SIZE;
memcpy(Memory::GetPointer(m_ACLBuffer.m_buffer), _Address, ACL_MAX_SIZE);
// Write the packet size as return value
Memory::Write_U32(sizeof(UACLHeader) + ((UACLHeader*)_Address)->Size, m_ACLBuffer.m_address + 0x4);
// 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()
{
// Check if HCI Pool is not purged
if (m_HCIPool.m_number > 0)
{
@ -440,14 +446,16 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
{
counter--;
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);
// Create ACL connection
SendEventRequestConnection(m_WiiMotes[i]);
return true;
}
}
}
// AyuanX: Actually we don't need to link channels so early
@ -457,7 +465,7 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
// But ... whatever, either way works
//
// 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++)
{
@ -469,14 +477,17 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
// The Real Wiimote sends report at a fixed frequency of 100Hz
// So let's make it also 100Hz here
// 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++;
if(m_FreqDividerMote >= 150)
for (unsigned int i = 0; i < m_WiiMotes.size(); i++)
{
m_FreqDividerMote = 0;
CPluginManager::GetInstance().GetWiimote(0)->Wiimote_Update();
return true;
m_FreqDividerMote[i]++;
if (m_WiiMotes[i].IsLinked() && m_FreqDividerMote[i] >= 150)
{
m_FreqDividerMote[i] = 0;
CPluginManager::GetInstance().GetWiimote(0)->Wiimote_Update(i);
return true;
}
}
}
@ -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())
{
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;
SendEventNumberOfCompletedPackets(m_WiiMotes[0].GetConnectionHandle(), m_PacketCount);
m_PacketCount = 0;
SendEventNumberOfCompletedPackets();
memset(m_PacketCount, 0, sizeof(m_PacketCount));
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_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)");
PanicAlert("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!");
}
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
{
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
m_HCIPool.m_size[m_HCIPool.m_number] = _event.m_size;
m_HCIPool.m_number++;
@ -636,7 +647,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventInquiryResponse()
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);
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->Status = 0x00;
pConnectionComplete->Connection_Handle = pWiiMote->GetConnectionHandle();
pConnectionComplete->bdaddr = pWiiMote->GetBD();
pConnectionComplete->bdaddr = _bd;
pConnectionComplete->LinkType = HCI_LINK_ACL;
pConnectionComplete->EncryptionEnabled = HCI_ENCRYPTION_MODE_NONE;
AddEventToQueue(Event);
CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(_bd);
if (pWiimote)
pWiimote->EventConnectionAccepted();
#if MAX_LOGLEVEL >= DEBUG_LEVEL
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. */
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);
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->LinkType = HCI_LINK_ACL;
AddEventToQueue(Event);
// Log
#if MAX_LOGLEVEL >= DEBUG_LEVEL
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, " LinkType: %s", LinkType[pEventRequestConnection->LinkType]);
AddEventToQueue(Event);
return true;
}
@ -771,7 +775,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventAuthenticationCompleted(u16 _
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);
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->PayloadLength = sizeof(SHCIEventRemoteNameReq) - 2;
pRemoteNameReq->Status = 0x00;
pRemoteNameReq->bdaddr = pWiiMote->GetBD();
pRemoteNameReq->bdaddr = _bd;
strcpy((char*)pRemoteNameReq->RemoteName, pWiiMote->GetName());
AddEventToQueue(Event);
@ -807,10 +811,8 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventReadRemoteFeatures(u16 _conne
SQueuedEvent Event(sizeof(SHCIEventReadRemoteFeatures), _connectionHandle);
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
// try it and see :)
pReadRemoteFeatures->EventType = 0x0c; //HCI_EVENT_READ_REMOTE_FEATURES_COMPL;
pReadRemoteFeatures->EventType = HCI_EVENT_READ_REMOTE_FEATURES_COMPL;
pReadRemoteFeatures->PayloadLength = sizeof(SHCIEventReadRemoteFeatures) - 2;
pReadRemoteFeatures->Status = 0x00;
pReadRemoteFeatures->ConnectionHandle = pWiiMote->GetConnectionHandle();
@ -955,25 +957,29 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRoleChange(bdaddr_t _bd, bool
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);
if (pWiiMote == NULL)
int Num = m_WiiMotes.size();
if (Num == NULL)
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;
pNumberOfCompletedPackets->EventType = HCI_EVENT_NUM_COMPL_PKTS;
pNumberOfCompletedPackets->PayloadLength = sizeof(SHCIEventNumberOfCompletedPackets) - 2;
pNumberOfCompletedPackets->NumberOfHandles = 1;
pNumberOfCompletedPackets->Connection_Handle = _connectionHandle;
pNumberOfCompletedPackets->Number_Of_Completed_Packets = _count;
pNumberOfCompletedPackets->PayloadLength = sizeof(SHCIEventNumberOfCompletedPackets) + Num * 4 - 2;
pNumberOfCompletedPackets->NumberOfHandles = Num;
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
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventNumberOfCompletedPackets");
DEBUG_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x", pNumberOfCompletedPackets->Connection_Handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " Number_Of_Completed_Packets: %i", pNumberOfCompletedPackets->Number_Of_Completed_Packets);
DEBUG_LOG(WII_IPC_WIIMOTE, " NumberOfConnectionHandle: 0x%04x", pNumberOfCompletedPackets->NumberOfHandles);
AddEventToQueue(Event);
@ -1032,7 +1038,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventLinkKeyNotification(const CWI
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);
@ -1042,13 +1048,13 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestLinkKey(bdaddr_t _bd)
pEventRequestLinkKey->PayloadLength = sizeof(SHCIEventRequestLinkKey) - 2;
pEventRequestLinkKey->bdaddr = _bd;
AddEventToQueue(Event);
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventRequestLinkKey");
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[3], pEventRequestLinkKey->bdaddr.b[4], pEventRequestLinkKey->bdaddr.b[5]);
AddEventToQueue(Event);
return true;
};
@ -1121,7 +1127,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::ExecuteHCICommandMessage(const SHCICom
if(m_LastCmd == NULL)
{
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)
@ -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;
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, " 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;
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);
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;
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",
pRemoteNameReq->bdaddr.b[0], pRemoteNameReq->bdaddr.b[1], pRemoteNameReq->bdaddr.b[2],
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;
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);
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;
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);
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;
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);
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;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_SNIFF_MODE");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pSniffMode->con_handle);
INFO_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, " min_interval: 0x%04x", pSniffMode->min_interval);
DEBUG_LOG(WII_IPC_WIIMOTE, " attempt: 0x%04x", pSniffMode->attempt);
DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: 0x%04x", pSniffMode->timeout);
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)
{
if(SendEventCommandStatus(HCI_CMD_WRITE_LINK_POLICY_SETTINGS))
return;
// command parameters
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");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pLinkPolicy->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " Policy: 0x%04x", pLinkPolicy->settings);
CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(pLinkPolicy->con_handle);
if (pWiimote)
{
pWiimote->EventCommandWriteLinkPolicy();
}
hci_write_link_policy_settings_rp Reply;
Reply.status = 0x00;
Reply.con_handle = pLinkPolicy->con_handle;
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)
@ -1660,7 +1664,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandSetEventFilter(u8* _Input)
Reply.status = 0x00;
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_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;
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);
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;
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",
pDeleteStoredLinkKey->bdaddr.b[0], pDeleteStoredLinkKey->bdaddr.b[1], pDeleteStoredLinkKey->bdaddr.b[2],
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;
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);
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;
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);
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
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]);
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;
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[1]: 0x%02x", pWriteUnitClass->uclass[1]);
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;
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_sco_size: %i", pHostBufferSize->max_sco_size);
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
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");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_LINK_SUPERVISION_TIMEOUT");
DEBUG_LOG(WII_IPC_WIIMOTE, " con_handle: 0x%04x", pSuperVision->con_handle);
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.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)
@ -1894,7 +1893,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryScanType(u8* _Input
Reply.status = 0x00;
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);
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
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]);
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
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]);
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_WiiMote.h"
#define HCI_MAX_SIZE 128
#define ACL_MAX_SIZE 128
union UACLHeader
{
@ -129,7 +131,7 @@ private:
struct ACLPool
{
u32 m_number;
u8 m_data[1024]; // Capacity: 64B x 16
u8 m_data[ACL_MAX_SIZE * 16];
ACLPool(int num)
: m_number(num)
@ -140,7 +142,7 @@ private:
struct HCIPool
{
u32 m_number;
u8 m_data[1024]; // Capacity: 64B x 16
u8 m_data[HCI_MAX_SIZE * 16];
u8 m_size[16];
HCIPool(int num)
@ -191,9 +193,9 @@ private:
CtrlBuffer m_ACLBuffer;
ACLPool m_ACLPool;
u32 m_LastCmd;
int m_PacketCount;
u32 m_PacketCount[4];
u32 m_FreqDividerMote[4];
u32 m_FreqDividerSync;
u32 m_FreqDividerMote;
// Events
void AddEventToQueue(const SQueuedEvent& _event);
@ -201,19 +203,19 @@ private:
void SendEventCommandComplete(u16 _OpCode, void* _pData, u32 _DataSize);
bool SendEventInquiryResponse();
bool SendEventInquiryComplete();
bool SendEventRemoteNameReq(bdaddr_t _bd);
bool SendEventRemoteNameReq(const bdaddr_t& _bd);
bool SendEventRequestConnection(CWII_IPC_HLE_WiiMote& _rWiiMote);
bool SendEventConnectionComplete(bdaddr_t _bd);
bool SendEventConnectionComplete(const bdaddr_t& _bd);
bool SendEventReadClockOffsetComplete(u16 _connectionHandle);
bool SendEventConPacketTypeChange(u16 _connectionHandle, u16 _packetType);
bool SendEventReadRemoteVerInfo(u16 _connectionHandle);
bool SendEventReadRemoteFeatures(u16 _connectionHandle);
bool SendEventRoleChange(bdaddr_t _bd, bool _master);
bool SendEventNumberOfCompletedPackets(u16 _connectionHandle, u16 _count);
bool SendEventNumberOfCompletedPackets();
bool SendEventAuthenticationCompleted(u16 _connectionHandle);
bool SendEventModeChange(u16 _connectionHandle, u8 _mode, u16 _value);
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);
// Execute HCI Message

169
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;
CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305* _pHost, int _Number)
: m_Connected(false)
, m_Linked(false)
CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305* _pHost, int _Number, bool ready)
: m_Linked(false)
, m_HIDControlChannel_Connected(false)
, m_HIDControlChannel_ConnectedWait(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);
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[1] = 0x02;
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[5] = _Number;
m_ControllerConnectionHandle = 0x100 + _Number;
uclass[0]= 0x00;
uclass[1]= 0x04;
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_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()
{
if ((m_Connected == false) || (m_Linked == true))
if ((m_Connected <= 0) || (m_Linked == true))
return false;
// try to connect HID_CONTROL_CHANNEL
@ -102,7 +102,6 @@ bool CWII_IPC_HLE_WiiMote::LinkChannel()
return false;
m_HIDControlChannel_ConnectedWait = true;
// The CID is fixed, other CID will be rejected
SendConnectionRequest(0x0040, HID_CONTROL_CHANNEL);
return true;
}
@ -113,10 +112,8 @@ bool CWII_IPC_HLE_WiiMote::LinkChannel()
if (m_HIDControlChannel_ConfigWait)
return false;
SChannel& rChannel = m_Channel[0x0040];
m_HIDControlChannel_ConfigWait = true;
SendConfigurationRequest(rChannel.DCID);
SendConfigurationRequest(0x0040);
return true;
}
@ -127,7 +124,6 @@ bool CWII_IPC_HLE_WiiMote::LinkChannel()
return false;
m_HIDInterruptChannel_ConnectedWait = true;
// The CID is fixed, other CID will be rejected
SendConnectionRequest(0x0041, HID_INTERRUPT_CHANNEL);
return true;
}
@ -139,9 +135,7 @@ bool CWII_IPC_HLE_WiiMote::LinkChannel()
return false;
m_HIDInterruptChannel_ConfigWait = true;
SChannel& rChannel = m_Channel[0x0041];
SendConfigurationRequest(rChannel.DCID);
SendConfigurationRequest(0x0041);
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()
{
m_Connected = true;
m_Connected = 1;
m_Linked = false;
}
void CWII_IPC_HLE_WiiMote::EventDisconnect()
{
m_Connected = false;
m_Connected = 0;
m_Linked = false;
// Clear channel flags
EventCommandWriteLinkPolicy();
ResetChannels();
}
bool CWII_IPC_HLE_WiiMote::EventPagingChanged(u8 _pageMode)
{
if (m_Connected)
if (m_Connected != 0)
return false;
if ((_pageMode & 2) == 0)
if ((_pageMode & 0x2) == 0)
return false;
m_Connected = -1;
return true;
}
void CWII_IPC_HLE_WiiMote::EventCommandWriteLinkPolicy()
void CWII_IPC_HLE_WiiMote::ResetChannels()
{
// reset connection process
m_HIDControlChannel_Connected = false;
m_HIDControlChannel_Config = 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;
u8* pData = _pData + sizeof(SL2CAP_Header);
u32 DataSize = _Size - sizeof(SL2CAP_Header);
INFO_LOG(WII_IPC_WIIMOTE, "++++++++++++++++++++++++++++++++++++++");
INFO_LOG(WII_IPC_WIIMOTE, "Execute L2CAP Command: Cid 0x%04x, Len 0x%x, DataSize 0x%x", pHeader->CID, pHeader->Length, DataSize);
INFO_LOG(WII_IPC_WIIMOTE, " CID 0x%04x, Len 0x%x, DataSize 0x%x", pHeader->CID, pHeader->Length, DataSize);
if(pHeader->Length != DataSize)
{
@ -322,13 +321,13 @@ void CWII_IPC_HLE_WiiMote::ExecuteL2capCmd(u8* _pData, u32 _Size)
break;
case HID_CONTROL_CHANNEL:
mote->Wiimote_ControlChannel(rChannel.DCID, pData, DataSize);
mote->Wiimote_ControlChannel(m_ConnectionHandle & 0x1, pHeader->CID, pData, DataSize);
// Call Wiimote Plugin
break;
case HID_INTERRUPT_CHANNEL:
ShowStatus(pData);
mote->Wiimote_InterruptChannel(rChannel.DCID, pData, DataSize);
mote->Wiimote_InterruptChannel(m_ConnectionHandle & 0x1, pHeader->CID, pData, DataSize);
// Call Wiimote Plugin
break;
@ -415,7 +414,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConnectionReq(u8 _Ident, u8* _pData, u32 _Size
rChannel.SCID = 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, " PSM: 0x%04x", rChannel.PSM);
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.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);
}
@ -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));
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, " SCID: 0x%04x", rsp->scid);
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];
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, " DCID: 0x%04x", pCommandConfigReq->dcid);
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);
SL2CAP_OptionsMTU* pMTU = (SL2CAP_OptionsMTU*)&_pData[Offset];
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
// This means that we only need temp_frame_size of 640B instead 1024B
// 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);
SL2CAP_OptionsFlushTimeOut* pFlushTimeOut = (SL2CAP_OptionsFlushTimeOut*)&_pData[Offset];
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;
@ -535,14 +534,13 @@ void CWII_IPC_HLE_WiiMote::ReceiveConfigurationReq(u8 _Ident, u8* _pData, u32 _S
RespLen += OptionSize;
}
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] SendConfigurationResponse");
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConfigurationResponse");
SendCommandToACL(_Ident, L2CAP_CONF_RSP, RespLen, TempBuffer);
// update state machine
if (rChannel.PSM == HID_CONTROL_CHANNEL)
m_HIDControlChannel_Connected = true;
if (rChannel.PSM == HID_INTERRUPT_CHANNEL)
else if (rChannel.PSM == HID_INTERRUPT_CHANNEL)
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;
_dbg_assert_(WII_IPC_WIIMOTE, _Size == sizeof(l2cap_conf_rsp));
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] ReceiveConfigurationResponse");
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConfigurationResponse");
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, " 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];
if (rChannel.PSM == HID_CONTROL_CHANNEL)
{
m_HIDControlChannel_Config = true;
if (rChannel.PSM == HID_INTERRUPT_CHANNEL)
INFO_LOG(WII_IPC_WIIMOTE, "Building HID_CONTROL_CHANNEL -- OK");
}
else if (rChannel.PSM == HID_INTERRUPT_CHANNEL)
{
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)
{
SL2CAP_CommandDisconnectionReq* pCommandDisconnectionReq = (SL2CAP_CommandDisconnectionReq*)_pData;
_dbg_assert_(WII_IPC_WIIMOTE, m_Channel.find(pCommandDisconnectionReq->scid) != m_Channel.end());
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] ReceiveDisconnectionReq");
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveDisconnectionReq");
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->scid);
DEBUG_LOG(WII_IPC_WIIMOTE, " DCID: 0x%04x", pCommandDisconnectionReq->dcid);
DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", pCommandDisconnectionReq->scid);
// response
SL2CAP_CommandDisconnectionResponse Rsp;
Rsp.scid = pCommandDisconnectionReq->scid;
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);
}
@ -614,7 +612,8 @@ void CWII_IPC_HLE_WiiMote::SendConnectionRequest(u16 scid, u16 psm)
cr.psm = psm;
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, " Scid: 0x%04x", cr.scid);
@ -631,14 +630,14 @@ void CWII_IPC_HLE_WiiMote::SendDisconnectRequest(u16 scid)
cr.dcid = rChannel.DCID;
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, " Scid: 0x%04x", cr.scid);
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));
SChannel& rChannel = m_Channel[scid];
@ -651,31 +650,29 @@ void CWII_IPC_HLE_WiiMote::SendConfigurationRequest(u16 scid, u16* MTU, u16* Flu
cr->flags = 0;
Offset += sizeof(l2cap_conf_req);
if (MTU != NULL)
{
SL2CAP_Options* pOptions = (SL2CAP_Options*)&Buffer[Offset];
Offset += sizeof(SL2CAP_Options);
SL2CAP_Options* pOptions;
pOptions->type = 1;
pOptions->length = 2;
if (MTU == NULL) MTU = rChannel.MTU;
pOptions = (SL2CAP_Options*)&Buffer[Offset];
Offset += sizeof(SL2CAP_Options);
pOptions->type = 1;
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];
Offset += sizeof(SL2CAP_Options);
pOptions->type = 2;
pOptions->length = 2;
*(u16*)&Buffer[Offset] = FlushTimeOut;
Offset += 2;
if (FlushTimeOut != NULL)
{
SL2CAP_Options* pOptions = (SL2CAP_Options*)&Buffer[Offset];
Offset += sizeof(SL2CAP_Options);
pOptions->type = 2;
pOptions->length = 2;
*(u16*)&Buffer[Offset] = *FlushTimeOut; Offset += 2;
}
INFO_LOG(WII_IPC_WIIMOTE, "[ACL] SendConfigurationRequest");
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConfigurationRequest");
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, " MTU: 0x%04x", MTU);
DEBUG_LOG(WII_IPC_WIIMOTE, " FlushTimeOut: 0x%04x", FlushTimeOut);
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;
SL2CAP_Header* pHeader = (SL2CAP_Header*)&DataFrame[Offset]; Offset += sizeof(SL2CAP_Header);
pHeader->CID = 0x0001;
pHeader->Length = sizeof(SL2CAP_Command) + _CommandLength;
pHeader->CID = 0x0001;
SL2CAP_Command* pCommand = (SL2CAP_Command*)&DataFrame[Offset]; Offset += sizeof(SL2CAP_Command);
pCommand->len = _CommandLength;
pCommand->ident = _Ident;
pCommand->code = _Code;
pCommand->ident = _Ident;
pCommand->len = _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, " Code: 0x%02x", _Code);
@ -944,16 +941,16 @@ namespace Core
{
/* 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. */
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;
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);
DEBUG_LOG(WII_IPC_WIIMOTE, "=========================================================");
INFO_LOG(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:
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()
{}
@ -193,7 +193,9 @@ public:
// we really have to clean all this code
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; }
void ShowStatus(const void* _pData); // Show status
void UpdateStatus(); // Update status
@ -203,11 +205,10 @@ public:
void EventConnectionAccepted();
void EventDisconnect();
bool EventPagingChanged(u8 _pageMode);
void EventCommandWriteLinkPolicy();
const bdaddr_t& GetBD() const { return m_BD; }
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 char* GetName() const { return m_Name.c_str(); }
u8 GetLMPVersion() const { return lmp_version; }
@ -218,7 +219,7 @@ public:
private:
// state machine
bool m_Connected;
int m_Connected; // 0: ready, -1: inactive/connecting, 1: connected
bool m_Linked;
bool m_HIDControlChannel_Connected;
bool m_HIDControlChannel_ConnectedWait;
@ -231,7 +232,7 @@ private:
// STATE_TO_SAVE
bdaddr_t m_BD;
u16 m_ControllerConnectionHandle;
u16 m_ConnectionHandle;
uint8_t uclass[HCI_CLASS_SIZE];
u8 features[HCI_FEATURES_SIZE];
u8 lmp_version;
@ -263,7 +264,7 @@ private:
void SignalChannel(u8* _pData, u32 _Size);
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 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."));
WiimoteStatusLEDs->SetToolTip(wxT("Show which wiimotes are connected 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.")
wxT("\nCauses major speed improvements on PCs with more than one core,")
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.
// 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.
typedef struct
@ -35,7 +35,7 @@ typedef struct
// input: Da pakket.
// 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
@ -44,7 +44,7 @@ EXPORT void CALL Wiimote_ControlChannel(u16 _channelID, const void* _pData, u32
// input: Da pakket.
// 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
@ -52,7 +52,7 @@ EXPORT void CALL Wiimote_InterruptChannel(u16 _channelID, const void* _pData, u3
// input: none
// output: none
//
EXPORT void CALL Wiimote_Update();
EXPORT void CALL Wiimote_Update(int _number);
// __________________________________________________________________________________________________
// Function: PAD_GetAttachedPads

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

@ -21,7 +21,7 @@
#include "Common.h"
#include "IniFile.h"
#include "StringUtil.h"
#include "wiimote_hid.h"
#include "Config.h"
#include "EmuDefinitions.h" // for PadMapping
#include "main.h"
@ -293,7 +293,7 @@ void Config::Load(bool ChangePad)
iniFile.Get("Real", "AccNunNeutralY", &iAccNunNeutralY, 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
char SectionName[32];
@ -404,7 +404,7 @@ void Config::Save(int Slot)
iniFile.Set("Real", "AccNunNeutralY", iAccNunNeutralY);
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
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)
{
// 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);
// Save the settings for the current pad
// g_Config.Save(Slot);
@ -271,7 +271,7 @@ void WiimotePadConfigDialog::DoSave(bool ChangePad, int Slot)
else
{
// 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);
// 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, " Mode: 0x%02x", dr->mode);
g_ReportingAuto = dr->all_the_time;
g_ReportingAuto[g_RefreshWiimote] = dr->all_the_time;
g_ReportingMode = dr->mode;
g_ReportingChannel = _channelID;
@ -114,8 +114,7 @@ void SendReportCore(u16 _channelID)
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging
//ReadDebugging(true, DataFrame, Offset);
}
@ -140,7 +139,7 @@ void SendReportCoreAccel(u16 _channelID)
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging
//ReadDebugging(true, DataFrame, Offset);
@ -170,7 +169,7 @@ void SendReportCoreAccelIr12(u16 _channelID) {
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging
//ReadDebugging(true, DataFrame, Offset);
@ -215,7 +214,7 @@ void SendReportCoreAccelExt16(u16 _channelID)
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging
//ReadDebugging(true, DataFrame, Offset);
@ -269,7 +268,7 @@ void SendReportCoreAccelIr10Ext(u16 _channelID)
DEBUG_LOG(WIIMOTE, " Channel: %04x", _channelID);
DEBUG_LOG(WIIMOTE, " Size: %08x", Offset);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging
//ReadDebugging(true, DataFrame, Offset);

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

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

40
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_IR_SIZE 0x34
extern u8 g_Leds;
extern u8 g_Leds[4];
extern u8 g_Speaker;
extern u8 g_SpeakerVoice;
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_RegIr[WIIMOTE_REG_IR_SIZE];
extern bool g_ReportingAuto;
extern int g_RefreshWiimote;
extern bool g_ReportingAuto[4];
extern u8 g_ReportingMode;
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
struct KeyboardWiimote
@ -204,10 +213,6 @@ struct KeyboardWiimote
MA, MB,
LAST_CONSTANT
};
// Raw X and Y coordinate and processed X and Y coordinates
SIR IR;
STiltData TiltData;
};
extern KeyboardWiimote g_Wiimote_kbd;
@ -215,12 +220,7 @@ struct KeyboardNunchuck
{
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,
#endif
Z = 18,
C,
L, R, U, D,
ROLL_L, ROLL_R,
@ -228,8 +228,6 @@ struct KeyboardNunchuck
SHAKE,
LAST_CONSTANT
};
STiltData TiltData;
};
extern KeyboardNunchuck g_NunchuckExt;
@ -237,12 +235,7 @@ struct KeyboardClassicController
{
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,
#endif
A = 29,
B, X, Y,
P, M, H,
Tl, Tr, Zl, Zr,
@ -258,12 +251,7 @@ struct KeyboardGH3GLP
{
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,
#endif
Green = 52,
Red, Yellow, Blue, Orange,
Plus, Minus, Whammy,
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
//******************************************************************************
/*
// Calculate dot positions from the basic 10 byte IR 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].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)
{
if (Dot[i].Ry == 1023)
@ -270,7 +271,7 @@ void IRData2DotsBasic(u8 *Data)
else
{
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
@ -281,8 +282,9 @@ void IRData2DotsBasic(u8 *Data)
ReorderIRDots();
IRData2Distance();
}
*/
/*
// Calculate dot positions from the extented 12 byte IR data
void IRData2Dots(u8 *Data)
{
@ -297,7 +299,7 @@ void IRData2Dots(u8 *Data)
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)
Dot[i].Visible = false;
else
@ -313,8 +315,9 @@ void IRData2Dots(u8 *Data)
ReorderIRDots();
IRData2Distance();
}
*/
/*
// Reorder the IR dots according to their x-axis value
void ReorderIRDots()
{
@ -347,8 +350,9 @@ void ReorderIRDots()
Dot[i].Order = order;
}
}
*/
/*
// Calculate dot positions from the extented 12 byte IR data
void IRData2Distance()
{
@ -371,15 +375,15 @@ void IRData2Distance()
// Only one dot was visible, we can not calculate the distance
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
simple distance between the x dots, i.e. the sensor bar width */
// 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
int xd = Dot[i2].X - Dot[i1].X;
int yd = Dot[i2].Y - Dot[i1].Y;
// Save the distance
g_Wiimote_kbd.IR.Distance = (int)sqrt((float)(xd*xd) + (float)(yd*yd));
}
*/
//******************************************************************************
// 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
void ResetVariables()
{
g_ReportingAuto = false;
g_RefreshWiimote = 0;
g_ReportingMode = 0;
g_ReportingChannel = 0;
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
#if defined(HAVE_WX) && HAVE_WX
for (int i = 0; i < 3; i++)
@ -469,7 +475,6 @@ void Initialize()
void DoState(PointerWrap &p)
{
// TODO: Shorten the list
p.Do(g_Leds);
p.Do(g_Speaker);
p.Do(g_SpeakerVoice);
p.Do(g_IR);
@ -480,7 +485,6 @@ void DoState(PointerWrap &p)
p.DoArray(g_RegExtTmp, WIIMOTE_REG_EXT_SIZE);
p.DoArray(g_RegIr, WIIMOTE_REG_IR_SIZE);
p.Do(g_ReportingAuto);
p.Do(g_ReportingMode);
p.Do(g_ReportingChannel);
@ -492,10 +496,16 @@ void DoState(PointerWrap &p)
//p.Do(joyinfo);
//p.DoArray(PadState, 4);
//p.DoArray(PadMapping, 4);
//p.Do(g_Wiimote_kbd);
//p.Do(g_NunchuckExt);
//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;
}
@ -515,8 +525,9 @@ void Shutdown()
/* This function produce Wiimote Input, i.e. reports from the Wiimote in
response to Output from the Wii. */
void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
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
not determined by sizeof(data). We have to determine it by looking at
the data cases. */
@ -524,7 +535,7 @@ void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
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)
{
@ -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;
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)
{
@ -586,7 +599,7 @@ void ControlChannel(u16 _channelID, const void* _pData, u32 _Size)
// (TO_BE_VERIFIED)
//
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!");
}
@ -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
think it's tied to the frame rate of the game rather than a certain amount
of times per second. */
void Update()
void Update(int _number)
{
if(g_ReportingAuto == false)
if (g_ReportingAuto[_number] == false)
return;
// Read input or not
g_RefreshWiimote = _number;
// Read input or not
if (g_Config.bInputActive)
{
ReadLinuxKeyboard();
@ -626,9 +640,8 @@ void Update()
&& NumGoodPads > 0 && joyinfo.size() > (u32)PadMapping[0].ID)
*/
// Check if the pad state should be updated
const int Page = 0;
if (NumGoodPads > 0 && joyinfo.size() > (u32)PadMapping[Page].ID)
WiiMoteEmu::GetJoyState(PadState[Page], PadMapping[Page], Page, joyinfo[PadMapping[Page].ID].NumButtons);
if (NumGoodPads > 0 && joyinfo.size() > (u32)PadMapping[g_RefreshWiimote].ID)
WiiMoteEmu::GetJoyState(PadState[g_RefreshWiimote], PadMapping[g_RefreshWiimote], g_RefreshWiimote, joyinfo[PadMapping[g_RefreshWiimote].ID].NumButtons);
}
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 DoState(PointerWrap &p);
void Shutdown();
void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size);
void ControlChannel(u16 _channelID, const void* _pData, u32 _Size) ;
void Update();
void InterruptChannel(int _number, u16 _channelID, const void* _pData, u32 _Size);
void ControlChannel(int _number, u16 _channelID, const void* _pData, u32 _Size) ;
void Update(int _number);
void ReadLinuxKeyboard();
// Recordings
@ -68,8 +68,8 @@ void AdjustAngles(int &Roll, int &Pitch);
void RotateIRDots(int &_x, int &_y, STiltData &_TiltData);
void IRData2Dots(u8 *Data);
void IRData2DotsBasic(u8 *Data);
void ReorderIRDots();
void IRData2Distance();
//void ReorderIRDots();
//void IRData2Distance();
// Classic Controller 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);
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, " Report ID: %02x", _reportID);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging
//ReadDebugging(true, DataFrame, Offset);
@ -360,11 +360,11 @@ void SendReadDataReply(u16 _channelID, void* _Base, u16 _Address, int _Size)
#if defined(_DEBUG) || defined(DEBUGFAST)
std::string Temp = ArrayToString(DataFrame, Offset);
ERROR_LOG(WIIMOTE, "Data: %s", Temp.c_str());
DEBUG_LOG(WIIMOTE, "Data: %s", Temp.c_str());
#endif
// Send a piece
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Update the size that is left
_Size -= copySize;
@ -482,7 +482,7 @@ void WmRequestStatus(u16 _channelID, wm_request_status* rs, int Extension)
#if defined(HAVE_WX) && HAVE_WX
FillReportInfo(pStatus->buttons);
#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->speaker = g_Speaker; // 1 bit
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, " Buttons: 0x%04x", pStatus->buttons);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
g_WiimoteInitialize.pWiimoteInput(g_RefreshWiimote, _channelID, DataFrame, Offset);
// Debugging
//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;
// Select input method and return the x, y, x values
else if (g_Config.Tilt.TypeWM == g_Config.Tilt.KEYBOARD)
TiltByKeyboardWM(g_Wiimote_kbd.TiltData);
TiltByKeyboardWM(g_WiimoteData[g_RefreshWiimote].TiltWM);
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
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
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);
}
@ -708,16 +708,16 @@ void TiltNunchuck(int &_x, int &_y, int &_z)
return;
// Select input method and return the x, y, x values
else if (g_Config.Tilt.TypeNC == g_Config.Tilt.KEYBOARD)
TiltByKeyboardNC(g_NunchuckExt.TiltData);
TiltByKeyboardNC(g_WiimoteData[g_RefreshWiimote].TiltNC);
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
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
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);
}
@ -745,11 +745,11 @@ void FillReportAcc(wm_accel& _acc)
// Adjust position, also add some noise to prevent disconnection
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
_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())
{
@ -757,14 +757,14 @@ void FillReportAcc(wm_accel& _acc)
int acc_y = _acc.y;
int acc_z = _acc.z;
if (IsKey(g_Wiimote_kbd.SHAKE) && g_Wiimote_kbd.TiltData.Shake == 0)
g_Wiimote_kbd.TiltData.Shake = 1;
if (IsKey(g_Wiimote_kbd.SHAKE) && g_WiimoteData[g_RefreshWiimote].TiltWM.Shake == 0)
g_WiimoteData[g_RefreshWiimote].TiltWM.Shake = 1;
// 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
if (g_Wiimote_kbd.TiltData.Shake == 0)
if (g_WiimoteData[g_RefreshWiimote].TiltWM.Shake == 0)
TiltWiimote(acc_x, acc_y, acc_z);
// 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 x1 = x0 + SENSOR_BAR_WIDTH;
RotateIRDot(x0, y0, g_Wiimote_kbd.TiltData);
RotateIRDot(x1, y1, g_Wiimote_kbd.TiltData);
RotateIRDot(x0, y0, g_WiimoteData[g_RefreshWiimote].TiltWM);
RotateIRDot(x1, y1, g_WiimoteData[g_RefreshWiimote].TiltWM);
// Converted to IR data
_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 x2 = x1 + SENSOR_BAR_WIDTH;
RotateIRDot(x1, y1, g_Wiimote_kbd.TiltData);
RotateIRDot(x2, y2, g_Wiimote_kbd.TiltData);
RotateIRDot(x1, y1, g_WiimoteData[g_RefreshWiimote].TiltWM);
RotateIRDot(x2, y2, g_WiimoteData[g_RefreshWiimote].TiltWM);
/* 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
@ -1082,14 +1082,14 @@ if (IsFocus())
int acc_y = _ext.ay;
int acc_z = _ext.az;
if (IsKey(g_NunchuckExt.SHAKE) && g_NunchuckExt.TiltData.Shake == 0)
g_NunchuckExt.TiltData.Shake = 1;
if (IsKey(g_NunchuckExt.SHAKE) && g_WiimoteData[g_RefreshWiimote].TiltNC.Shake == 0)
g_WiimoteData[g_RefreshWiimote].TiltNC.Shake = 1;
// 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
if (g_NunchuckExt.TiltData.Shake == 0)
if (g_WiimoteData[g_RefreshWiimote].TiltNC.Shake == 0)
TiltNunchuck(acc_x, acc_y, acc_z);
// 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()
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;
@ -319,17 +319,17 @@ void Wiimote_InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
// Decice where to send the message
if (!g_Config.bUseRealWiimote || !g_RealWiiMotePresent)
WiiMoteEmu::InterruptChannel(_channelID, _pData, _Size);
WiiMoteEmu::InterruptChannel(_number, _channelID, _pData, _Size);
#if HAVE_WIIUSE
else if (g_RealWiiMotePresent)
WiiMoteReal::InterruptChannel(_channelID, _pData, _Size);
WiiMoteReal::InterruptChannel(_channelID, _pData, _Size); // TODO: Multi-Wiimote
#endif
}
// 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;
@ -354,17 +354,17 @@ void Wiimote_ControlChannel(u16 _channelID, const void* _pData, u32 _Size)
}
if (!g_Config.bUseRealWiimote || !g_RealWiiMotePresent)
WiiMoteEmu::ControlChannel(_channelID, _pData, _Size);
WiiMoteEmu::ControlChannel(_number, _channelID, _pData, _Size);
#if HAVE_WIIUSE
else if (g_RealWiiMotePresent)
WiiMoteReal::ControlChannel(_channelID, _pData, _Size);
WiiMoteReal::ControlChannel(_channelID, _pData, _Size); // TODO: Multi-Wiimote
#endif
}
/* This sends a Data Report from the Wiimote. See SystemTimers.cpp for the documentation of this
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
#if defined(HAVE_WX) && HAVE_WX
@ -384,10 +384,10 @@ void Wiimote_Update()
// Emulated Wiimote: Only data reports 0x30-0x37
// Real Wiimote: Both data reports 0x30-0x37 and all other read reports
if (!g_Config.bUseRealWiimote || !g_RealWiiMotePresent)
WiiMoteEmu::Update();
WiiMoteEmu::Update(_number);
#if HAVE_WIIUSE
else if (g_RealWiiMotePresent)
WiiMoteReal::Update();
WiiMoteReal::Update(); // TODO: Multi-Wiimote
#endif
// Debugging
@ -445,7 +445,7 @@ void DisableExtensions()
g_Config.iExtensionConnected = EXT_NONE;
}
/*
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->battery_low
);
/* 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. */
// 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.
if(!Emu && !pStatus->extension)
{
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);
}
/* 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. */
// 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.
if(data[4] == 0x10)
{
if (!Emu) DisableExtensions();
@ -553,9 +553,9 @@ void ReadDebugging(bool Emu, const void* _pData, int Size)
}
// Show the Wiimote neutral values
/* The only difference between the Nunchuck and Wiimote that we go
after is calibration here is the offset in memory. If needed we can
check the preceding 0x17 request to. */
// The only difference between the Nunchuck and Wiimote that we go
// after is calibration here is the offset in memory. If needed we can
// check the preceding 0x17 request to.
if(data[4] == 0xf0 && data[5] == 0x00 && 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
// -----------
/*
ConsoleListener* Console = LogManager::GetInstance()->getConsoleListener();
Console->ClearScreen();
// Show a test of our calculations
@ -771,7 +770,7 @@ void ReadDebugging(bool Emu, const void* _pData, int Size)
u8 x, y, z;
//WiiMoteEmu::Tilt(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]);
}
}
*/
void InterruptDebugging(bool Emu, const void* _pData)
{

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

@ -25,6 +25,8 @@
#endif
#pragma pack(push, 1)
#define MAX_WIIMOTES 2
// Source: HID_010_SPC_PFL/1.0 (official HID specification)
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);
// Send it
g_WiimoteInitialize.pWiimoteInput(m_channelID, Buffer, Offset);
g_WiimoteInitialize.pWiimoteInput(0, m_channelID, Buffer, Offset); // TODO: Multi-Wiimote
// Debugging
// ReadDebugging(false, Buffer, Offset);

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

@ -26,8 +26,6 @@
namespace WiiMoteReal
{
#define MAX_WIIMOTES 1
int Initialize();
void DoState(PointerWrap &p);
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
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].triggertype = m_TriggerType[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
for(int i = 0; i < 4; i++)
{
if (!PadMapping[i].enable)
continue;
for(int j = InputCommon::CTL_L_SHOULDER; j <= InputCommon::CTL_START; j++)
{
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
// disconnected
if (!PadState[_numPAD].joy || !PadMapping[_numPAD].enable)
if (!PadState[_numPAD].joy)
return;
// Clear pad status