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

some more wpad work... 

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@973 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
fires.gc 2008-10-26 14:16:51 +00:00
parent f1db84a999
commit c9a8672987
11 changed files with 399 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/Core/Core/Core.vcproj
View File

@ -1143,10 +1143,6 @@
RelativePath=".\Src\IPC_HLE\WII_IPC_HLE_WiiMote.h"
>
</File>
<File
RelativePath=".\Src\IPC_HLE\wiimote_hid.h"
>
</File>
</Filter>
<Filter
Name="Boot"

20
Source/Core/Core/Src/Debugger/Debugger_SymbolMap.cpp
View File

@ -134,4 +134,24 @@ void PrintCallstack(LogTypes::LOG_TYPE _Log)
}
}
void PrintDataBuffer(LogTypes::LOG_TYPE _Log, u8* _pData, size_t _Size, const char* _title)
{
__Log(_Log, _title);
for (u32 j=0; j<_Size;)
{
std::string Temp;
for (int i=0; i<16; i++)
{
char Buffer[128];
sprintf(Buffer, "%02x ", _pData[j++]);
Temp.append(Buffer);
if (j >= _Size)
break;
}
__Log(_Log, " Data: %s", Temp.c_str());
}
}
} // end of namespace Debugger

1
Source/Core/Core/Src/Debugger/Debugger_SymbolMap.h
View File

@ -35,6 +35,7 @@ struct CallstackEntry
bool GetCallstack(std::vector<CallstackEntry> &output);
void PrintCallstack();
void PrintCallstack(LogTypes::LOG_TYPE _Log);
void PrintDataBuffer(LogTypes::LOG_TYPE _Log, u8* _pData, size_t _Size, const char* _title);
} // end of namespace Debugger

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

