The-Homebrew-Cloud/dolphin
2
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-02-04 03:46:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3318 from lioncash/const

Browse Source 
WII_IPC_HLE_Device_usb: const correctness for function parameters
This commit is contained in:
Markus Wick 2015-12-06 12:34:04 +01:00
commit a0ac2b8673
4 changed files with 330 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Source/Core/Core/Debugger/Debugger_SymbolMap.cpp
View File

@ -145,17 +145,17 @@ void PrintCallstack(LogTypes::LOG_TYPE type, LogTypes::LOG_LEVELS level)
}); });
} }
void PrintDataBuffer(LogTypes::LOG_TYPE type, u8* _pData, size_t _Size, const std::string& _title) void PrintDataBuffer(LogTypes::LOG_TYPE type, const u8* data, size_t size, const std::string& title)
{ {
GENERIC_LOG(type, LogTypes::LDEBUG, "%s", _title.c_str()); GENERIC_LOG(type, LogTypes::LDEBUG, "%s", title.c_str());
for (u32 j = 0; j < _Size;) for (u32 j = 0; j < size;)
{ {
std::string hex_line = ""; std::string hex_line = "";
for (int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
{ {
hex_line += StringFromFormat("%02x ", _pData[j++]); hex_line += StringFromFormat("%02x ", data[j++]);
if (j >= _Size) if (j >= size)
break; break;
} }
GENERIC_LOG(type, LogTypes::LDEBUG, " Data: %s", hex_line.c_str()); GENERIC_LOG(type, LogTypes::LDEBUG, " Data: %s", hex_line.c_str());

2
Source/Core/Core/Debugger/Debugger_SymbolMap.h
View File

@ -22,7 +22,7 @@ struct CallstackEntry
bool GetCallstack(std::vector<CallstackEntry> &output); bool GetCallstack(std::vector<CallstackEntry> &output);
void PrintCallstack(); void PrintCallstack();
void PrintCallstack(LogTypes::LOG_TYPE type, LogTypes::LOG_LEVELS level); void PrintCallstack(LogTypes::LOG_TYPE type, LogTypes::LOG_LEVELS level);
void PrintDataBuffer(LogTypes::LOG_TYPE _Log, u8* _pData, size_t _Size, const std::string& _title); void PrintDataBuffer(LogTypes::LOG_TYPE type, const u8* data, size_t size, const std::string& title);
void AddAutoBreakpoints(); void AddAutoBreakpoints();

580
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_usb.cpp
View File

@ -353,29 +353,29 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::IncDataPacket(u16 _ConnectionHandle)
// Here we send ACL packets to CPU. They will consist of header + data. // Here we send ACL packets to CPU. They will consist of header + data.
// The header is for example 07 00 41 00 which means size 0x0007 and channel 0x0041. // The header is for example 07 00 41 00 which means size 0x0007 and channel 0x0041.
void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendACLPacket(u16 _ConnectionHandle, u8* _pData, u32 _Size) void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendACLPacket(u16 connection_handle, const u8* data, u32 size)
{ {
DEBUG_LOG(WII_IPC_WIIMOTE, "ACL packet from %x ready to send to stack...", _ConnectionHandle); DEBUG_LOG(WII_IPC_WIIMOTE, "ACL packet from %x ready to send to stack...", connection_handle);
if (m_ACLEndpoint.IsValid() && !m_HCIEndpoint.IsValid() && m_EventQueue.empty()) if (m_ACLEndpoint.IsValid() && !m_HCIEndpoint.IsValid() && m_EventQueue.empty())
{ {
DEBUG_LOG(WII_IPC_WIIMOTE, "ACL endpoint valid, sending packet to %08x", m_ACLEndpoint.m_address); DEBUG_LOG(WII_IPC_WIIMOTE, "ACL endpoint valid, sending packet to %08x", m_ACLEndpoint.m_address);
hci_acldata_hdr_t* pHeader = (hci_acldata_hdr_t*)Memory::GetPointer(m_ACLEndpoint.m_buffer); hci_acldata_hdr_t* header = reinterpret_cast<hci_acldata_hdr_t*>(Memory::GetPointer(m_ACLEndpoint.m_buffer));
pHeader->con_handle = HCI_MK_CON_HANDLE(_ConnectionHandle, HCI_PACKET_START, HCI_POINT2POINT); header->con_handle = HCI_MK_CON_HANDLE(connection_handle, HCI_PACKET_START, HCI_POINT2POINT);
pHeader->length = _Size; header->length = size;
// Write the packet to the buffer // Write the packet to the buffer
memcpy((u8*)pHeader + sizeof(hci_acldata_hdr_t), _pData, pHeader->length); memcpy(reinterpret_cast<u8*>(header) + sizeof(hci_acldata_hdr_t), data, header->length);
m_ACLEndpoint.SetRetVal(sizeof(hci_acldata_hdr_t) + _Size); m_ACLEndpoint.SetRetVal(sizeof(hci_acldata_hdr_t) + size);
EnqueueReply(m_ACLEndpoint.m_address); EnqueueReply(m_ACLEndpoint.m_address);
m_ACLEndpoint.Invalidate(); m_ACLEndpoint.Invalidate();
} }
else else
{ {
DEBUG_LOG(WII_IPC_WIIMOTE, "ACL endpoint not currently valid, queuing..."); DEBUG_LOG(WII_IPC_WIIMOTE, "ACL endpoint not currently valid, queuing...");
m_acl_pool.Store(_pData, _Size, _ConnectionHandle); m_acl_pool.Store(data, size, connection_handle);
} }
} }
@ -820,28 +820,28 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventReadRemoteVerInfo(u16 _connec
return true; return true;
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventCommandComplete(u16 _OpCode, void* _pData, u32 _DataSize) void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventCommandComplete(u16 opcode, const void* data, u32 data_size)
{ {
_dbg_assert_(WII_IPC_WIIMOTE, (sizeof(SHCIEventCommand) - 2 + _DataSize) < 256); _dbg_assert_(WII_IPC_WIIMOTE, (sizeof(SHCIEventCommand) - 2 + data_size) < 256);
SQueuedEvent Event(sizeof(SHCIEventCommand) + _DataSize, 0); SQueuedEvent event(sizeof(SHCIEventCommand) + data_size, 0);
SHCIEventCommand* pHCIEvent = (SHCIEventCommand*)Event.m_buffer; SHCIEventCommand* hci_event = reinterpret_cast<SHCIEventCommand*>(event.m_buffer);
pHCIEvent->EventType = HCI_EVENT_COMMAND_COMPL; hci_event->EventType = HCI_EVENT_COMMAND_COMPL;
pHCIEvent->PayloadLength = (u8)(sizeof(SHCIEventCommand) - 2 + _DataSize); hci_event->PayloadLength = (u8)(sizeof(SHCIEventCommand) - 2 + data_size);
pHCIEvent->PacketIndicator = 0x01; hci_event->PacketIndicator = 0x01;
pHCIEvent->Opcode = _OpCode; hci_event->Opcode = opcode;
// add the payload // add the payload
if ((_pData != nullptr) && (_DataSize > 0)) if (data != nullptr && data_size > 0)
{ {
u8* pPayload = Event.m_buffer + sizeof(SHCIEventCommand); u8* payload = event.m_buffer + sizeof(SHCIEventCommand);
memcpy(pPayload, _pData, _DataSize); memcpy(payload, data, data_size);
} }
INFO_LOG(WII_IPC_WIIMOTE, "Event: Command Complete (Opcode: 0x%04x)", pHCIEvent->Opcode); INFO_LOG(WII_IPC_WIIMOTE, "Event: Command Complete (Opcode: 0x%04x)", hci_event->Opcode);
AddEventToQueue(Event); AddEventToQueue(event);
} }
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventCommandStatus(u16 _Opcode) bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventCommandStatus(u16 _Opcode)
@ -1248,78 +1248,78 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::ExecuteHCICommandMessage(const SHCICom
// --- command helper // --- command helper
// //
// //
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandInquiry(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandInquiry(const u8* input)
{ {
// Inquiry should not be called normally // Inquiry should not be called normally
hci_inquiry_cp* pInquiry = (hci_inquiry_cp*)_Input; const hci_inquiry_cp* inquiry = reinterpret_cast<const hci_inquiry_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_INQUIRY:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_INQUIRY:");
DEBUG_LOG(WII_IPC_WIIMOTE, "write:"); DEBUG_LOG(WII_IPC_WIIMOTE, "write:");
DEBUG_LOG(WII_IPC_WIIMOTE, " LAP[0]: 0x%02x", pInquiry->lap[0]); DEBUG_LOG(WII_IPC_WIIMOTE, " LAP[0]: 0x%02x", inquiry->lap[0]);
DEBUG_LOG(WII_IPC_WIIMOTE, " LAP[1]: 0x%02x", pInquiry->lap[1]); DEBUG_LOG(WII_IPC_WIIMOTE, " LAP[1]: 0x%02x", inquiry->lap[1]);
DEBUG_LOG(WII_IPC_WIIMOTE, " LAP[2]: 0x%02x", pInquiry->lap[2]); DEBUG_LOG(WII_IPC_WIIMOTE, " LAP[2]: 0x%02x", inquiry->lap[2]);
DEBUG_LOG(WII_IPC_WIIMOTE, " inquiry_length: %i (N x 1.28) sec", pInquiry->inquiry_length); DEBUG_LOG(WII_IPC_WIIMOTE, " inquiry_length: %i (N x 1.28) sec", inquiry->inquiry_length);
DEBUG_LOG(WII_IPC_WIIMOTE, " num_responses: %i (N x 1.28) sec", pInquiry->num_responses); DEBUG_LOG(WII_IPC_WIIMOTE, " num_responses: %i (N x 1.28) sec", inquiry->num_responses);
SendEventCommandStatus(HCI_CMD_INQUIRY); SendEventCommandStatus(HCI_CMD_INQUIRY);
SendEventInquiryResponse(); SendEventInquiryResponse();
SendEventInquiryComplete(); SendEventInquiryComplete();
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandInquiryCancel(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandInquiryCancel(const u8* input)
{ {
hci_inquiry_cancel_rp Reply; hci_inquiry_cancel_rp reply;
Reply.status = 0x00; reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_INQUIRY_CANCEL"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_INQUIRY_CANCEL");
SendEventCommandComplete(HCI_CMD_INQUIRY_CANCEL, &Reply, sizeof(hci_inquiry_cancel_rp)); SendEventCommandComplete(HCI_CMD_INQUIRY_CANCEL, &reply, sizeof(hci_inquiry_cancel_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandCreateCon(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandCreateCon(const u8* input)
{ {
hci_create_con_cp* pCreateCon = (hci_create_con_cp*)_Input; const hci_create_con_cp* create_connection = reinterpret_cast<const hci_create_con_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_CREATE_CON"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_CREATE_CON");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input:"); DEBUG_LOG(WII_IPC_WIIMOTE, "Input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pCreateCon->bdaddr.b[0], pCreateCon->bdaddr.b[1], pCreateCon->bdaddr.b[2], create_connection->bdaddr.b[0], create_connection->bdaddr.b[1], create_connection->bdaddr.b[2],
pCreateCon->bdaddr.b[3], pCreateCon->bdaddr.b[4], pCreateCon->bdaddr.b[5]); create_connection->bdaddr.b[3], create_connection->bdaddr.b[4], create_connection->bdaddr.b[5]);
DEBUG_LOG(WII_IPC_WIIMOTE, " pkt_type: %i", pCreateCon->pkt_type); DEBUG_LOG(WII_IPC_WIIMOTE, " pkt_type: %i", create_connection->pkt_type);
DEBUG_LOG(WII_IPC_WIIMOTE, " page_scan_rep_mode: %i", pCreateCon->page_scan_rep_mode); DEBUG_LOG(WII_IPC_WIIMOTE, " page_scan_rep_mode: %i", create_connection->page_scan_rep_mode);
DEBUG_LOG(WII_IPC_WIIMOTE, " page_scan_mode: %i", pCreateCon->page_scan_mode); DEBUG_LOG(WII_IPC_WIIMOTE, " page_scan_mode: %i", create_connection->page_scan_mode);
DEBUG_LOG(WII_IPC_WIIMOTE, " clock_offset: %i", pCreateCon->clock_offset); DEBUG_LOG(WII_IPC_WIIMOTE, " clock_offset: %i", create_connection->clock_offset);
DEBUG_LOG(WII_IPC_WIIMOTE, " accept_role_switch: %i", pCreateCon->accept_role_switch); DEBUG_LOG(WII_IPC_WIIMOTE, " accept_role_switch: %i", create_connection->accept_role_switch);
SendEventCommandStatus(HCI_CMD_CREATE_CON); SendEventCommandStatus(HCI_CMD_CREATE_CON);
SendEventConnectionComplete(pCreateCon->bdaddr); SendEventConnectionComplete(create_connection->bdaddr);
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandDisconnect(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandDisconnect(const u8* input)
{ {
hci_discon_cp* pDiscon = (hci_discon_cp*)_Input; const hci_discon_cp* disconnect = reinterpret_cast<const hci_discon_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_DISCONNECT"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_DISCONNECT");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pDiscon->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", disconnect->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " Reason: 0x%02x", pDiscon->reason); DEBUG_LOG(WII_IPC_WIIMOTE, " Reason: 0x%02x", disconnect->reason);
Host_SetWiiMoteConnectionState(0); Host_SetWiiMoteConnectionState(0);
DisplayDisconnectMessage((pDiscon->con_handle & 0xFF) + 1, pDiscon->reason); DisplayDisconnectMessage((disconnect->con_handle & 0xFF) + 1, disconnect->reason);
SendEventCommandStatus(HCI_CMD_DISCONNECT); SendEventCommandStatus(HCI_CMD_DISCONNECT);
SendEventDisconnect(pDiscon->con_handle, pDiscon->reason); SendEventDisconnect(disconnect->con_handle, disconnect->reason);
CWII_IPC_HLE_WiiMote* pWiimote = AccessWiiMote(pDiscon->con_handle); CWII_IPC_HLE_WiiMote* wiimote = AccessWiiMote(disconnect->con_handle);
if (pWiimote) if (wiimote)
pWiimote->EventDisconnect(); wiimote->EventDisconnect();
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandAcceptCon(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandAcceptCon(const u8* input)
{ {
hci_accept_con_cp* pAcceptCon = (hci_accept_con_cp*)_Input; const hci_accept_con_cp* accept_connection = reinterpret_cast<const hci_accept_con_cp*>(input);
static char s_szRole[][128] = static char roles[][128] =
{ {
{ "Master (0x00)"}, { "Master (0x00)"},
{ "Slave (0x01)"}, { "Slave (0x01)"},
@ -1327,210 +1327,204 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandAcceptCon(u8* _Input)
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_ACCEPT_CON"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_ACCEPT_CON");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pAcceptCon->bdaddr.b[0], pAcceptCon->bdaddr.b[1], pAcceptCon->bdaddr.b[2], accept_connection->bdaddr.b[0], accept_connection->bdaddr.b[1], accept_connection->bdaddr.b[2],
pAcceptCon->bdaddr.b[3], pAcceptCon->bdaddr.b[4], pAcceptCon->bdaddr.b[5]); accept_connection->bdaddr.b[3], accept_connection->bdaddr.b[4], accept_connection->bdaddr.b[5]);
DEBUG_LOG(WII_IPC_WIIMOTE, " role: %s", s_szRole[pAcceptCon->role]); DEBUG_LOG(WII_IPC_WIIMOTE, " role: %s", roles[accept_connection->role]);
SendEventCommandStatus(HCI_CMD_ACCEPT_CON); SendEventCommandStatus(HCI_CMD_ACCEPT_CON);
// this connection wants to be the master // this connection wants to be the master
if (pAcceptCon->role == 0) if (accept_connection->role == 0)
{ {
SendEventRoleChange(pAcceptCon->bdaddr, true); SendEventRoleChange(accept_connection->bdaddr, true);
} }
SendEventConnectionComplete(pAcceptCon->bdaddr); SendEventConnectionComplete(accept_connection->bdaddr);
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandLinkKeyRep(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandLinkKeyRep(const u8* input)
{ {
hci_link_key_rep_cp* pKeyRep = (hci_link_key_rep_cp*)_Input; const hci_link_key_rep_cp* key_rep = reinterpret_cast<const hci_link_key_rep_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_LINK_KEY_REP"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_LINK_KEY_REP");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pKeyRep->bdaddr.b[0], pKeyRep->bdaddr.b[1], pKeyRep->bdaddr.b[2], key_rep->bdaddr.b[0], key_rep->bdaddr.b[1], key_rep->bdaddr.b[2],
pKeyRep->bdaddr.b[3], pKeyRep->bdaddr.b[4], pKeyRep->bdaddr.b[5]); key_rep->bdaddr.b[3], key_rep->bdaddr.b[4], key_rep->bdaddr.b[5]);
LOG_LinkKey(pKeyRep->key); LOG_LinkKey(key_rep->key);
hci_link_key_rep_rp Reply; hci_link_key_rep_rp reply;
Reply.status = 0x00; reply.status = 0x00;
Reply.bdaddr = pKeyRep->bdaddr; reply.bdaddr = key_rep->bdaddr;
SendEventCommandComplete(HCI_CMD_LINK_KEY_REP, &Reply, sizeof(hci_link_key_rep_rp)); SendEventCommandComplete(HCI_CMD_LINK_KEY_REP, &reply, sizeof(hci_link_key_rep_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandLinkKeyNegRep(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandLinkKeyNegRep(const u8* input)
{ {
hci_link_key_neg_rep_cp* pKeyNeg = (hci_link_key_neg_rep_cp*)_Input; const hci_link_key_neg_rep_cp* key_neg = reinterpret_cast<const hci_link_key_neg_rep_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_LINK_KEY_NEG_REP"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_LINK_KEY_NEG_REP");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pKeyNeg->bdaddr.b[0], pKeyNeg->bdaddr.b[1], pKeyNeg->bdaddr.b[2], key_neg->bdaddr.b[0], key_neg->bdaddr.b[1], key_neg->bdaddr.b[2],
pKeyNeg->bdaddr.b[3], pKeyNeg->bdaddr.b[4], pKeyNeg->bdaddr.b[5]); key_neg->bdaddr.b[3], key_neg->bdaddr.b[4], key_neg->bdaddr.b[5]);
hci_link_key_neg_rep_rp Reply; hci_link_key_neg_rep_rp reply;
Reply.status = 0x00; reply.status = 0x00;
Reply.bdaddr = pKeyNeg->bdaddr; reply.bdaddr = key_neg->bdaddr;
SendEventCommandComplete(HCI_CMD_LINK_KEY_NEG_REP, &Reply, sizeof(hci_link_key_neg_rep_rp)); SendEventCommandComplete(HCI_CMD_LINK_KEY_NEG_REP, &reply, sizeof(hci_link_key_neg_rep_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandChangeConPacketType(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandChangeConPacketType(const u8* input)
{ {
hci_change_con_pkt_type_cp* pChangePacketType = (hci_change_con_pkt_type_cp*)_Input; const hci_change_con_pkt_type_cp* change_packet_type = reinterpret_cast<const hci_change_con_pkt_type_cp*>(input);
// ntd stack sets packet type 0xcc18, which is HCI_PKT_DH5 | HCI_PKT_DM5 | HCI_PKT_DH1 | HCI_PKT_DM1 // ntd stack sets packet type 0xcc18, which is HCI_PKT_DH5 | HCI_PKT_DM5 | HCI_PKT_DH1 | HCI_PKT_DM1
// dunno what to do...run awayyyyyy! // dunno what to do...run awayyyyyy!
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_CHANGE_CON_PACKET_TYPE"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_CHANGE_CON_PACKET_TYPE");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pChangePacketType->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", change_packet_type->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " PacketType: 0x%04x", pChangePacketType->pkt_type); DEBUG_LOG(WII_IPC_WIIMOTE, " PacketType: 0x%04x", change_packet_type->pkt_type);
SendEventCommandStatus(HCI_CMD_CHANGE_CON_PACKET_TYPE); SendEventCommandStatus(HCI_CMD_CHANGE_CON_PACKET_TYPE);
SendEventConPacketTypeChange(pChangePacketType->con_handle, pChangePacketType->pkt_type); SendEventConPacketTypeChange(change_packet_type->con_handle, change_packet_type->pkt_type);
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandAuthenticationRequested(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandAuthenticationRequested(const u8* input)
{ {
hci_auth_req_cp* pAuthReq = (hci_auth_req_cp*)_Input; const hci_auth_req_cp* auth_req = reinterpret_cast<const hci_auth_req_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_AUTH_REQ"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_AUTH_REQ");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pAuthReq->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", auth_req->con_handle);
SendEventCommandStatus(HCI_CMD_AUTH_REQ); SendEventCommandStatus(HCI_CMD_AUTH_REQ);
SendEventAuthenticationCompleted(pAuthReq->con_handle); SendEventAuthenticationCompleted(auth_req->con_handle);
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandRemoteNameReq(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandRemoteNameReq(const u8* input)
{ {
hci_remote_name_req_cp* pRemoteNameReq = (hci_remote_name_req_cp*)_Input; const hci_remote_name_req_cp* remote_name_req = reinterpret_cast<const hci_remote_name_req_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_REMOTE_NAME_REQ"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_REMOTE_NAME_REQ");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pRemoteNameReq->bdaddr.b[0], pRemoteNameReq->bdaddr.b[1], pRemoteNameReq->bdaddr.b[2], remote_name_req->bdaddr.b[0], remote_name_req->bdaddr.b[1], remote_name_req->bdaddr.b[2],
pRemoteNameReq->bdaddr.b[3], pRemoteNameReq->bdaddr.b[4], pRemoteNameReq->bdaddr.b[5]); remote_name_req->bdaddr.b[3], remote_name_req->bdaddr.b[4], remote_name_req->bdaddr.b[5]);
DEBUG_LOG(WII_IPC_WIIMOTE, " page_scan_rep_mode: %i", pRemoteNameReq->page_scan_rep_mode); DEBUG_LOG(WII_IPC_WIIMOTE, " page_scan_rep_mode: %i", remote_name_req->page_scan_rep_mode);
DEBUG_LOG(WII_IPC_WIIMOTE, " page_scan_mode: %i", pRemoteNameReq->page_scan_mode); DEBUG_LOG(WII_IPC_WIIMOTE, " page_scan_mode: %i", remote_name_req->page_scan_mode);
DEBUG_LOG(WII_IPC_WIIMOTE, " clock_offset: %i", pRemoteNameReq->clock_offset); DEBUG_LOG(WII_IPC_WIIMOTE, " clock_offset: %i", remote_name_req->clock_offset);
SendEventCommandStatus(HCI_CMD_REMOTE_NAME_REQ); SendEventCommandStatus(HCI_CMD_REMOTE_NAME_REQ);
SendEventRemoteNameReq(pRemoteNameReq->bdaddr); SendEventRemoteNameReq(remote_name_req->bdaddr);
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadRemoteFeatures(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadRemoteFeatures(const u8* input)
{ {
hci_read_remote_features_cp* pReadRemoteFeatures = (hci_read_remote_features_cp*)_Input; const hci_read_remote_features_cp* read_remote_features = reinterpret_cast<const hci_read_remote_features_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_REMOTE_FEATURES"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_REMOTE_FEATURES");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pReadRemoteFeatures->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", read_remote_features->con_handle);
SendEventCommandStatus(HCI_CMD_READ_REMOTE_FEATURES); SendEventCommandStatus(HCI_CMD_READ_REMOTE_FEATURES);
SendEventReadRemoteFeatures(pReadRemoteFeatures->con_handle); SendEventReadRemoteFeatures(read_remote_features->con_handle);
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadRemoteVerInfo(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadRemoteVerInfo(const u8* input)
{ {
hci_read_remote_ver_info_cp* pReadRemoteVerInfo = (hci_read_remote_ver_info_cp*)_Input; const hci_read_remote_ver_info_cp* read_remote_ver_info = reinterpret_cast<const hci_read_remote_ver_info_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_REMOTE_VER_INFO"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_REMOTE_VER_INFO");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%02x", pReadRemoteVerInfo->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%02x", read_remote_ver_info->con_handle);
SendEventCommandStatus(HCI_CMD_READ_REMOTE_VER_INFO); SendEventCommandStatus(HCI_CMD_READ_REMOTE_VER_INFO);
SendEventReadRemoteVerInfo(pReadRemoteVerInfo->con_handle); SendEventReadRemoteVerInfo(read_remote_ver_info->con_handle);
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadClockOffset(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadClockOffset(const u8* input)
{ {
hci_read_clock_offset_cp* pReadClockOffset = (hci_read_clock_offset_cp*)_Input; const hci_read_clock_offset_cp* read_clock_offset = reinterpret_cast<const hci_read_clock_offset_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_CLOCK_OFFSET"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_CLOCK_OFFSET");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%02x", pReadClockOffset->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%02x", read_clock_offset->con_handle);
SendEventCommandStatus(HCI_CMD_READ_CLOCK_OFFSET); SendEventCommandStatus(HCI_CMD_READ_CLOCK_OFFSET);
SendEventReadClockOffsetComplete(pReadClockOffset->con_handle); SendEventReadClockOffsetComplete(read_clock_offset->con_handle);
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandSniffMode(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandSniffMode(const u8* input)
{ {
hci_sniff_mode_cp* pSniffMode = (hci_sniff_mode_cp*)_Input; const hci_sniff_mode_cp* sniff_mode = reinterpret_cast<const hci_sniff_mode_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_SNIFF_MODE"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_SNIFF_MODE");
INFO_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pSniffMode->con_handle); INFO_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", sniff_mode->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " max_interval: %f msec", pSniffMode->max_interval * .625); DEBUG_LOG(WII_IPC_WIIMOTE, " max_interval: %f msec", sniff_mode->max_interval * .625);
DEBUG_LOG(WII_IPC_WIIMOTE, " min_interval: %f msec", pSniffMode->min_interval * .625); DEBUG_LOG(WII_IPC_WIIMOTE, " min_interval: %f msec", sniff_mode->min_interval * .625);
DEBUG_LOG(WII_IPC_WIIMOTE, " attempt: %f msec", pSniffMode->attempt * 1.25); DEBUG_LOG(WII_IPC_WIIMOTE, " attempt: %f msec", sniff_mode->attempt * 1.25);
DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: %f msec", pSniffMode->timeout * 1.25); DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: %f msec", sniff_mode->timeout * 1.25);
SendEventCommandStatus(HCI_CMD_SNIFF_MODE); SendEventCommandStatus(HCI_CMD_SNIFF_MODE);
SendEventModeChange(pSniffMode->con_handle, 0x02, pSniffMode->max_interval); // 0x02 - sniff mode SendEventModeChange(sniff_mode->con_handle, 0x02, sniff_mode->max_interval); // 0x02 - sniff mode
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLinkPolicy(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLinkPolicy(const u8* input)
{ {
hci_write_link_policy_settings_cp* pLinkPolicy = (hci_write_link_policy_settings_cp*)_Input; const hci_write_link_policy_settings_cp* link_policy = reinterpret_cast<const hci_write_link_policy_settings_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_LINK_POLICY_SETTINGS"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_LINK_POLICY_SETTINGS");
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", pLinkPolicy->con_handle); DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", link_policy->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " Policy: 0x%04x", pLinkPolicy->settings); DEBUG_LOG(WII_IPC_WIIMOTE, " Policy: 0x%04x", link_policy->settings);
//hci_write_link_policy_settings_rp Reply;
//Reply.status = 0x00;
//Reply.con_handle = pLinkPolicy->con_handle;
SendEventCommandStatus(HCI_CMD_WRITE_LINK_POLICY_SETTINGS); SendEventCommandStatus(HCI_CMD_WRITE_LINK_POLICY_SETTINGS);
//AccessWiiMote(pLinkPolicy->con_handle)->ResetChannels();
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReset(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReset(const u8* input)
{ {
hci_status_rp Reply; hci_status_rp reply;
Reply.status = 0x00; reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_RESET"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_RESET");
SendEventCommandComplete(HCI_CMD_RESET, &Reply, sizeof(hci_status_rp)); SendEventCommandComplete(HCI_CMD_RESET, &reply, sizeof(hci_status_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandSetEventFilter(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandSetEventFilter(const u8* input)
{ {
hci_set_event_filter_cp* pSetEventFilter = (hci_set_event_filter_cp*)_Input; const hci_set_event_filter_cp* set_event_filter = reinterpret_cast<const hci_set_event_filter_cp*>(input);
hci_set_event_filter_rp Reply; hci_set_event_filter_rp reply;
Reply.status = 0x00; reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_SET_EVENT_FILTER:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_SET_EVENT_FILTER:");
DEBUG_LOG(WII_IPC_WIIMOTE, " filter_type: %i", pSetEventFilter->filter_type); DEBUG_LOG(WII_IPC_WIIMOTE, " filter_type: %i", set_event_filter->filter_type);
DEBUG_LOG(WII_IPC_WIIMOTE, " filter_condition_type: %i", pSetEventFilter->filter_condition_type); DEBUG_LOG(WII_IPC_WIIMOTE, " filter_condition_type: %i", set_event_filter->filter_condition_type);
SendEventCommandComplete(HCI_CMD_SET_EVENT_FILTER, &Reply, sizeof(hci_set_event_filter_rp)); SendEventCommandComplete(HCI_CMD_SET_EVENT_FILTER, &reply, sizeof(hci_set_event_filter_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWritePinType(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWritePinType(const u8* input)
{ {
hci_write_pin_type_cp* pWritePinType = (hci_write_pin_type_cp*)_Input; const hci_write_pin_type_cp* write_pin_type = reinterpret_cast<const hci_write_pin_type_cp*>(input);
hci_write_pin_type_rp Reply; hci_write_pin_type_rp reply;
Reply.status = 0x00; reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PIN_TYPE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PIN_TYPE:");
DEBUG_LOG(WII_IPC_WIIMOTE, " pin_type: %x", pWritePinType->pin_type); DEBUG_LOG(WII_IPC_WIIMOTE, " pin_type: %x", write_pin_type->pin_type);
SendEventCommandComplete(HCI_CMD_WRITE_PIN_TYPE, &Reply, sizeof(hci_write_pin_type_rp)); SendEventCommandComplete(HCI_CMD_WRITE_PIN_TYPE, &reply, sizeof(hci_write_pin_type_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadStoredLinkKey(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadStoredLinkKey(const u8* input)
{ {
hci_read_stored_link_key_cp* ReadStoredLinkKey = (hci_read_stored_link_key_cp*)_Input; const hci_read_stored_link_key_cp* read_stored_link_key = reinterpret_cast<const hci_read_stored_link_key_cp*>(input);
hci_read_stored_link_key_rp Reply; hci_read_stored_link_key_rp reply;
Reply.status = 0x00; reply.status = 0x00;
Reply.num_keys_read = 0; reply.num_keys_read = 0;
Reply.max_num_keys = 255; reply.max_num_keys = 255;
if (ReadStoredLinkKey->read_all == 1) if (read_stored_link_key->read_all == 1)
{ {
Reply.num_keys_read = (u16)m_WiiMotes.size(); reply.num_keys_read = (u16)m_WiiMotes.size();
} }
else else
{ {
@ -1540,79 +1534,79 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadStoredLinkKey(u8* _Input)
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_STORED_LINK_KEY:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_STORED_LINK_KEY:");
DEBUG_LOG(WII_IPC_WIIMOTE, "input:"); DEBUG_LOG(WII_IPC_WIIMOTE, "input:");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
ReadStoredLinkKey->bdaddr.b[0], ReadStoredLinkKey->bdaddr.b[1], ReadStoredLinkKey->bdaddr.b[2], read_stored_link_key->bdaddr.b[0], read_stored_link_key->bdaddr.b[1], read_stored_link_key->bdaddr.b[2],
ReadStoredLinkKey->bdaddr.b[3], ReadStoredLinkKey->bdaddr.b[4], ReadStoredLinkKey->bdaddr.b[5]); read_stored_link_key->bdaddr.b[3], read_stored_link_key->bdaddr.b[4], read_stored_link_key->bdaddr.b[5]);
DEBUG_LOG(WII_IPC_WIIMOTE, " read_all: %i", ReadStoredLinkKey->read_all); DEBUG_LOG(WII_IPC_WIIMOTE, " read_all: %i", read_stored_link_key->read_all);
DEBUG_LOG(WII_IPC_WIIMOTE, "return:"); DEBUG_LOG(WII_IPC_WIIMOTE, "return:");
DEBUG_LOG(WII_IPC_WIIMOTE, " max_num_keys: %i", Reply.max_num_keys); DEBUG_LOG(WII_IPC_WIIMOTE, " max_num_keys: %i", reply.max_num_keys);
DEBUG_LOG(WII_IPC_WIIMOTE, " num_keys_read: %i", Reply.num_keys_read); DEBUG_LOG(WII_IPC_WIIMOTE, " num_keys_read: %i", reply.num_keys_read);
SendEventLinkKeyNotification((u8)Reply.num_keys_read); SendEventLinkKeyNotification((u8)reply.num_keys_read);
SendEventCommandComplete(HCI_CMD_READ_STORED_LINK_KEY, &Reply, sizeof(hci_read_stored_link_key_rp)); SendEventCommandComplete(HCI_CMD_READ_STORED_LINK_KEY, &reply, sizeof(hci_read_stored_link_key_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandDeleteStoredLinkKey(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandDeleteStoredLinkKey(const u8* input)
{ {
hci_delete_stored_link_key_cp* pDeleteStoredLinkKey = (hci_delete_stored_link_key_cp*)_Input; const hci_delete_stored_link_key_cp* delete_stored_link_key = reinterpret_cast<const hci_delete_stored_link_key_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_OCF_DELETE_STORED_LINK_KEY"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_OCF_DELETE_STORED_LINK_KEY");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pDeleteStoredLinkKey->bdaddr.b[0], pDeleteStoredLinkKey->bdaddr.b[1], pDeleteStoredLinkKey->bdaddr.b[2], delete_stored_link_key->bdaddr.b[0], delete_stored_link_key->bdaddr.b[1], delete_stored_link_key->bdaddr.b[2],
pDeleteStoredLinkKey->bdaddr.b[3], pDeleteStoredLinkKey->bdaddr.b[4], pDeleteStoredLinkKey->bdaddr.b[5]); delete_stored_link_key->bdaddr.b[3], delete_stored_link_key->bdaddr.b[4], delete_stored_link_key->bdaddr.b[5]);
DEBUG_LOG(WII_IPC_WIIMOTE, " delete_all: 0x%01x", pDeleteStoredLinkKey->delete_all); DEBUG_LOG(WII_IPC_WIIMOTE, " delete_all: 0x%01x", delete_stored_link_key->delete_all);
CWII_IPC_HLE_WiiMote* pWiiMote = AccessWiiMote(pDeleteStoredLinkKey->bdaddr); CWII_IPC_HLE_WiiMote* wiiMote = AccessWiiMote(delete_stored_link_key->bdaddr);
if (pWiiMote == nullptr) if (wiiMote == nullptr)
return; return;
hci_delete_stored_link_key_rp Reply; hci_delete_stored_link_key_rp reply;
Reply.status = 0x00; reply.status = 0x00;
Reply.num_keys_deleted = 0; reply.num_keys_deleted = 0;
SendEventCommandComplete(HCI_CMD_DELETE_STORED_LINK_KEY, &Reply, sizeof(hci_delete_stored_link_key_rp)); SendEventCommandComplete(HCI_CMD_DELETE_STORED_LINK_KEY, &reply, sizeof(hci_delete_stored_link_key_rp));
ERROR_LOG(WII_IPC_WIIMOTE, "HCI: CommandDeleteStoredLinkKey... Probably the security for linking has failed. Could be a problem with loading the SCONF"); ERROR_LOG(WII_IPC_WIIMOTE, "HCI: CommandDeleteStoredLinkKey... Probably the security for linking has failed. Could be a problem with loading the SCONF");
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLocalName(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLocalName(const u8* input)
{ {
hci_write_local_name_cp* pWriteLocalName = (hci_write_local_name_cp*)_Input; const hci_write_local_name_cp* write_local_name = reinterpret_cast<const hci_write_local_name_cp*>(input);
hci_write_local_name_rp Reply; hci_write_local_name_rp reply;
Reply.status = 0x00; reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_LOCAL_NAME:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_LOCAL_NAME:");
DEBUG_LOG(WII_IPC_WIIMOTE, " local_name: %s", pWriteLocalName->name); DEBUG_LOG(WII_IPC_WIIMOTE, " local_name: %s", write_local_name->name);
SendEventCommandComplete(HCI_CMD_WRITE_LOCAL_NAME, &Reply, sizeof(hci_write_local_name_rp)); SendEventCommandComplete(HCI_CMD_WRITE_LOCAL_NAME, &reply, sizeof(hci_write_local_name_rp));
} }
// Here we normally receive the timeout interval. // Here we normally receive the timeout interval.
// But not from homebrew games that use lwbt. Why not? // But not from homebrew games that use lwbt. Why not?
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWritePageTimeOut(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWritePageTimeOut(const u8* input)
{ {
hci_write_page_timeout_cp* pWritePageTimeOut = (hci_write_page_timeout_cp*)_Input; const hci_write_page_timeout_cp* write_page_timeout = reinterpret_cast<const hci_write_page_timeout_cp*>(input);
hci_host_buffer_size_rp Reply; hci_host_buffer_size_rp reply;
Reply.status = 0x00; reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PAGE_TIMEOUT:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PAGE_TIMEOUT:");
DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: %i", pWritePageTimeOut->timeout); DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: %i", write_page_timeout->timeout);
SendEventCommandComplete(HCI_CMD_WRITE_PAGE_TIMEOUT, &Reply, sizeof(hci_host_buffer_size_rp)); SendEventCommandComplete(HCI_CMD_WRITE_PAGE_TIMEOUT, &reply, sizeof(hci_host_buffer_size_rp));
} }
/* This will enable ScanEnable so that Update() can start the Wiimote. */ /* This will enable ScanEnable so that Update() can start the Wiimote. */
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteScanEnable(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteScanEnable(const u8* input)
{ {
hci_write_scan_enable_cp* pWriteScanEnable = (hci_write_scan_enable_cp*)_Input; const hci_write_scan_enable_cp* write_scan_enable = reinterpret_cast<const hci_write_scan_enable_cp*>(input);
m_ScanEnable = pWriteScanEnable->scan_enable; m_ScanEnable = write_scan_enable->scan_enable;
hci_write_scan_enable_rp Reply; hci_write_scan_enable_rp reply;
Reply.status = 0x00; reply.status = 0x00;
static char Scanning[][128] = static char scanning[][128] =
{ {
{ "HCI_NO_SCAN_ENABLE"}, { "HCI_NO_SCAN_ENABLE"},
{ "HCI_INQUIRY_SCAN_ENABLE"}, { "HCI_INQUIRY_SCAN_ENABLE"},
@ -1620,192 +1614,192 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteScanEnable(u8* _Input)
{ "HCI_INQUIRY_AND_PAGE_SCAN_ENABLE"}, { "HCI_INQUIRY_AND_PAGE_SCAN_ENABLE"},
}; };
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_SCAN_ENABLE: (0x%02x)", pWriteScanEnable->scan_enable); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_SCAN_ENABLE: (0x%02x)", write_scan_enable->scan_enable);
DEBUG_LOG(WII_IPC_WIIMOTE, " scan_enable: %s", Scanning[pWriteScanEnable->scan_enable]); DEBUG_LOG(WII_IPC_WIIMOTE, " scan_enable: %s", scanning[write_scan_enable->scan_enable]);
SendEventCommandComplete(HCI_CMD_WRITE_SCAN_ENABLE, &Reply, sizeof(hci_write_scan_enable_rp)); SendEventCommandComplete(HCI_CMD_WRITE_SCAN_ENABLE, &reply, sizeof(hci_write_scan_enable_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteUnitClass(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteUnitClass(const u8* input)
{ {
hci_write_unit_class_cp* pWriteUnitClass = (hci_write_unit_class_cp*)_Input; const hci_write_unit_class_cp* write_unit_class = reinterpret_cast<const hci_write_unit_class_cp*>(input);
hci_write_unit_class_rp Reply; hci_write_unit_class_rp reply;
Reply.status = 0x00; reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_UNIT_CLASS:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_UNIT_CLASS:");
DEBUG_LOG(WII_IPC_WIIMOTE, " COD[0]: 0x%02x", pWriteUnitClass->uclass[0]); DEBUG_LOG(WII_IPC_WIIMOTE, " COD[0]: 0x%02x", write_unit_class->uclass[0]);
DEBUG_LOG(WII_IPC_WIIMOTE, " COD[1]: 0x%02x", pWriteUnitClass->uclass[1]); DEBUG_LOG(WII_IPC_WIIMOTE, " COD[1]: 0x%02x", write_unit_class->uclass[1]);
DEBUG_LOG(WII_IPC_WIIMOTE, " COD[2]: 0x%02x", pWriteUnitClass->uclass[2]); DEBUG_LOG(WII_IPC_WIIMOTE, " COD[2]: 0x%02x", write_unit_class->uclass[2]);
SendEventCommandComplete(HCI_CMD_WRITE_UNIT_CLASS, &Reply, sizeof(hci_write_unit_class_rp)); SendEventCommandComplete(HCI_CMD_WRITE_UNIT_CLASS, &reply, sizeof(hci_write_unit_class_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandHostBufferSize(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandHostBufferSize(const u8* input)
{ {
hci_host_buffer_size_cp* pHostBufferSize = (hci_host_buffer_size_cp*)_Input; const hci_host_buffer_size_cp* host_buffer_size = reinterpret_cast<const hci_host_buffer_size_cp*>(input);
hci_host_buffer_size_rp Reply; hci_host_buffer_size_rp reply;
Reply.status = 0x00; reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_HOST_BUFFER_SIZE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_HOST_BUFFER_SIZE:");
DEBUG_LOG(WII_IPC_WIIMOTE, " max_acl_size: %i", pHostBufferSize->max_acl_size); DEBUG_LOG(WII_IPC_WIIMOTE, " max_acl_size: %i", host_buffer_size->max_acl_size);
DEBUG_LOG(WII_IPC_WIIMOTE, " max_sco_size: %i", pHostBufferSize->max_sco_size); DEBUG_LOG(WII_IPC_WIIMOTE, " max_sco_size: %i", host_buffer_size->max_sco_size);
DEBUG_LOG(WII_IPC_WIIMOTE, " num_acl_pkts: %i", pHostBufferSize->num_acl_pkts); DEBUG_LOG(WII_IPC_WIIMOTE, " num_acl_pkts: %i", host_buffer_size->num_acl_pkts);
DEBUG_LOG(WII_IPC_WIIMOTE, " num_sco_pkts: %i", pHostBufferSize->num_sco_pkts); DEBUG_LOG(WII_IPC_WIIMOTE, " num_sco_pkts: %i", host_buffer_size->num_sco_pkts);
SendEventCommandComplete(HCI_CMD_HOST_BUFFER_SIZE, &Reply, sizeof(hci_host_buffer_size_rp)); SendEventCommandComplete(HCI_CMD_HOST_BUFFER_SIZE, &reply, sizeof(hci_host_buffer_size_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLinkSupervisionTimeout(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteLinkSupervisionTimeout(const u8* input)
{ {
hci_write_link_supervision_timeout_cp* pSuperVision = (hci_write_link_supervision_timeout_cp*)_Input; const hci_write_link_supervision_timeout_cp* supervision = reinterpret_cast<const hci_write_link_supervision_timeout_cp*>(input);
// timeout of 0 means timing out is disabled // timeout of 0 means timing out is disabled
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_LINK_SUPERVISION_TIMEOUT"); 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, " con_handle: 0x%04x", supervision->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: 0x%02x", pSuperVision->timeout); DEBUG_LOG(WII_IPC_WIIMOTE, " timeout: 0x%02x", supervision->timeout);
hci_write_link_supervision_timeout_rp Reply; hci_write_link_supervision_timeout_rp reply;
Reply.status = 0x00; reply.status = 0x00;
Reply.con_handle = pSuperVision->con_handle; reply.con_handle = supervision->con_handle;
SendEventCommandComplete(HCI_CMD_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));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryScanType(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryScanType(const u8* input)
{ {
hci_write_inquiry_scan_type_cp* pSetEventFilter = (hci_write_inquiry_scan_type_cp*)_Input; const hci_write_inquiry_scan_type_cp* set_event_filter = reinterpret_cast<const hci_write_inquiry_scan_type_cp*>(input);
hci_write_inquiry_scan_type_rp Reply; hci_write_inquiry_scan_type_rp reply;
Reply.status = 0x00; reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_INQUIRY_SCAN_TYPE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_INQUIRY_SCAN_TYPE:");
DEBUG_LOG(WII_IPC_WIIMOTE, " type: %i", pSetEventFilter->type); DEBUG_LOG(WII_IPC_WIIMOTE, " type: %i", set_event_filter->type);
SendEventCommandComplete(HCI_CMD_WRITE_INQUIRY_SCAN_TYPE, &Reply, sizeof(hci_write_inquiry_scan_type_rp)); SendEventCommandComplete(HCI_CMD_WRITE_INQUIRY_SCAN_TYPE, &reply, sizeof(hci_write_inquiry_scan_type_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryMode(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryMode(const u8* input)
{ {
hci_write_inquiry_mode_cp* pInquiryMode = (hci_write_inquiry_mode_cp*)_Input; const hci_write_inquiry_mode_cp* inquiry_mode = reinterpret_cast<const hci_write_inquiry_mode_cp*>(input);
hci_write_inquiry_mode_rp Reply; hci_write_inquiry_mode_rp reply;
Reply.status = 0x00; reply.status = 0x00;
static char InquiryMode[][128] = static char inquiry_mode_tag[][128] =
{ {
{ "Standard Inquiry Result event format (default)" }, { "Standard Inquiry Result event format (default)" },
{ "Inquiry Result format with RSSI" }, { "Inquiry Result format with RSSI" },
{ "Inquiry Result with RSSI format or Extended Inquiry Result format" } { "Inquiry Result with RSSI format or Extended Inquiry Result format" }
}; };
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_INQUIRY_MODE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_INQUIRY_MODE:");
DEBUG_LOG(WII_IPC_WIIMOTE, " mode: %s", InquiryMode[pInquiryMode->mode]); DEBUG_LOG(WII_IPC_WIIMOTE, " mode: %s", inquiry_mode_tag[inquiry_mode->mode]);
SendEventCommandComplete(HCI_CMD_WRITE_INQUIRY_MODE, &Reply, sizeof(hci_write_inquiry_mode_rp)); SendEventCommandComplete(HCI_CMD_WRITE_INQUIRY_MODE, &reply, sizeof(hci_write_inquiry_mode_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWritePageScanType(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWritePageScanType(const u8* input)
{ {
hci_write_page_scan_type_cp* pWritePageScanType = (hci_write_page_scan_type_cp*)_Input; const hci_write_page_scan_type_cp* write_page_scan_type = reinterpret_cast<const hci_write_page_scan_type_cp*>(input);
hci_write_page_scan_type_rp Reply; hci_write_page_scan_type_rp reply;
Reply.status = 0x00; reply.status = 0x00;
static char PageScanType[][128] = static char page_scan_type[][128] =
{ {
{ "Mandatory: Standard Scan (default)" }, { "Mandatory: Standard Scan (default)" },
{ "Optional: Interlaced Scan" } { "Optional: Interlaced Scan" }
}; };
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PAGE_SCAN_TYPE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_PAGE_SCAN_TYPE:");
DEBUG_LOG(WII_IPC_WIIMOTE, " type: %s", PageScanType[pWritePageScanType->type]); DEBUG_LOG(WII_IPC_WIIMOTE, " type: %s", page_scan_type[write_page_scan_type->type]);
SendEventCommandComplete(HCI_CMD_WRITE_PAGE_SCAN_TYPE, &Reply, sizeof(hci_write_page_scan_type_rp)); SendEventCommandComplete(HCI_CMD_WRITE_PAGE_SCAN_TYPE, &reply, sizeof(hci_write_page_scan_type_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadLocalVer(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadLocalVer(const u8* input)
{ {
hci_read_local_ver_rp Reply; hci_read_local_ver_rp reply;
Reply.status = 0x00; reply.status = 0x00;
Reply.hci_version = 0x03; // HCI version: 1.1 reply.hci_version = 0x03; // HCI version: 1.1
Reply.hci_revision = 0x40a7; // current revision (?) reply.hci_revision = 0x40a7; // current revision (?)
Reply.lmp_version = 0x03; // LMP version: 1.1 reply.lmp_version = 0x03; // LMP version: 1.1
Reply.manufacturer = 0x000F; // manufacturer: reserved for tests reply.manufacturer = 0x000F; // manufacturer: reserved for tests
Reply.lmp_subversion = 0x430e; // LMP subversion reply.lmp_subversion = 0x430e; // LMP subversion
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_LOCAL_VER:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_LOCAL_VER:");
DEBUG_LOG(WII_IPC_WIIMOTE, "return:"); DEBUG_LOG(WII_IPC_WIIMOTE, "return:");
DEBUG_LOG(WII_IPC_WIIMOTE, " status: %i", Reply.status); DEBUG_LOG(WII_IPC_WIIMOTE, " status: %i", reply.status);
DEBUG_LOG(WII_IPC_WIIMOTE, " hci_revision: %i", Reply.hci_revision); DEBUG_LOG(WII_IPC_WIIMOTE, " hci_revision: %i", reply.hci_revision);
DEBUG_LOG(WII_IPC_WIIMOTE, " lmp_version: %i", Reply.lmp_version); DEBUG_LOG(WII_IPC_WIIMOTE, " lmp_version: %i", reply.lmp_version);
DEBUG_LOG(WII_IPC_WIIMOTE, " manufacturer: %i", Reply.manufacturer); DEBUG_LOG(WII_IPC_WIIMOTE, " manufacturer: %i", reply.manufacturer);
DEBUG_LOG(WII_IPC_WIIMOTE, " lmp_subversion: %i", Reply.lmp_subversion); DEBUG_LOG(WII_IPC_WIIMOTE, " lmp_subversion: %i", reply.lmp_subversion);
SendEventCommandComplete(HCI_CMD_READ_LOCAL_VER, &Reply, sizeof(hci_read_local_ver_rp)); SendEventCommandComplete(HCI_CMD_READ_LOCAL_VER, &reply, sizeof(hci_read_local_ver_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadLocalFeatures(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadLocalFeatures(const u8* input)
{ {
hci_read_local_features_rp Reply; hci_read_local_features_rp reply;
Reply.status = 0x00; reply.status = 0x00;
Reply.features[0] = 0xFF; reply.features[0] = 0xFF;
Reply.features[1] = 0xFF; reply.features[1] = 0xFF;
Reply.features[2] = 0x8D; reply.features[2] = 0x8D;
Reply.features[3] = 0xFE; reply.features[3] = 0xFE;
Reply.features[4] = 0x9B; reply.features[4] = 0x9B;
Reply.features[5] = 0xF9; reply.features[5] = 0xF9;
Reply.features[6] = 0x00; reply.features[6] = 0x00;
Reply.features[7] = 0x80; reply.features[7] = 0x80;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_LOCAL_FEATURES:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_LOCAL_FEATURES:");
DEBUG_LOG(WII_IPC_WIIMOTE, "return:"); DEBUG_LOG(WII_IPC_WIIMOTE, "return:");
DEBUG_LOG(WII_IPC_WIIMOTE, " features: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " features: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
Reply.features[0], Reply.features[1], Reply.features[2], reply.features[0], reply.features[1], reply.features[2],
Reply.features[3], Reply.features[4], Reply.features[5], reply.features[3], reply.features[4], reply.features[5],
Reply.features[6], Reply.features[7]); reply.features[6], reply.features[7]);
SendEventCommandComplete(HCI_CMD_READ_LOCAL_FEATURES, &Reply, sizeof(hci_read_local_features_rp)); SendEventCommandComplete(HCI_CMD_READ_LOCAL_FEATURES, &reply, sizeof(hci_read_local_features_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadBufferSize(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadBufferSize(const u8* input)
{ {
hci_read_buffer_size_rp Reply; hci_read_buffer_size_rp reply;
Reply.status = 0x00; reply.status = 0x00;
Reply.max_acl_size = m_acl_pkt_size; reply.max_acl_size = m_acl_pkt_size;
// Due to how the widcomm stack which Nintendo uses is coded, we must never // Due to how the widcomm stack which Nintendo uses is coded, we must never
// let the stack think the controller is buffering more than 10 data packets // let the stack think the controller is buffering more than 10 data packets
// - it will cause a u8 underflow and royally screw things up. // - it will cause a u8 underflow and royally screw things up.
Reply.num_acl_pkts = m_acl_pkts_num; reply.num_acl_pkts = m_acl_pkts_num;
Reply.max_sco_size = 64; reply.max_sco_size = 64;
Reply.num_sco_pkts = 0; reply.num_sco_pkts = 0;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_BUFFER_SIZE:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_BUFFER_SIZE:");
DEBUG_LOG(WII_IPC_WIIMOTE, "return:"); DEBUG_LOG(WII_IPC_WIIMOTE, "return:");
DEBUG_LOG(WII_IPC_WIIMOTE, " max_acl_size: %i", Reply.max_acl_size); DEBUG_LOG(WII_IPC_WIIMOTE, " max_acl_size: %i", reply.max_acl_size);
DEBUG_LOG(WII_IPC_WIIMOTE, " num_acl_pkts: %i", Reply.num_acl_pkts); DEBUG_LOG(WII_IPC_WIIMOTE, " num_acl_pkts: %i", reply.num_acl_pkts);
DEBUG_LOG(WII_IPC_WIIMOTE, " max_sco_size: %i", Reply.max_sco_size); DEBUG_LOG(WII_IPC_WIIMOTE, " max_sco_size: %i", reply.max_sco_size);
DEBUG_LOG(WII_IPC_WIIMOTE, " num_sco_pkts: %i", Reply.num_sco_pkts); DEBUG_LOG(WII_IPC_WIIMOTE, " num_sco_pkts: %i", reply.num_sco_pkts);
SendEventCommandComplete(HCI_CMD_READ_BUFFER_SIZE, &Reply, sizeof(hci_read_buffer_size_rp)); SendEventCommandComplete(HCI_CMD_READ_BUFFER_SIZE, &reply, sizeof(hci_read_buffer_size_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadBDAdrr(u8* _Input) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReadBDAdrr(const u8* input)
{ {
hci_read_bdaddr_rp Reply; hci_read_bdaddr_rp reply;
Reply.status = 0x00; reply.status = 0x00;
Reply.bdaddr = m_ControllerBD; reply.bdaddr = m_ControllerBD;
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_BDADDR:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_READ_BDADDR:");
DEBUG_LOG(WII_IPC_WIIMOTE, "return:"); DEBUG_LOG(WII_IPC_WIIMOTE, "return:");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
Reply.bdaddr.b[0], Reply.bdaddr.b[1], Reply.bdaddr.b[2], reply.bdaddr.b[0], reply.bdaddr.b[1], reply.bdaddr.b[2],
Reply.bdaddr.b[3], Reply.bdaddr.b[4], Reply.bdaddr.b[5]); reply.bdaddr.b[3], reply.bdaddr.b[4], reply.bdaddr.b[5]);
SendEventCommandComplete(HCI_CMD_READ_BDADDR, &Reply, sizeof(hci_read_bdaddr_rp)); SendEventCommandComplete(HCI_CMD_READ_BDADDR, &reply, sizeof(hci_read_bdaddr_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandVendorSpecific_FC4F(u8* _Input, u32 _Size) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandVendorSpecific_FC4F(const u8* input, u32 size)
{ {
// callstack... // callstack...
// BTM_VendorSpecificCommad() // BTM_VendorSpecificCommad()
@ -1814,27 +1808,27 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandVendorSpecific_FC4F(u8* _Input,
// WUDiGetFirmwareVersion() // WUDiGetFirmwareVersion()
// WUDiStackSetupComplete() // WUDiStackSetupComplete()
hci_status_rp Reply; hci_status_rp reply;
Reply.status = 0x00; reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: CommandVendorSpecific_FC4F: (callstack WUDiRemovePatch)"); INFO_LOG(WII_IPC_WIIMOTE, "Command: CommandVendorSpecific_FC4F: (callstack WUDiRemovePatch)");
INFO_LOG(WII_IPC_WIIMOTE, "Input (size 0x%x):", _Size); INFO_LOG(WII_IPC_WIIMOTE, "Input (size 0x%x):", size);
Dolphin_Debugger::PrintDataBuffer(LogTypes::WII_IPC_WIIMOTE, _Input, _Size, "Data: "); Dolphin_Debugger::PrintDataBuffer(LogTypes::WII_IPC_WIIMOTE, input, size, "Data: ");
SendEventCommandComplete(0xFC4F, &Reply, sizeof(hci_status_rp)); SendEventCommandComplete(0xFC4F, &reply, sizeof(hci_status_rp));
} }
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandVendorSpecific_FC4C(u8* _Input, u32 _Size) void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandVendorSpecific_FC4C(const u8* input, u32 size)
{ {
hci_status_rp Reply; hci_status_rp reply;
Reply.status = 0x00; reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: CommandVendorSpecific_FC4C:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: CommandVendorSpecific_FC4C:");
INFO_LOG(WII_IPC_WIIMOTE, "Input (size 0x%x):", _Size); INFO_LOG(WII_IPC_WIIMOTE, "Input (size 0x%x):", size);
Dolphin_Debugger::PrintDataBuffer(LogTypes::WII_IPC_WIIMOTE, _Input, _Size, "Data: "); Dolphin_Debugger::PrintDataBuffer(LogTypes::WII_IPC_WIIMOTE, input, size, "Data: ");
SendEventCommandComplete(0xFC4C, &Reply, sizeof(hci_status_rp)); SendEventCommandComplete(0xFC4C, &reply, sizeof(hci_status_rp));
} }

74
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_usb.h
View File

@ -63,7 +63,7 @@ public:
static void EnqueueReply(u32 CommandAddress); static void EnqueueReply(u32 CommandAddress);
// Send ACL data back to Bluetooth stack // Send ACL data back to Bluetooth stack
void SendACLPacket(u16 _ConnectionHandle, u8* _pData, u32 _Size); void SendACLPacket(u16 connection_handle, const u8* data, u32 size);
bool RemoteDisconnect(u16 _connectionHandle); bool RemoteDisconnect(u16 _connectionHandle);
@ -199,7 +199,7 @@ private:
// Events // Events
void AddEventToQueue(const SQueuedEvent& _event); void AddEventToQueue(const SQueuedEvent& _event);
bool SendEventCommandStatus(u16 _Opcode); bool SendEventCommandStatus(u16 _Opcode);
void SendEventCommandComplete(u16 _OpCode, void* _pData, u32 _DataSize); void SendEventCommandComplete(u16 opcode, const void* data, u32 data_size);
bool SendEventInquiryResponse(); bool SendEventInquiryResponse();
bool SendEventInquiryComplete(); bool SendEventInquiryComplete();
bool SendEventRemoteNameReq(const bdaddr_t& _bd); bool SendEventRemoteNameReq(const bdaddr_t& _bd);
@ -221,49 +221,49 @@ private:
void ExecuteHCICommandMessage(const SHCICommandMessage& _rCtrlMessage); void ExecuteHCICommandMessage(const SHCICommandMessage& _rCtrlMessage);
// OGF 0x01 - Link control commands and return parameters // OGF 0x01 - Link control commands and return parameters
void CommandWriteInquiryMode(u8* _Input); void CommandWriteInquiryMode(const u8* input);
void CommandWritePageScanType(u8* _Input); void CommandWritePageScanType(const u8* input);
void CommandHostBufferSize(u8* _Input); void CommandHostBufferSize(const u8* input);
void CommandInquiryCancel(u8* _Input); void CommandInquiryCancel(const u8* input);
void CommandRemoteNameReq(u8* _Input); void CommandRemoteNameReq(const u8* input);
void CommandCreateCon(u8* _Input); void CommandCreateCon(const u8* input);
void CommandAcceptCon(u8* _Input); void CommandAcceptCon(const u8* input);
void CommandReadClockOffset(u8* _Input); void CommandReadClockOffset(const u8* input);
void CommandReadRemoteVerInfo(u8* _Input); void CommandReadRemoteVerInfo(const u8* input);
void CommandReadRemoteFeatures(u8* _Input); void CommandReadRemoteFeatures(const u8* input);
void CommandAuthenticationRequested(u8* _Input); void CommandAuthenticationRequested(const u8* input);
void CommandInquiry(u8* _Input); void CommandInquiry(const u8* input);
void CommandDisconnect(u8* _Input); void CommandDisconnect(const u8* input);
void CommandLinkKeyNegRep(u8* _Input); void CommandLinkKeyNegRep(const u8* input);
void CommandLinkKeyRep(u8* _Input); void CommandLinkKeyRep(const u8* input);
void CommandDeleteStoredLinkKey(u8* _Input); void CommandDeleteStoredLinkKey(const u8* input);
void CommandChangeConPacketType(u8* _Input); void CommandChangeConPacketType(const u8* input);
// OGF 0x02 - Link policy commands and return parameters // OGF 0x02 - Link policy commands and return parameters
void CommandWriteLinkPolicy(u8* _Input); void CommandWriteLinkPolicy(const u8* input);
void CommandSniffMode(u8* _Input); void CommandSniffMode(const u8* input);
// OGF 0x03 - Host Controller and Baseband commands and return parameters // OGF 0x03 - Host Controller and Baseband commands and return parameters
void CommandReset(u8* _Input); void CommandReset(const u8* input);
void CommandWriteLocalName(u8* _Input); void CommandWriteLocalName(const u8* input);
void CommandWritePageTimeOut(u8* _Input); void CommandWritePageTimeOut(const u8* input);
void CommandWriteScanEnable(u8* _Input); void CommandWriteScanEnable(const u8* input);
void CommandWriteUnitClass(u8* _Input); void CommandWriteUnitClass(const u8* input);
void CommandReadStoredLinkKey(u8* _Input); void CommandReadStoredLinkKey(const u8* input);
void CommandWritePinType(u8* _Input); void CommandWritePinType(const u8* input);
void CommandSetEventFilter(u8* _Input); void CommandSetEventFilter(const u8* input);
void CommandWriteInquiryScanType(u8* _Input); void CommandWriteInquiryScanType(const u8* input);
void CommandWriteLinkSupervisionTimeout(u8* _Input); void CommandWriteLinkSupervisionTimeout(const u8* input);
// OGF 0x04 - Informational commands and return parameters // OGF 0x04 - Informational commands and return parameters
void CommandReadBufferSize(u8* _Input); void CommandReadBufferSize(const u8* input);
void CommandReadLocalVer(u8* _Input); void CommandReadLocalVer(const u8* input);
void CommandReadLocalFeatures(u8* _Input); void CommandReadLocalFeatures(const u8* input);
void CommandReadBDAdrr(u8* _Input); void CommandReadBDAdrr(const u8* input);
// OGF 0x3F - Vendor specific // OGF 0x3F - Vendor specific
void CommandVendorSpecific_FC4C(u8* _Input, u32 _Size); void CommandVendorSpecific_FC4C(const u8* input, u32 size);
void CommandVendorSpecific_FC4F(u8* _Input, u32 _Size); void CommandVendorSpecific_FC4F(const u8* input, u32 size);
static void DisplayDisconnectMessage(const int wiimoteNumber, const int reason); static void DisplayDisconnectMessage(const int wiimoteNumber, const int reason);