mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-07-21 05:09:34 -06:00
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
@ -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
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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));
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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."));
|
||||
|
||||
Reference in New Issue
Block a user