@ -18,6 +18,8 @@
#include "WII_IPC_HLE_Device_usb.h"
#include "../Plugins/Plugin_Wiimote.h"
#include "../Debugger/Debugger_SymbolMap.h"
// ugly hacks for "SendEventNumberOfCompletedPackets"
int g_HCICount = 0;
int g_GlobalHandle = 0;
@ -67,9 +69,17 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::IOCtl(u32 _CommandAddress)
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::IOCtlV(u32 _CommandAddress)
{
// wpadsampled.elf - patch so the USB_LOG will print somehting
Memory::Write_U8(255, 0x80149950); // BTM LOG
// 3 logs L2Cap
// 4 logs l2_csm$
Memory::Write_U8(255, 0x80149949); // HID
Memory::Write_U8(255, 0x80152058); // low ??
// even it it wasn't very useful yet...
Memory::Write_U8(1, 0x80151488); // DebugLog
// Memory::Write_U8(1, 0x80151488); // WPAD_LOG
// Memory::Write_U8(1, 0x801514A8); // USB_LOG
// Memory::Write_U8(1, 0x801514D8); // WUD_DEBUGPrint
// Memory::Write_U8(1, 0x80148E09); // HID LOG
@ -210,7 +220,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendToDevice(u16 _ConnectionHandle, u8
CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_ConnectionHandle);
if (pWiiMote == NULL)
{
PanicAlert("Cant find WiiMote by connection handle: %02x", _ConnectionHandle);
PanicAlert("SendToDevice: Cant find WiiMote by connection handle: %02x", _ConnectionHandle);
return;
}
@ -293,7 +303,31 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
g_HCICount = 0;
}
PluginWiimote::Wiimote_Update();
if (m_AclFrameQue.empty())
{
PluginWiimote::Wiimote_Update();
}
static bool test = true;
if (GetAsyncKeyState(VK_LBUTTON) && GetAsyncKeyState(VK_RBUTTON))
{
if (test)
{
for (size_t i=0; i<m_WiiMotes.size(); i++)
{
// if (m_WiiMotes[i].EventPagingChanged(2))
{
SendEventRequestConnection(m_WiiMotes[i].GetBD());
}
}
test = false;
}
}
else
{
test = true;
}
return 0;
}
@ -368,6 +402,9 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventInquiryResponse()
for (size_t i=0; i<m_WiiMotes.size(); i++)
{
if (m_WiiMotes[i].IsConnected())
continue;
u8* pBuffer = Event.m_buffer + sizeof(SHCIEventInquiryResult) + i*sizeof(hci_inquiry_response);
hci_inquiry_response* pResponse = (hci_inquiry_response*)pBuffer;
@ -413,7 +450,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRemoteNameReq(bdaddr_t _bd)
CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_bd);
if (pWiiMote == NULL)
{
PanicAlert("Cant find WiiMote by bd: %02x:%02x:%02x:%02x:%02x:%02x",
PanicAlert("SendEventRemoteNameReq: Cant find WiiMote by bd: %02x:%02x:%02x:%02x:%02x:%02x",
_bd.b[0], _bd.b[1], _bd.b[2],
_bd.b[3], _bd.b[4], _bd.b[5]);
return false;
@ -440,9 +477,9 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRemoteNameReq(bdaddr_t _bd)
return true;
}
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection()
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection(bdaddr_t _bd)
{
const CWII_IPC_HLE_WiiMote rWiiMote = m_WiiMotes[0];
const CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_bd);
SQueuedEvent Event(sizeof(SHCIEventRequestConnection), 0);
@ -450,10 +487,10 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection()
pEventRequestConnection->EventType = 0x04;
pEventRequestConnection->PayloadLength = sizeof(SHCIEventRequestConnection) - 2;
pEventRequestConnection->bdaddr = rWiiMote.GetBD(); // BD_ADDR of the device that requests the connection
pEventRequestConnection->uclass[0] = rWiiMote.GetClass()[0];
pEventRequestConnection->uclass[1] = rWiiMote.GetClass()[1];
pEventRequestConnection->uclass[2] = rWiiMote.GetClass()[2];
pEventRequestConnection->bdaddr = pWiiMote->GetBD(); // BD_ADDR of the device that requests the connection
pEventRequestConnection->uclass[0] = pWiiMote->GetClass()[0];
pEventRequestConnection->uclass[1] = pWiiMote->GetClass()[1];
pEventRequestConnection->uclass[2] = pWiiMote->GetClass()[2];
pEventRequestConnection->LinkType = 0x01;
AddEventToQueue(Event);
@ -480,12 +517,36 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection()
return true;
};
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestLinkKey(bdaddr_t _bd)
{
const CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_bd);
SQueuedEvent Event(sizeof(SHCIEventRequestLinkKey), 0);
SHCIEventRequestLinkKey* pEventRequestLinkKey = (SHCIEventRequestLinkKey*)Event.m_buffer;
pEventRequestLinkKey->EventType = 0x17;
pEventRequestLinkKey->PayloadLength = sizeof(SHCIEventRequestLinkKey) - 2;
pEventRequestLinkKey->bdaddr = _bd;
AddEventToQueue(Event);
LOG(WIIMOTE, "Event: SendEventRequestLinkKey");
LOG(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]);
return true;
};
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventConnectionComplete(bdaddr_t _bd)
{
CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_bd);
if (pWiiMote == NULL)
{
PanicAlert("Cant find WiiMote by bd: %02x:%02x:%02x:%02x:%02x:%02x",
PanicAlert("SendEventConnectionComplete: Cant find WiiMote by bd: %02x:%02x:%02x:%02x:%02x:%02x",
_bd.b[0], _bd.b[1], _bd.b[2],
_bd.b[3], _bd.b[4], _bd.b[5]);
return false;
@ -532,7 +593,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRoleChange(bdaddr_t _bd)
CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_bd);
if (pWiiMote == NULL)
{
PanicAlert("Cant find WiiMote by bd: %02x:%02x:%02x:%02x:%02x:%02x",
PanicAlert("SendEventRoleChange: Cant find WiiMote by bd: %02x:%02x:%02x:%02x:%02x:%02x",
_bd.b[0], _bd.b[1], _bd.b[2],
_bd.b[3], _bd.b[4], _bd.b[5]);
return false;
@ -542,7 +603,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRoleChange(bdaddr_t _bd)
SHCIEventRoleChange* pRoleChange = (SHCIEventRoleChange*)Event.m_buffer;
pRoleChange->EventType = 0x03;
pRoleChange->EventType = 0x12;
pRoleChange->PayloadLength = sizeof(SHCIEventRoleChange) - 2;
pRoleChange->Status = 0x00;
pRoleChange->bdaddr = pWiiMote->GetBD();
@ -566,7 +627,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventReadClockOffsetComplete(u16 _
CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_connectionHandle);
if (pWiiMote == NULL)
{
PanicAlert("Cant find WiiMote by connection handle: %02x", _connectionHandle);
PanicAlert("SendEventReadClockOffsetComplete: Cant find WiiMote by connection handle: %02x", _connectionHandle);
return false;
}
@ -594,7 +655,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventReadRemoteVerInfo(u16 _connec
CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_connectionHandle);
if (pWiiMote == NULL)
{
PanicAlert("Cant find WiiMote by connection handle: %02x", _connectionHandle);
PanicAlert("SendEventReadRemoteVerInfo: Cant find WiiMote by connection handle: %02x", _connectionHandle);
return false;
}
@ -626,7 +687,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventReadRemoteFeatures(u16 _conne
CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(_connectionHandle);
if (pWiiMote == NULL)
{
PanicAlert("Cant find WiiMote by connection handle: %02x", _connectionHandle);
PanicAlert("SendEventReadRemoteFeatures: Cant find WiiMote by connection handle: %02x", _connectionHandle);
return false;
}
@ -771,9 +832,6 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventDisconnect(u16 _connectionHan
}
////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
@ -787,7 +845,10 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::ExecuteHCICommandMessage(const SHCICom
u8* pInput = Memory::GetPointer(_rHCICommandMessage.m_PayLoadAddr + 3);
SCommandMessage* pMsg = (SCommandMessage*)Memory::GetPointer(_rHCICommandMessage.m_PayLoadAddr);
LOG(WIIMOTE, "****************************** ExecuteHCICommandMessage(0x%04x)", pMsg->Opcode);
u16 ocf = HCI_OCF(pMsg->Opcode);
u16 ogf = HCI_OGF(pMsg->Opcode);
LOG(WIIMOTE, "****************************** ExecuteHCICommandMessage(0x%04x)"
"(ocf: 0x%02x, ogf: 0x%02x)", pMsg->Opcode, ocf, ogf);
switch(pMsg->Opcode)
{
@ -914,6 +975,15 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::ExecuteHCICommandMessage(const SHCICom
case HCI_CMD_DISCONNECT:
CommandDisconnect(pInput);
break;
case HCI_CMD_WRITE_LINK_SUPERVISION_TIMEOUT:
CommandWriteLinkSupervisionTimeout(pInput);
break;
case HCI_CMD_LINK_KEY_NEG_REP:
CommandLinkKeyNegRep(pInput);
break;
//
// --- default ---
//
@ -1191,15 +1261,15 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteScanEnable(u8* _Input)
SendEventCommandComplete(HCI_CMD_WRITE_SCAN_ENABLE, &Reply, sizeof(hci_write_scan_enable_rp));
return;
// TODO: fix this ugly request connection hack :)
//for homebrew works this
if (pWriteScanEnable->scan_enable & 2) // check if page scan is enable
for (size_t i=0; i<m_WiiMotes.size(); i++)
{
static bool first = true;
if (first)
if (m_WiiMotes[i].EventPagingChanged(pWriteScanEnable->scan_enable))
{
first = false;
// SendEventRequestConnection();
SendEventRequestConnection(m_WiiMotes[i].GetBD());
}
}
}
@ -1292,13 +1362,8 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandInquiry(u8* _Input)
LOG(WIIMOTE, " num_responses: %i (N x 1.28) sec", pInquiry->num_responses);
SendEventCommandStatus(HCI_CMD_INQUIRY);
if (g_GlobalHandle == 0)
{
SendEventInquiryResponse();
}
/*
SendEventInquiryComplete(); */
SendEventInquiryResponse();
SendEventInquiryComplete();
}
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryScanType(u8* _Input)
@ -1331,12 +1396,10 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandVendorSpecific_FC4F(u8* _Input,
hci_status_rp Reply;
Reply.status = 0x00;
LOG(WIIMOTE, "Command: CommandVendorSpecific_FC4F:");
LOG(WIIMOTE, "Command: CommandVendorSpecific_FC4F: (callstack WUDiRemovePatch)");
LOG(WIIMOTE, "input (size 0x%x):", _Size);
for (u32 i=0; i<_Size; i++)
LOG(WIIMOTE, " Data: 0x%02x", _Input[i]);
LOG(WIIMOTE, "write:");
LOG(WIIMOTE, " callstack WUDiRemovePatch");
Debugger::PrintDataBuffer(LogTypes::WIIMOTE, _Input, _Size, "Data: ");
SendEventCommandComplete(0xFC4F, &Reply, sizeof(hci_status_rp));
}
@ -1349,10 +1412,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandVendorSpecific_FC4C(u8* _Input,
LOG(WIIMOTE, "Command: CommandVendorSpecific_FC4C:");
LOG(WIIMOTE, "input (size 0x%x):", _Size);
for (u32 i=0; i<_Size; i++)
LOG(WIIMOTE, " Data: 0x%02x", _Input[i]);
LOG(WIIMOTE, "write:");
LOG(WIIMOTE, " perhaps append patch?");
Debugger::PrintDataBuffer(LogTypes::WIIMOTE, _Input, _Size, "Data: ");
SendEventCommandComplete(0xFC4C, &Reply, sizeof(hci_status_rp));
}
@ -1428,6 +1488,13 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandAcceptCon(u8* _Input)
LOG(WIIMOTE, " role: %s", s_szRole[pAcceptCon->role]);
SendEventCommandStatus(HCI_CMD_ACCEPT_CON);
CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(pAcceptCon->bdaddr);
if (pWiimote)
{
pWiimote->EventConnectionAccepted();
}
SendEventConnectionComplete(pAcceptCon->bdaddr);
}
@ -1442,6 +1509,9 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadClockOffset(u8* _Input)
SendEventCommandStatus(HCI_CMD_READ_CLOCK_OFFSET);
SendEventReadClockOffsetComplete(pReadClockOffset->con_handle);
//CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(pReadClockOffset->con_handle);
// pWiiMote->Connect();
}
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadRemoteVerInfo(u8* _Input)
@ -1455,10 +1525,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadRemoteVerInfo(u8* _Input)
SendEventCommandStatus(HCI_CMD_READ_REMOTE_VER_INFO);
SendEventReadRemoteVerInfo(pReadRemoteVerInfo->con_handle);
// connect
// CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(pReadRemoteVerInfo->con_handle);
// pWiimote->Connect();
}
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadRemoteFeatures(u8* _Input)
@ -1472,6 +1538,10 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadRemoteFeatures(u8* _Input)
SendEventCommandStatus(HCI_CMD_READ_REMOTE_FEATURES);
SendEventReadRemoteFeatures(pReadRemoteFeatures->con_handle);
// connect
// CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(pReadRemoteFeatures->con_handle);
// pWiimote->Connect();
}
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLinkPolicy(u8* _Input)
@ -1485,12 +1555,6 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLinkPolicy(u8* _Input)
LOG(WIIMOTE, " Policy: 0x%04x", pLinkPolicy->settings);
SendEventCommandStatus(HCI_CMD_WRITE_LINK_POLICY_SETTINGS);
PanicAlert("The connect should be send after the command status... check it");
// for homebrew works this
// CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(pLinkPolicy->con_handle);
// pWiimote->Connect();
}
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandAuthenticationRequested(u8* _Input)
@ -1535,8 +1599,52 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandDisconnect(u8* _Input)
SendEventCommandStatus(HCI_CMD_DISCONNECT);
SendEventDisconnect(pDiscon->con_handle, pDiscon->reason);
CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(pDiscon->con_handle);
if (pWiimote)
{
pWiimote->EventDisconnect();
}
}
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLinkSupervisionTimeout(u8* _Input)
{
// command parameters
hci_write_link_supervision_timeout_cp* pSuperVision = (hci_write_link_supervision_timeout_cp*)_Input;
LOG(WIIMOTE, "Command: HCI_OCF_WRITE_LINK_SUPERVISION_TIMEOUT");
LOG(WIIMOTE, "Input:");
LOG(WIIMOTE, " con_handle: 0x%04x", pSuperVision->con_handle);
LOG(WIIMOTE, " timeout: 0x%02x", pSuperVision->timeout);
hci_write_link_supervision_timeout_rp Reply;
Reply.status = 0x00;
Reply.con_handle = pSuperVision->con_handle;
SendEventCommandComplete(HCI_OCF_WRITE_LINK_SUPERVISION_TIMEOUT, &Reply, sizeof(hci_write_link_supervision_timeout_rp));
}
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandLinkKeyNegRep(u8* _Input)
{
// command parameters
hci_link_key_neg_rep_cp* pKeyNeg = (hci_link_key_neg_rep_cp*)_Input;
LOG(WIIMOTE, "Command: HCI_CMD_LINK_KEY_NEG_REP");
LOG(WIIMOTE, "Input:");
LOG(WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pKeyNeg->bdaddr.b[0], pKeyNeg->bdaddr.b[1], pKeyNeg->bdaddr.b[2],
pKeyNeg->bdaddr.b[3], pKeyNeg->bdaddr.b[4], pKeyNeg->bdaddr.b[5]);
hci_link_key_neg_rep_rp Reply;
Reply.status = 0x00;
Reply.bdaddr = pKeyNeg->bdaddr;
SendEventCommandComplete(HCI_OCF_WRITE_LINK_SUPERVISION_TIMEOUT, &Reply, sizeof(hci_link_key_neg_rep_rp));
// CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(pKeyNeg->bdaddr);
// pWiiMote->Connect();
}

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

@ -152,7 +152,7 @@ private:
bool SendEventInquiryResponse();
bool SendEventInquiryComplete();
bool SendEventRemoteNameReq(bdaddr_t _bd);
bool SendEventRequestConnection();
bool SendEventRequestConnection(bdaddr_t _bd);
bool SendEventConnectionComplete(bdaddr_t _bd);
bool SendEventReadClockOffsetComplete(u16 _connectionHandle);
bool SendEventReadRemoteVerInfo(u16 _connectionHandle);
@ -162,6 +162,7 @@ private:
bool SendEventAuthenticationCompleted(u16 _connectionHandle);
bool SendEventModeChange(u16 _connectionHandle, u8 _mode, u16 _value);
bool SendEventDisconnect(u16 _connectionHandle, u8 _Reason);
bool SendEventRequestLinkKey(bdaddr_t _bd);
// Execute HCI Message
void ExecuteHCICommandMessage(const SHCICommandMessage& _rCtrlMessage);
@ -180,6 +181,7 @@ private:
void CommandAuthenticationRequested(u8* _Input);
void CommandInquiry(u8* _Input);
void CommandDisconnect(u8* _Input);
void CommandLinkKeyNegRep(u8* _Input);
// OGF 0x02 Link policy commands and return parameters
void CommandWriteLinkPolicy(u8* _Input);
@ -195,6 +197,7 @@ private:
void CommandWritePinType(u8* _Input);
void CommandSetEventFilter(u8* _Input);
void CommandWriteInquiryScanType(u8* _Input);
void CommandWriteLinkSupervisionTimeout(u8* _Input);
// OGF 0x04 Informational commands and return parameters
void CommandReadBufferSize(u8* _Input);

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

@ -135,13 +135,27 @@ static CWII_IPC_HLE_Device_usb_oh1_57e_305* s_Usb;
namespace Core {
void Callback_WiimoteInput(u16 _channelID, const void* _pData, u32 _Size)
{
const u8* pData = (const u8*)_pData;
LOG(WIIMOTE, "Callback_WiimoteInput: 0x%x", _channelID);
std::string Temp;
for (u32 j=0; j<_Size; j++)
{
char Buffer[128];
sprintf(Buffer, "%02x ", pData[j]);
Temp.append(Buffer);
}
LOG(WIIMOTE, " Data: %s", Temp.c_str());
s_Usb->m_WiiMotes[0].SendL2capData(_channelID, _pData, _Size);
// CCPU::Break();
}
}
CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305* _pHost, int _Number)
: m_Name("Nintendo RVL-CNT-01")
, m_pHost(_pHost)
, m_Connected(false)
{
s_Usb = _pHost;
LOG(WIIMOTE, "Wiimote %i constructed", _Number);
@ -172,21 +186,33 @@ CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305*
lmp_subversion = 0x229;
}
void CWII_IPC_HLE_WiiMote::EventConnectionAccepted()
{
m_Connected = true;
}
void CWII_IPC_HLE_WiiMote::EventDisconnect()
{
m_Connected = false;
}
bool CWII_IPC_HLE_WiiMote::EventPagingChanged(u8 _pageMode)
{
if (m_Connected)
return false;
if ((_pageMode & 2) == 0)
return false;
return true;
}
void CWII_IPC_HLE_WiiMote::SendACLFrame(u8* _pData, u32 _Size)
{
/* // dump raw data
{
LOG(WIIMOTE, "SendToDevice: 0x%x", GetConnectionHandle());
std::string Temp;
for (u32 j=0; j<_Size; j++)
{
char Buffer[128];
sprintf(Buffer, "%02x ", _pData[j]);
Temp.append(Buffer);
}
LOG(WIIMOTE, " Data: %s", Temp.c_str());
}
*/
// Debugger::PrintDataBuffer(LogTypes::WIIMOTE, _pData, _Size, "SendACLFrame: ");
// parse the command
SL2CAP_Header* pHeader = (SL2CAP_Header*)_pData;
u8* pData = _pData + sizeof(SL2CAP_Header);
@ -296,8 +322,10 @@ void CWII_IPC_HLE_WiiMote::SendCommandToACL(u8 _Ident, u8 _Code, u8 _CommandLeng
void CWII_IPC_HLE_WiiMote::Connect()
{
SendConnectionRequest(0x0040, HIDP_OUTPUT_CHANNEL);
SendConnectionRequest(0x0041, HIDP_INPUT_CHANNEL);
SendConnectionRequest(0x0040, 1);
// SendConnectionRequest(0x0041, HIDP_OUTPUT_CHANNEL);
// SendConnectionRequest(0x0042, HIDP_INPUT_CHANNEL);
}
void CWII_IPC_HLE_WiiMote::SendConnectionRequest(u16 scid, u16 psm)
@ -318,6 +346,22 @@ void CWII_IPC_HLE_WiiMote::SendConnectionRequest(u16 scid, u16 psm)
SendCommandToACL(L2CAP_CONN_REQ, L2CAP_CONN_REQ, sizeof(l2cap_conn_req), (u8*)&cr);
}
void CWII_IPC_HLE_WiiMote::SendDisconnectRequest(u16 scid)
{
// create the channel
SChannel& rChannel = m_Channel[scid];
l2cap_disconn_req cr;
cr.dcid = rChannel.DCID;
cr.scid = rChannel.SCID;
LOG(WIIMOTE, " SendDisconnectionRequest()");
LOG(WIIMOTE, " Dcid: 0x%04x", cr.dcid);
LOG(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)
{
_dbg_assert_(WIIMOTE, DoesChannelExist(scid));

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

@ -80,6 +80,17 @@ public:
virtual ~CWII_IPC_HLE_WiiMote()
{}
//////////////////////////////////////////////////////////////
// ugly Host handling....
// we really have to clean all this code
bool IsConnected() const { return m_Connected; }
void EventConnectionAccepted();
void EventDisconnect();
bool EventPagingChanged(u8 _pageMode);
const bdaddr_t& GetBD() const { return m_BD; }
const uint8_t* GetClass() const { return uclass; }
@ -104,6 +115,8 @@ public:
private:
bool m_Connected;
// STATE_TO_SAVE
bdaddr_t m_BD;
@ -146,6 +159,7 @@ private:
void SendConnectionRequest(u16 scid, u16 psm);
void SendConfigurationRequest(u16 scid, u16* MTU, u16* FlushTimeOut);
void SendDisconnectRequest(u16 scid);
void CommandConnectionReq(u8 _Ident, u8* _pData, u32 _Size);
void CommandCofigurationReq(u8 _Ident, u8* _pData, u32 _Size);

6
Source/Core/Core/Src/IPC_HLE/hci.h
View File

@ -2534,6 +2534,12 @@ struct SHCIEventDisconnectCompleted
u8 Reason;
};
struct SHCIEventRequestLinkKey
{
u8 EventType;
u8 PayloadLength;
bdaddr_t bdaddr;
};
#ifdef __cplusplus
}

63
Source/Core/Core/Src/IPC_HLE/l2cap.h
View File

@ -212,6 +212,69 @@ struct l2cap_info_rsp {
#pragma pack(pop)
#endif
struct value_string
{
u32 value;
char* string;
};
static const value_string command_code_vals[] = {
{ 0x01, "Command Reject" },
{ 0x02, "Connection Request" },
{ 0x03, "Connection Response" },
{ 0x04, "Configure Request" },
{ 0x05, "Configure Response" },
{ 0x06, "Disconnect Request" },
{ 0x07, "Disconnect Response" },
{ 0x08, "Echo Request" },
{ 0x09, "Echo Response" },
{ 0x0A, "Information Request" },
{ 0x0B, "Information Response" },
{ 0, NULL }
};
static const value_string psm_vals[] = {
{ 0x0001, "SDP" },
{ 0x0003, "RFCOMM" },
{ 0x0005, "TCS-BIN" },
{ 0x0007, "TCS-BIN-CORDLESS" },
{ 0x000F, "BNEP" },
{ 0x0011, "HID_CONTROL" },
{ 0x0013, "HID_INTERRUPT" },
{ 0x0015, "UPnP" },
{ 0x0017, "AVCTP" },
{ 0x0019, "AVDTP" },
{ 0x001D, "UDI_C-Plane" },
{ 0, NULL }
};
static const value_string result_vals[] = {
{ 0x0000, "Connection successful" },
{ 0x0001, "Connection pending" },
{ 0x0002, "Connection Refused - PSM not supported" },
{ 0x0003, "Connection refused - security block" },
{ 0x0004, "Connection refused - no resources available" },
{ 0, NULL }
};
static const value_string status_vals[] = {
{ 0x0000, "No further information available" },
{ 0x0001, "Authentication panding" },
{ 0x0002, "Authorization pending" },
{ 0, NULL }
};
#ifdef NOT_DOLPHIN
/* ----- L2CAP connections ----- */

93
Source/Plugins/Plugin_Wiimote_Test/Src/Wiimote.cpp
View File

@ -67,12 +67,12 @@ void WmRequestStatus(u16 _channelID, wm_request_status* rs);
void WmDataReporting(u16 _channelID, wm_data_reporting* dr);
void SendReadDataReply(u16 _channelID, void* _Base, u16 _Address, u8 _Size);
void SendWriteDataReply(u16 _channelID);
void SendReportCoreAccel(u16 _channelID);
void SendReportCoreAccelIr12(u16 _channelID);
void SendReportCore(u16 _channelID);
int WriteWmReport(u16 _channelID, u8* dst, u8 channel);
int WriteWmReport(u8* dst, u8 channel);
void WmSendAck(u16 _channelID, u8 _reportID);
static u32 convert24bit(const u8* src) {
return (src[0] << 16) | (src[1] << 8) | src[2];
@ -202,7 +202,11 @@ extern "C" void Wiimote_Input(u16 _channelID, const void* _pData, u32 _Size)
switch(hidp->param)
{
case HID_PARAM_OUTPUT:
HidOutputReport(_channelID, (wm_report*)hidp->data);
{
wm_report* sr = (wm_report*)hidp->data;
WmSendAck(_channelID, sr->channel);
HidOutputReport(_channelID, sr);
}
break;
default:
@ -278,7 +282,7 @@ extern "C" void Wiimote_Update() {
switch(g_ReportingMode) {
case 0:
break;
case WM_REPORT_CORE: SendReportCoreAccel(g_ReportingChannel); break;
case WM_REPORT_CORE: SendReportCore(g_ReportingChannel); break;
case WM_REPORT_CORE_ACCEL: SendReportCoreAccel(g_ReportingChannel); break;
case WM_REPORT_CORE_ACCEL_IR12: SendReportCoreAccelIr12(g_ReportingChannel);break;
}
@ -299,6 +303,7 @@ void HidOutputReport(u16 _channelID, wm_report* sr) {
{
case WM_LEDS:
WmLeds(_channelID, (wm_leds*)sr->data);
// WmSendAck(_channelID, WM_LEDS);
break;
case WM_READ_DATA:
WmReadData(_channelID, (wm_read_data*)sr->data);
@ -309,6 +314,7 @@ void HidOutputReport(u16 _channelID, wm_report* sr) {
case WM_IR_PIXEL_CLOCK:
case WM_IR_LOGIC:
LOG(WIIMOTE, " IR Enable 0x%02x 0x%02x", sr->channel, sr->data[0]);
// WmSendAck(_channelID, WM_IR_LOGIC);
break;
case WM_WRITE_DATA:
WmWriteData(_channelID, (wm_write_data*)sr->data);
@ -330,8 +336,36 @@ void WmLeds(u16 _channelID, wm_leds* leds) {
g_Leds = leds->leds;
}
void WmSendAck(u16 _channelID, u8 _reportID)
{
void WmDataReporting(u16 _channelID, wm_data_reporting* dr) {
u8 DataFrame[1024];
u32 Offset = 0;
// header
hid_packet* pHidHeader = (hid_packet*)(DataFrame + Offset);
pHidHeader->type = HID_TYPE_DATA;
pHidHeader->param = HID_PARAM_INPUT;
Offset += sizeof(hid_packet);
wm_acknowledge* pData = (wm_acknowledge*)(DataFrame + Offset);
pData->Channel = WM_WRITE_DATA_REPLY;
pData->unk0 = 0;
pData->unk1 = 0;
pData->reportID = _reportID;
pData->errorID = 0;
Offset += sizeof(wm_acknowledge);
LOG(WIIMOTE, " WMSendAck()");
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
}
void WmDataReporting(u16 _channelID, wm_data_reporting* dr)
{
LOG(WIIMOTE, " Set Data reporting mode");
LOG(WIIMOTE, " Rumble: %x", dr->rumble);
LOG(WIIMOTE, " Continuous: %x", dr->continuous);
@ -341,7 +375,7 @@ void WmDataReporting(u16 _channelID, wm_data_reporting* dr) {
g_ReportingMode = dr->mode;
g_ReportingChannel = _channelID;
switch(g_ReportingMode) { //see Wiimote_Update()
switch(dr->mode) { //see Wiimote_Update()
case 0x30:
case 0x31:
case 0x33:
@ -349,26 +383,30 @@ void WmDataReporting(u16 _channelID, wm_data_reporting* dr) {
default:
PanicAlert("Wiimote: Unknown reporting mode 0x%x", dr->mode);
}
// WmSendAck(_channelID, WM_DATA_REPORTING);
}
void FillReportInfo(wm_report_core& _reportCore)
void FillReportInfo(wm_core& _core)
{
static bool bb = true;
bb = !bb;
_reportCore.c.a = bb ? 1 : 0;
_core.a = GetAsyncKeyState(VK_LBUTTON) ? 1 : 0;
_core.b = GetAsyncKeyState(VK_RBUTTON) ? 1 : 0;
}
void SendReportCore(u16 _channelID) {
void SendReportCore(u16 _channelID)
{
u8 DataFrame[1024];
u32 Offset = WriteWmReport(_channelID, DataFrame, WM_REPORT_CORE);
u32 Offset = WriteWmReport(DataFrame, WM_REPORT_CORE);
wm_report_core* pReport = (wm_report_core*)(DataFrame + Offset);
Offset += sizeof(wm_report_core);
memset(pReport, 0, sizeof(wm_report_core));
FillReportInfo(*pReport);
FillReportInfo(pReport->c);
LOG(WIIMOTE, " SendReportCore()");
@ -378,7 +416,7 @@ void SendReportCore(u16 _channelID) {
void SendReportCoreAccelIr12(u16 _channelID) {
u8 DataFrame[1024];
u32 Offset = WriteWmReport(_channelID, DataFrame, WM_REPORT_CORE_ACCEL_IR12);
u32 Offset = WriteWmReport(DataFrame, WM_REPORT_CORE_ACCEL_IR12);
wm_report_core_accel_ir12* pReport = (wm_report_core_accel_ir12*)(DataFrame + Offset);
Offset += sizeof(wm_report_core_accel_ir12);
@ -437,7 +475,7 @@ void SendReportCoreAccelIr12(u16 _channelID) {
void SendReportCoreAccel(u16 _channelID) {
u8 DataFrame[1024];
u32 Offset = WriteWmReport(_channelID, DataFrame, WM_REPORT_CORE_ACCEL);
u32 Offset = WriteWmReport(DataFrame, WM_REPORT_CORE_ACCEL);
wm_report_core_accel* pReport = (wm_report_core_accel*)(DataFrame + Offset);
Offset += sizeof(wm_report_core_accel);
@ -462,10 +500,12 @@ void WmReadData(u16 _channelID, wm_read_data* rd) {
LOG(WIIMOTE, " Size: 0x%04x", size);
LOG(WIIMOTE, " Rumble: %x", rd->rumble);
if(size <= 16 && rd->space == 0) {
if(size <= 100 && rd->space == 0) {
SendReadDataReply(_channelID, g_Eeprom, address, (u8)size);
} else {
PanicAlert("WmReadData: unimplemented parameters!");
}
else
{
PanicAlert("WmReadData: unimplemented parameters (size: %i, addr: 0x%x!", size, rd->space);
}
}
@ -484,7 +524,8 @@ void WmWriteData(u16 _channelID, wm_write_data* wd) {
return;
}
memcpy(g_Eeprom + address, wd->data, wd->size);
SendWriteDataReply(_channelID);
// WmSendAck(_channelID, WM_WRITE_DATA);
}
else if(wd->size <= 16 && (wd->space == WM_SPACE_REGS1 || wd->space == WM_SPACE_REGS2))
{
@ -513,22 +554,14 @@ void WmWriteData(u16 _channelID, wm_write_data* wd) {
return;
}
memcpy(block + address, wd->data, wd->size);
SendWriteDataReply(_channelID);
// WmSendAck(_channelID, WM_WRITE_DATA);
} else {
PanicAlert("WmWriteData: unimplemented parameters!");
}
}
void SendWriteDataReply(u16 _channelID) {
u8 DataFrame[1024];
u32 Offset = WriteWmReport(_channelID, DataFrame, WM_WRITE_DATA_REPLY);
LOG(WIIMOTE, " SendWriteDataReply()");
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
}
int WriteWmReport(u16 _channelID, u8* dst, u8 channel) {
int WriteWmReport(u8* dst, u8 channel) {
u32 Offset = 0;
hid_packet* pHidHeader = (hid_packet*)(dst + Offset);
Offset += sizeof(hid_packet);
@ -547,7 +580,7 @@ void WmRequestStatus(u16 _channelID, wm_request_status* rs) {
//SendStatusReport();
u8 DataFrame[1024];
u32 Offset = WriteWmReport(_channelID, DataFrame, WM_STATUS_REPORT);
u32 Offset = WriteWmReport(DataFrame, WM_STATUS_REPORT);
wm_status_report* pStatus = (wm_status_report*)(DataFrame + Offset);
Offset += sizeof(wm_status_report);
@ -566,7 +599,7 @@ void WmRequestStatus(u16 _channelID, wm_request_status* rs) {
void SendReadDataReply(u16 _channelID, void* _Base, u16 _Address, u8 _Size)
{
u8 DataFrame[1024];
u32 Offset = WriteWmReport(_channelID, DataFrame, WM_READ_DATA_REPLY);
u32 Offset = WriteWmReport(DataFrame, WM_READ_DATA_REPLY);
_dbg_assert_(WIIMOTE, _Size <= 16);

9
Source/Plugins/Plugin_Wiimote_Test/Src/wiimote_hid.h
View File

@ -80,6 +80,15 @@ struct wm_write_data {
};
#define WM_WRITE_DATA_REPLY 0x22 //empty, afaik
struct wm_acknowledge
{
u8 Channel;
u8 unk0;
u8 unk1;
u8 reportID;
u8 errorID;
};
#define WM_READ_DATA 0x17
struct wm_read_data {