From eaace415d3fef9a63ac802390535805f069a2ba6 Mon Sep 17 00:00:00 2001 From: Lioncash Date: Sun, 10 Jun 2018 13:22:11 -0400 Subject: [PATCH] WiimoteDevice: Amend variable naming for non-class member variables This file is quite out of sync when it comes to our naming conventions, this brings it back in line with it. --- .../Core/IOS/USB/Bluetooth/WiimoteDevice.cpp | 566 +++++++++--------- .../Core/IOS/USB/Bluetooth/WiimoteDevice.h | 38 +- 2 files changed, 302 insertions(+), 302 deletions(-) diff --git a/Source/Core/Core/IOS/USB/Bluetooth/WiimoteDevice.cpp b/Source/Core/Core/IOS/USB/Bluetooth/WiimoteDevice.cpp index 1aef6a7d85..b2662d288c 100644 --- a/Source/Core/Core/IOS/USB/Bluetooth/WiimoteDevice.cpp +++ b/Source/Core/Core/IOS/USB/Bluetooth/WiimoteDevice.cpp @@ -28,25 +28,25 @@ namespace IOS::HLE class CBigEndianBuffer { public: - explicit CBigEndianBuffer(u8* pBuffer) : m_pBuffer(pBuffer) {} - u8 Read8(u32 offset) const { return m_pBuffer[offset]; } - u16 Read16(u32 offset) const { return Common::swap16(&m_pBuffer[offset]); } - u32 Read32(u32 offset) const { return Common::swap32(&m_pBuffer[offset]); } - void Write8(u32 offset, u8 data) { m_pBuffer[offset] = data; } + explicit CBigEndianBuffer(u8* buffer) : m_buffer(buffer) {} + u8 Read8(u32 offset) const { return m_buffer[offset]; } + u16 Read16(u32 offset) const { return Common::swap16(&m_buffer[offset]); } + u32 Read32(u32 offset) const { return Common::swap32(&m_buffer[offset]); } + void Write8(u32 offset, u8 data) { m_buffer[offset] = data; } void Write16(u32 offset, u16 data) { const u16 swapped = Common::swap16(data); - std::memcpy(&m_pBuffer[offset], &swapped, sizeof(u16)); + std::memcpy(&m_buffer[offset], &swapped, sizeof(u16)); } void Write32(u32 offset, u32 data) { const u32 swapped = Common::swap32(data); - std::memcpy(&m_pBuffer[offset], &swapped, sizeof(u32)); + std::memcpy(&m_buffer[offset], &swapped, sizeof(u32)); } - u8* GetPointer(u32 offset) { return &m_pBuffer[offset]; } + u8* GetPointer(u32 offset) { return &m_buffer[offset]; } private: - u8* m_pBuffer; + u8* m_buffer; }; WiimoteDevice::WiimoteDevice(Device::BluetoothEmu* host, int number, bdaddr_t bd, bool ready) @@ -246,33 +246,33 @@ void WiimoteDevice::ResetChannels() // // This function receives L2CAP commands from the CPU -void WiimoteDevice::ExecuteL2capCmd(u8* _pData, u32 _Size) +void WiimoteDevice::ExecuteL2capCmd(u8* ptr, u32 size) { // parse the command - l2cap_hdr_t* pHeader = (l2cap_hdr_t*)_pData; - u8* pData = _pData + sizeof(l2cap_hdr_t); - u32 DataSize = _Size - sizeof(l2cap_hdr_t); - DEBUG_LOG(IOS_WIIMOTE, " CID 0x%04x, Len 0x%x, DataSize 0x%x", pHeader->dcid, pHeader->length, - DataSize); + l2cap_hdr_t* header = (l2cap_hdr_t*)ptr; + u8* data = ptr + sizeof(l2cap_hdr_t); + const u32 data_size = size - sizeof(l2cap_hdr_t); + DEBUG_LOG(IOS_WIIMOTE, " CID 0x%04x, Len 0x%x, DataSize 0x%x", header->dcid, header->length, + data_size); - if (pHeader->length != DataSize) + if (header->length != data_size) { INFO_LOG(IOS_WIIMOTE, "Faulty packet. It is dropped."); return; } - switch (pHeader->dcid) + switch (header->dcid) { case L2CAP_SIGNAL_CID: - SignalChannel(pData, DataSize); + SignalChannel(data, data_size); break; default: { - DEBUG_ASSERT_MSG(IOS_WIIMOTE, DoesChannelExist(pHeader->dcid), - "L2CAP: SendACLPacket to unknown channel %i", pHeader->dcid); + DEBUG_ASSERT_MSG(IOS_WIIMOTE, DoesChannelExist(header->dcid), + "L2CAP: SendACLPacket to unknown channel %i", header->dcid); - const auto itr = m_Channel.find(pHeader->dcid); + const auto itr = m_Channel.find(header->dcid); const int number = m_ConnectionHandle & 0xFF; if (itr != m_Channel.end()) @@ -281,12 +281,12 @@ void WiimoteDevice::ExecuteL2capCmd(u8* _pData, u32 _Size) switch (channel.PSM) { case L2CAP_PSM_SDP: - HandleSDP(pHeader->dcid, pData, DataSize); + HandleSDP(header->dcid, data, data_size); break; case L2CAP_PSM_HID_CNTL: if (number < MAX_BBMOTES) - Wiimote::ControlChannel(number, pHeader->dcid, pData, DataSize); + Wiimote::ControlChannel(number, header->dcid, data, data_size); break; case L2CAP_PSM_HID_INTR: @@ -294,17 +294,17 @@ void WiimoteDevice::ExecuteL2capCmd(u8* _pData, u32 _Size) if (number < MAX_BBMOTES) { DEBUG_LOG(WIIMOTE, "Wiimote_InterruptChannel"); - DEBUG_LOG(WIIMOTE, " Channel ID: %04x", pHeader->dcid); - const std::string temp = ArrayToString(pData, DataSize); + DEBUG_LOG(WIIMOTE, " Channel ID: %04x", header->dcid); + const std::string temp = ArrayToString(data, data_size); DEBUG_LOG(WIIMOTE, " Data: %s", temp.c_str()); - Wiimote::InterruptChannel(number, pHeader->dcid, pData, DataSize); + Wiimote::InterruptChannel(number, header->dcid, data, data_size); } } break; default: - ERROR_LOG(IOS_WIIMOTE, "Channel 0x04%x has unknown PSM %x", pHeader->dcid, channel.PSM); + ERROR_LOG(IOS_WIIMOTE, "Channel 0x04%x has unknown PSM %x", header->dcid, channel.PSM); break; } } @@ -313,13 +313,13 @@ void WiimoteDevice::ExecuteL2capCmd(u8* _pData, u32 _Size) } } -void WiimoteDevice::SignalChannel(u8* _pData, u32 _Size) +void WiimoteDevice::SignalChannel(u8* data, u32 size) { - while (_Size >= sizeof(l2cap_cmd_hdr_t)) + while (size >= sizeof(l2cap_cmd_hdr_t)) { - l2cap_cmd_hdr_t* cmd_hdr = (l2cap_cmd_hdr_t*)_pData; - _pData += sizeof(l2cap_cmd_hdr_t); - _Size = _Size - sizeof(l2cap_cmd_hdr_t) - cmd_hdr->length; + l2cap_cmd_hdr_t* cmd_hdr = (l2cap_cmd_hdr_t*)data; + data += sizeof(l2cap_cmd_hdr_t); + size = size - sizeof(l2cap_cmd_hdr_t) - cmd_hdr->length; switch (cmd_hdr->code) { @@ -329,23 +329,23 @@ void WiimoteDevice::SignalChannel(u8* _pData, u32 _Size) break; case L2CAP_CONNECT_REQ: - ReceiveConnectionReq(cmd_hdr->ident, _pData, cmd_hdr->length); + ReceiveConnectionReq(cmd_hdr->ident, data, cmd_hdr->length); break; case L2CAP_CONNECT_RSP: - ReceiveConnectionResponse(cmd_hdr->ident, _pData, cmd_hdr->length); + ReceiveConnectionResponse(cmd_hdr->ident, data, cmd_hdr->length); break; case L2CAP_CONFIG_REQ: - ReceiveConfigurationReq(cmd_hdr->ident, _pData, cmd_hdr->length); + ReceiveConfigurationReq(cmd_hdr->ident, data, cmd_hdr->length); break; case L2CAP_CONFIG_RSP: - ReceiveConfigurationResponse(cmd_hdr->ident, _pData, cmd_hdr->length); + ReceiveConfigurationResponse(cmd_hdr->ident, data, cmd_hdr->length); break; case L2CAP_DISCONNECT_REQ: - ReceiveDisconnectionReq(cmd_hdr->ident, _pData, cmd_hdr->length); + ReceiveDisconnectionReq(cmd_hdr->ident, data, cmd_hdr->length); break; default: @@ -353,7 +353,7 @@ void WiimoteDevice::SignalChannel(u8* _pData, u32 _Size) return; } - _pData += cmd_hdr->length; + data += cmd_hdr->length; } } @@ -368,38 +368,38 @@ void WiimoteDevice::SignalChannel(u8* _pData, u32 _Size) // // -void WiimoteDevice::ReceiveConnectionReq(u8 _Ident, u8* _pData, u32 _Size) +void WiimoteDevice::ReceiveConnectionReq(u8 ident, u8* data, u32 size) { - l2cap_con_req_cp* pCommandConnectionReq = (l2cap_con_req_cp*)_pData; + l2cap_con_req_cp* command_connection_req = (l2cap_con_req_cp*)data; // create the channel - SChannel& rChannel = m_Channel[pCommandConnectionReq->scid]; - rChannel.PSM = pCommandConnectionReq->psm; - rChannel.SCID = pCommandConnectionReq->scid; - rChannel.DCID = pCommandConnectionReq->scid; + SChannel& channel = m_Channel[command_connection_req->scid]; + channel.PSM = command_connection_req->psm; + channel.SCID = command_connection_req->scid; + channel.DCID = command_connection_req->scid; DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] ReceiveConnectionRequest"); - DEBUG_LOG(IOS_WIIMOTE, " Ident: 0x%02x", _Ident); - DEBUG_LOG(IOS_WIIMOTE, " PSM: 0x%04x", rChannel.PSM); - DEBUG_LOG(IOS_WIIMOTE, " SCID: 0x%04x", rChannel.SCID); - DEBUG_LOG(IOS_WIIMOTE, " DCID: 0x%04x", rChannel.DCID); + DEBUG_LOG(IOS_WIIMOTE, " Ident: 0x%02x", ident); + DEBUG_LOG(IOS_WIIMOTE, " PSM: 0x%04x", channel.PSM); + DEBUG_LOG(IOS_WIIMOTE, " SCID: 0x%04x", channel.SCID); + DEBUG_LOG(IOS_WIIMOTE, " DCID: 0x%04x", channel.DCID); // response - l2cap_con_rsp_cp Rsp; - Rsp.scid = rChannel.SCID; - Rsp.dcid = rChannel.DCID; - Rsp.result = L2CAP_SUCCESS; - Rsp.status = L2CAP_NO_INFO; + l2cap_con_rsp_cp rsp; + rsp.scid = channel.SCID; + rsp.dcid = channel.DCID; + rsp.result = L2CAP_SUCCESS; + rsp.status = L2CAP_NO_INFO; DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] SendConnectionResponse"); - SendCommandToACL(_Ident, L2CAP_CONNECT_RSP, sizeof(l2cap_con_rsp_cp), (u8*)&Rsp); + SendCommandToACL(ident, L2CAP_CONNECT_RSP, sizeof(l2cap_con_rsp_cp), (u8*)&rsp); } -void WiimoteDevice::ReceiveConnectionResponse(u8 _Ident, u8* _pData, u32 _Size) +void WiimoteDevice::ReceiveConnectionResponse(u8 ident, u8* data, u32 size) { - l2cap_con_rsp_cp* rsp = (l2cap_con_rsp_cp*)_pData; + l2cap_con_rsp_cp* rsp = (l2cap_con_rsp_cp*)data; - DEBUG_ASSERT(_Size == sizeof(l2cap_con_rsp_cp)); + DEBUG_ASSERT(size == sizeof(l2cap_con_rsp_cp)); DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] ReceiveConnectionResponse"); DEBUG_LOG(IOS_WIIMOTE, " DCID: 0x%04x", rsp->dcid); @@ -411,95 +411,95 @@ void WiimoteDevice::ReceiveConnectionResponse(u8 _Ident, u8* _pData, u32 _Size) DEBUG_ASSERT(rsp->status == L2CAP_NO_INFO); DEBUG_ASSERT(DoesChannelExist(rsp->scid)); - SChannel& rChannel = m_Channel[rsp->scid]; - rChannel.DCID = rsp->dcid; + SChannel& channel = m_Channel[rsp->scid]; + channel.DCID = rsp->dcid; // update state machine - if (rChannel.PSM == L2CAP_PSM_HID_CNTL) + if (channel.PSM == L2CAP_PSM_HID_CNTL) m_hid_control_channel.connected = true; - else if (rChannel.PSM == L2CAP_PSM_HID_INTR) + else if (channel.PSM == L2CAP_PSM_HID_INTR) m_hid_interrupt_channel.connected = true; } -void WiimoteDevice::ReceiveConfigurationReq(u8 _Ident, u8* _pData, u32 _Size) +void WiimoteDevice::ReceiveConfigurationReq(u8 ident, u8* data, u32 size) { - u32 Offset = 0; - l2cap_cfg_req_cp* pCommandConfigReq = (l2cap_cfg_req_cp*)_pData; + u32 offset = 0; + l2cap_cfg_req_cp* command_config_req = (l2cap_cfg_req_cp*)data; // Flags being 1 means that the options are sent in multi-packets - DEBUG_ASSERT(pCommandConfigReq->flags == 0x00); - DEBUG_ASSERT(DoesChannelExist(pCommandConfigReq->dcid)); + DEBUG_ASSERT(command_config_req->flags == 0x00); + DEBUG_ASSERT(DoesChannelExist(command_config_req->dcid)); - SChannel& rChannel = m_Channel[pCommandConfigReq->dcid]; + SChannel& channel = m_Channel[command_config_req->dcid]; DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] ReceiveConfigurationRequest"); - DEBUG_LOG(IOS_WIIMOTE, " Ident: 0x%02x", _Ident); - DEBUG_LOG(IOS_WIIMOTE, " DCID: 0x%04x", pCommandConfigReq->dcid); - DEBUG_LOG(IOS_WIIMOTE, " Flags: 0x%04x", pCommandConfigReq->flags); + DEBUG_LOG(IOS_WIIMOTE, " Ident: 0x%02x", ident); + DEBUG_LOG(IOS_WIIMOTE, " DCID: 0x%04x", command_config_req->dcid); + DEBUG_LOG(IOS_WIIMOTE, " Flags: 0x%04x", command_config_req->flags); - Offset += sizeof(l2cap_cfg_req_cp); + offset += sizeof(l2cap_cfg_req_cp); - u8 TempBuffer[1024]; - u32 RespLen = 0; + u8 temp_buffer[1024]; + u32 resp_len = 0; - l2cap_cfg_rsp_cp* Rsp = (l2cap_cfg_rsp_cp*)TempBuffer; - Rsp->scid = rChannel.DCID; - Rsp->flags = 0x00; - Rsp->result = L2CAP_SUCCESS; + l2cap_cfg_rsp_cp* rsp = (l2cap_cfg_rsp_cp*)temp_buffer; + rsp->scid = channel.DCID; + rsp->flags = 0x00; + rsp->result = L2CAP_SUCCESS; - RespLen += sizeof(l2cap_cfg_rsp_cp); + resp_len += sizeof(l2cap_cfg_rsp_cp); // read configuration options - while (Offset < _Size) + while (offset < size) { - l2cap_cfg_opt_t* pOptions = (l2cap_cfg_opt_t*)&_pData[Offset]; - Offset += sizeof(l2cap_cfg_opt_t); + l2cap_cfg_opt_t* options = (l2cap_cfg_opt_t*)&data[offset]; + offset += sizeof(l2cap_cfg_opt_t); - switch (pOptions->type) + switch (options->type) { case L2CAP_OPT_MTU: { - DEBUG_ASSERT(pOptions->length == L2CAP_OPT_MTU_SIZE); - l2cap_cfg_opt_val_t* pMTU = (l2cap_cfg_opt_val_t*)&_pData[Offset]; - rChannel.MTU = pMTU->mtu; - DEBUG_LOG(IOS_WIIMOTE, " MTU: 0x%04x", pMTU->mtu); + DEBUG_ASSERT(options->length == L2CAP_OPT_MTU_SIZE); + l2cap_cfg_opt_val_t* mtu = (l2cap_cfg_opt_val_t*)&data[offset]; + channel.MTU = mtu->mtu; + DEBUG_LOG(IOS_WIIMOTE, " MTU: 0x%04x", mtu->mtu); } break; case L2CAP_OPT_FLUSH_TIMO: { - DEBUG_ASSERT(pOptions->length == L2CAP_OPT_FLUSH_TIMO_SIZE); - l2cap_cfg_opt_val_t* pFlushTimeOut = (l2cap_cfg_opt_val_t*)&_pData[Offset]; - rChannel.FlushTimeOut = pFlushTimeOut->flush_timo; - DEBUG_LOG(IOS_WIIMOTE, " FlushTimeOut: 0x%04x", pFlushTimeOut->flush_timo); + DEBUG_ASSERT(options->length == L2CAP_OPT_FLUSH_TIMO_SIZE); + l2cap_cfg_opt_val_t* flush_time_out = (l2cap_cfg_opt_val_t*)&data[offset]; + channel.FlushTimeOut = flush_time_out->flush_timo; + DEBUG_LOG(IOS_WIIMOTE, " FlushTimeOut: 0x%04x", flush_time_out->flush_timo); } break; default: - DEBUG_ASSERT_MSG(IOS_WIIMOTE, 0, "Unknown Option: 0x%02x", pOptions->type); + DEBUG_ASSERT_MSG(IOS_WIIMOTE, 0, "Unknown Option: 0x%02x", options->type); break; } - Offset += pOptions->length; + offset += options->length; - u32 OptionSize = sizeof(l2cap_cfg_opt_t) + pOptions->length; - memcpy(&TempBuffer[RespLen], pOptions, OptionSize); - RespLen += OptionSize; + const u32 option_size = sizeof(l2cap_cfg_opt_t) + options->length; + memcpy(&temp_buffer[resp_len], options, option_size); + resp_len += option_size; } DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] SendConfigurationResponse"); - SendCommandToACL(_Ident, L2CAP_CONFIG_RSP, RespLen, TempBuffer); + SendCommandToACL(ident, L2CAP_CONFIG_RSP, resp_len, temp_buffer); // update state machine - if (rChannel.PSM == L2CAP_PSM_HID_CNTL) + if (channel.PSM == L2CAP_PSM_HID_CNTL) m_hid_control_channel.connected = true; - else if (rChannel.PSM == L2CAP_PSM_HID_INTR) + else if (channel.PSM == L2CAP_PSM_HID_INTR) m_hid_interrupt_channel.connected = true; } -void WiimoteDevice::ReceiveConfigurationResponse(u8 _Ident, u8* _pData, u32 _Size) +void WiimoteDevice::ReceiveConfigurationResponse(u8 ident, u8* data, u32 size) { - l2cap_cfg_rsp_cp* rsp = (l2cap_cfg_rsp_cp*)_pData; + l2cap_cfg_rsp_cp* rsp = (l2cap_cfg_rsp_cp*)data; DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] ReceiveConfigurationResponse"); DEBUG_LOG(IOS_WIIMOTE, " SCID: 0x%04x", rsp->scid); @@ -509,30 +509,30 @@ void WiimoteDevice::ReceiveConfigurationResponse(u8 _Ident, u8* _pData, u32 _Siz DEBUG_ASSERT(rsp->result == L2CAP_SUCCESS); // update state machine - SChannel& rChannel = m_Channel[rsp->scid]; + const SChannel& channel = m_Channel[rsp->scid]; - if (rChannel.PSM == L2CAP_PSM_HID_CNTL) + if (channel.PSM == L2CAP_PSM_HID_CNTL) m_hid_control_channel.config = true; - else if (rChannel.PSM == L2CAP_PSM_HID_INTR) + else if (channel.PSM == L2CAP_PSM_HID_INTR) m_hid_interrupt_channel.config = true; } -void WiimoteDevice::ReceiveDisconnectionReq(u8 _Ident, u8* _pData, u32 _Size) +void WiimoteDevice::ReceiveDisconnectionReq(u8 ident, u8* data, u32 size) { - l2cap_discon_req_cp* pCommandDisconnectionReq = (l2cap_discon_req_cp*)_pData; + l2cap_discon_req_cp* command_disconnection_req = (l2cap_discon_req_cp*)data; DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] ReceiveDisconnectionReq"); - DEBUG_LOG(IOS_WIIMOTE, " Ident: 0x%02x", _Ident); - DEBUG_LOG(IOS_WIIMOTE, " DCID: 0x%04x", pCommandDisconnectionReq->dcid); - DEBUG_LOG(IOS_WIIMOTE, " SCID: 0x%04x", pCommandDisconnectionReq->scid); + DEBUG_LOG(IOS_WIIMOTE, " Ident: 0x%02x", ident); + DEBUG_LOG(IOS_WIIMOTE, " DCID: 0x%04x", command_disconnection_req->dcid); + DEBUG_LOG(IOS_WIIMOTE, " SCID: 0x%04x", command_disconnection_req->scid); // response - l2cap_discon_req_cp Rsp; - Rsp.dcid = pCommandDisconnectionReq->dcid; - Rsp.scid = pCommandDisconnectionReq->scid; + l2cap_discon_req_cp rsp; + rsp.dcid = command_disconnection_req->dcid; + rsp.scid = command_disconnection_req->scid; DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] SendDisconnectionResponse"); - SendCommandToACL(_Ident, L2CAP_DISCONNECT_RSP, sizeof(l2cap_discon_req_cp), (u8*)&Rsp); + SendCommandToACL(ident, L2CAP_DISCONNECT_RSP, sizeof(l2cap_discon_req_cp), (u8*)&rsp); } // @@ -550,9 +550,9 @@ void WiimoteDevice::ReceiveDisconnectionReq(u8 _Ident, u8* _pData, u32 _Size) void WiimoteDevice::SendConnectionRequest(u16 scid, u16 psm) { // create the channel - SChannel& rChannel = m_Channel[scid]; - rChannel.PSM = psm; - rChannel.SCID = scid; + SChannel& channel = m_Channel[scid]; + channel.PSM = psm; + channel.SCID = scid; l2cap_con_req_cp cr; cr.psm = psm; @@ -569,11 +569,11 @@ void WiimoteDevice::SendConnectionRequest(u16 scid, u16 psm) void WiimoteDevice::SendDisconnectRequest(u16 scid) { // create the channel - SChannel& rChannel = m_Channel[scid]; + const SChannel& channel = m_Channel[scid]; l2cap_discon_req_cp cr; - cr.dcid = rChannel.DCID; - cr.scid = rChannel.SCID; + cr.dcid = channel.DCID; + cr.scid = channel.SCID; DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] SendDisconnectionRequest"); DEBUG_LOG(IOS_WIIMOTE, " Dcid: 0x%04x", cr.dcid); @@ -583,56 +583,56 @@ void WiimoteDevice::SendDisconnectRequest(u16 scid) (u8*)&cr); } -void WiimoteDevice::SendConfigurationRequest(u16 scid, u16 MTU, u16 FlushTimeOut) +void WiimoteDevice::SendConfigurationRequest(u16 scid, u16 mtu, u16 flush_time_out) { DEBUG_ASSERT(DoesChannelExist(scid)); - SChannel& rChannel = m_Channel[scid]; + const SChannel& channel = m_Channel[scid]; - u8 Buffer[1024]; - int Offset = 0; + u8 buffer[1024]; + int offset = 0; - l2cap_cfg_req_cp* cr = (l2cap_cfg_req_cp*)&Buffer[Offset]; - cr->dcid = rChannel.DCID; + l2cap_cfg_req_cp* cr = (l2cap_cfg_req_cp*)&buffer[offset]; + cr->dcid = channel.DCID; cr->flags = 0; - Offset += sizeof(l2cap_cfg_req_cp); + offset += sizeof(l2cap_cfg_req_cp); DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] SendConfigurationRequest"); DEBUG_LOG(IOS_WIIMOTE, " Dcid: 0x%04x", cr->dcid); DEBUG_LOG(IOS_WIIMOTE, " Flags: 0x%04x", cr->flags); - l2cap_cfg_opt_t* pOptions; + l2cap_cfg_opt_t* options; // (shuffle2) currently we end up not appending options. this is because we don't // negotiate after trying to set MTU = 0 fails (stack will respond with // "configuration failed" msg...). This is still fine, we'll just use whatever the // Bluetooth stack defaults to. - if (MTU || rChannel.MTU) + if (mtu || channel.MTU) { - if (MTU == 0) - MTU = rChannel.MTU; - pOptions = (l2cap_cfg_opt_t*)&Buffer[Offset]; - Offset += sizeof(l2cap_cfg_opt_t); - pOptions->type = L2CAP_OPT_MTU; - pOptions->length = L2CAP_OPT_MTU_SIZE; - *(u16*)&Buffer[Offset] = MTU; - Offset += L2CAP_OPT_MTU_SIZE; - DEBUG_LOG(IOS_WIIMOTE, " MTU: 0x%04x", MTU); + if (mtu == 0) + mtu = channel.MTU; + options = (l2cap_cfg_opt_t*)&buffer[offset]; + offset += sizeof(l2cap_cfg_opt_t); + options->type = L2CAP_OPT_MTU; + options->length = L2CAP_OPT_MTU_SIZE; + *(u16*)&buffer[offset] = mtu; + offset += L2CAP_OPT_MTU_SIZE; + DEBUG_LOG(IOS_WIIMOTE, " MTU: 0x%04x", mtu); } - if (FlushTimeOut || rChannel.FlushTimeOut) + if (flush_time_out || channel.FlushTimeOut) { - if (FlushTimeOut == 0) - FlushTimeOut = rChannel.FlushTimeOut; - pOptions = (l2cap_cfg_opt_t*)&Buffer[Offset]; - Offset += sizeof(l2cap_cfg_opt_t); - pOptions->type = L2CAP_OPT_FLUSH_TIMO; - pOptions->length = L2CAP_OPT_FLUSH_TIMO_SIZE; - *(u16*)&Buffer[Offset] = FlushTimeOut; - Offset += L2CAP_OPT_FLUSH_TIMO_SIZE; - DEBUG_LOG(IOS_WIIMOTE, " FlushTimeOut: 0x%04x", FlushTimeOut); + if (flush_time_out == 0) + flush_time_out = channel.FlushTimeOut; + options = (l2cap_cfg_opt_t*)&buffer[offset]; + offset += sizeof(l2cap_cfg_opt_t); + options->type = L2CAP_OPT_FLUSH_TIMO; + options->length = L2CAP_OPT_FLUSH_TIMO_SIZE; + *(u16*)&buffer[offset] = flush_time_out; + offset += L2CAP_OPT_FLUSH_TIMO_SIZE; + DEBUG_LOG(IOS_WIIMOTE, " FlushTimeOut: 0x%04x", flush_time_out); } - SendCommandToACL(L2CAP_CONFIG_REQ, L2CAP_CONFIG_REQ, Offset, Buffer); + SendCommandToACL(L2CAP_CONFIG_REQ, L2CAP_CONFIG_REQ, offset, buffer); } // @@ -652,13 +652,13 @@ void WiimoteDevice::SendConfigurationRequest(u16 scid, u16 MTU, u16 FlushTimeOut #define SDP_SEQ8 0x35 #define SDP_SEQ16 0x36 -void WiimoteDevice::SDPSendServiceSearchResponse(u16 cid, u16 TransactionID, - u8* pServiceSearchPattern, - u16 MaximumServiceRecordCount) +void WiimoteDevice::SDPSendServiceSearchResponse(u16 cid, u16 transaction_id, + u8* service_search_pattern, + u16 maximum_service_record_count) { // verify block... we handle search pattern for HID service only { - CBigEndianBuffer buffer(pServiceSearchPattern); + CBigEndianBuffer buffer(service_search_pattern); DEBUG_ASSERT(buffer.Read8(0) == SDP_SEQ8); // data sequence DEBUG_ASSERT(buffer.Read8(1) == 0x03); // sequence size @@ -667,135 +667,135 @@ void WiimoteDevice::SDPSendServiceSearchResponse(u16 cid, u16 TransactionID, DEBUG_ASSERT(buffer.Read16(3) == 0x1124); } - u8 DataFrame[1000]; - CBigEndianBuffer buffer(DataFrame); + u8 data_frame[1000]; + CBigEndianBuffer buffer(data_frame); - int Offset = 0; - l2cap_hdr_t* pHeader = (l2cap_hdr_t*)&DataFrame[Offset]; - Offset += sizeof(l2cap_hdr_t); - pHeader->dcid = cid; + int offset = 0; + l2cap_hdr_t* header = (l2cap_hdr_t*)&data_frame[offset]; + offset += sizeof(l2cap_hdr_t); + header->dcid = cid; - buffer.Write8(Offset, 0x03); - Offset++; - buffer.Write16(Offset, TransactionID); - Offset += 2; // Transaction ID - buffer.Write16(Offset, 0x0009); - Offset += 2; // Param length - buffer.Write16(Offset, 0x0001); - Offset += 2; // TotalServiceRecordCount - buffer.Write16(Offset, 0x0001); - Offset += 2; // CurrentServiceRecordCount - buffer.Write32(Offset, 0x10000); - Offset += 4; // ServiceRecordHandleList[4] - buffer.Write8(Offset, 0x00); - Offset++; // No continuation state; + buffer.Write8(offset, 0x03); + offset++; + buffer.Write16(offset, transaction_id); + offset += 2; // Transaction ID + buffer.Write16(offset, 0x0009); + offset += 2; // Param length + buffer.Write16(offset, 0x0001); + offset += 2; // TotalServiceRecordCount + buffer.Write16(offset, 0x0001); + offset += 2; // CurrentServiceRecordCount + buffer.Write32(offset, 0x10000); + offset += 4; // ServiceRecordHandleList[4] + buffer.Write8(offset, 0x00); + offset++; // No continuation state; - pHeader->length = (u16)(Offset - sizeof(l2cap_hdr_t)); - m_pHost->SendACLPacket(GetConnectionHandle(), DataFrame, pHeader->length + sizeof(l2cap_hdr_t)); + header->length = (u16)(offset - sizeof(l2cap_hdr_t)); + m_pHost->SendACLPacket(GetConnectionHandle(), data_frame, header->length + sizeof(l2cap_hdr_t)); } -static u32 ParseCont(u8* pCont) +static u32 ParseCont(u8* cont) { - u32 attribOffset = 0; - CBigEndianBuffer attribList(pCont); - u8 typeID = attribList.Read8(attribOffset); - attribOffset++; + u32 attrib_offset = 0; + CBigEndianBuffer attrib_list(cont); + const u8 type_id = attrib_list.Read8(attrib_offset); + attrib_offset++; - if (typeID == 0x02) + if (type_id == 0x02) { - return attribList.Read16(attribOffset); + return attrib_list.Read16(attrib_offset); } - else if (typeID == 0x00) + else if (type_id == 0x00) { return 0x00; } - ERROR_LOG(IOS_WIIMOTE, "ParseCont: wrong cont: %i", typeID); - PanicAlert("ParseCont: wrong cont: %i", typeID); + ERROR_LOG(IOS_WIIMOTE, "ParseCont: wrong cont: %i", type_id); + PanicAlert("ParseCont: wrong cont: %i", type_id); return 0; } -static int ParseAttribList(u8* pAttribIDList, u16& _startID, u16& _endID) +static int ParseAttribList(u8* attrib_id_list, u16& start_id, u16& end_id) { - u32 attribOffset = 0; - CBigEndianBuffer attribList(pAttribIDList); + u32 attrib_offset = 0; + CBigEndianBuffer attrib_list(attrib_id_list); - u8 sequence = attribList.Read8(attribOffset); - attribOffset++; - u8 seqSize = attribList.Read8(attribOffset); - attribOffset++; - u8 typeID = attribList.Read8(attribOffset); - attribOffset++; + const u8 sequence = attrib_list.Read8(attrib_offset); + attrib_offset++; + const u8 seq_size = attrib_list.Read8(attrib_offset); + attrib_offset++; + const u8 type_id = attrib_list.Read8(attrib_offset); + attrib_offset++; if (MAX_LOGLEVEL >= LogTypes::LOG_LEVELS::LDEBUG) { DEBUG_ASSERT(sequence == SDP_SEQ8); - (void)seqSize; + (void)seq_size; } - if (typeID == SDP_UINT32) + if (type_id == SDP_UINT32) { - _startID = attribList.Read16(attribOffset); - attribOffset += 2; - _endID = attribList.Read16(attribOffset); - attribOffset += 2; + start_id = attrib_list.Read16(attrib_offset); + attrib_offset += 2; + end_id = attrib_list.Read16(attrib_offset); + attrib_offset += 2; } else { - _startID = attribList.Read16(attribOffset); - attribOffset += 2; - _endID = _startID; + start_id = attrib_list.Read16(attrib_offset); + attrib_offset += 2; + end_id = start_id; WARN_LOG(IOS_WIIMOTE, "Read just a single attrib - not tested"); PanicAlert("Read just a single attrib - not tested"); } - return attribOffset; + return attrib_offset; } -void WiimoteDevice::SDPSendServiceAttributeResponse(u16 cid, u16 TransactionID, u32 ServiceHandle, - u16 startAttrID, u16 endAttrID, - u16 MaximumAttributeByteCount, - u8* pContinuationState) +void WiimoteDevice::SDPSendServiceAttributeResponse(u16 cid, u16 transaction_id, u32 service_handle, + u16 start_attr_id, u16 end_attr_id, + u16 maximum_attribute_byte_count, + u8* continuation_state) { - if (ServiceHandle != 0x10000) + if (service_handle != 0x10000) { - ERROR_LOG(IOS_WIIMOTE, "Unknown service handle %x", ServiceHandle); - PanicAlert("Unknown service handle %x", ServiceHandle); + ERROR_LOG(IOS_WIIMOTE, "Unknown service handle %x", service_handle); + PanicAlert("Unknown service handle %x", service_handle); } - u32 contState = ParseCont(pContinuationState); + const u32 cont_state = ParseCont(continuation_state); - u32 packetSize = 0; - const u8* pPacket = GetAttribPacket(ServiceHandle, contState, packetSize); + u32 packet_size = 0; + const u8* packet = GetAttribPacket(service_handle, cont_state, packet_size); // generate package - u8 DataFrame[1000]; - CBigEndianBuffer buffer(DataFrame); + u8 data_frame[1000]; + CBigEndianBuffer buffer(data_frame); - int Offset = 0; - l2cap_hdr_t* pHeader = (l2cap_hdr_t*)&DataFrame[Offset]; - Offset += sizeof(l2cap_hdr_t); - pHeader->dcid = cid; + int offset = 0; + l2cap_hdr_t* header = (l2cap_hdr_t*)&data_frame[offset]; + offset += sizeof(l2cap_hdr_t); + header->dcid = cid; - buffer.Write8(Offset, 0x05); - Offset++; - buffer.Write16(Offset, TransactionID); - Offset += 2; // Transaction ID + buffer.Write8(offset, 0x05); + offset++; + buffer.Write16(offset, transaction_id); + offset += 2; // Transaction ID - memcpy(buffer.GetPointer(Offset), pPacket, packetSize); - Offset += packetSize; + memcpy(buffer.GetPointer(offset), packet, packet_size); + offset += packet_size; - pHeader->length = (u16)(Offset - sizeof(l2cap_hdr_t)); - m_pHost->SendACLPacket(GetConnectionHandle(), DataFrame, pHeader->length + sizeof(l2cap_hdr_t)); + header->length = (u16)(offset - sizeof(l2cap_hdr_t)); + m_pHost->SendACLPacket(GetConnectionHandle(), data_frame, header->length + sizeof(l2cap_hdr_t)); - // Debugger::PrintDataBuffer(LogTypes::WIIMOTE, DataFrame, pHeader->length + sizeof(l2cap_hdr_t), + // Debugger::PrintDataBuffer(LogTypes::WIIMOTE, data_frame, header->length + sizeof(l2cap_hdr_t), // "test response: "); } -void WiimoteDevice::HandleSDP(u16 cid, u8* _pData, u32 _Size) +void WiimoteDevice::HandleSDP(u16 cid, u8* data, u32 size) { - // Debugger::PrintDataBuffer(LogTypes::WIIMOTE, _pData, _Size, "HandleSDP: "); + // Debugger::PrintDataBuffer(LogTypes::WIIMOTE, data, size, "HandleSDP: "); - CBigEndianBuffer buffer(_pData); + CBigEndianBuffer buffer(data); switch (buffer.Read8(0)) { @@ -804,14 +804,14 @@ void WiimoteDevice::HandleSDP(u16 cid, u8* _pData, u32 _Size) { WARN_LOG(IOS_WIIMOTE, "!!! SDP_ServiceSearchRequest !!!"); - DEBUG_ASSERT(_Size == 13); + DEBUG_ASSERT(size == 13); - u16 TransactionID = buffer.Read16(1); - u8* pServiceSearchPattern = buffer.GetPointer(5); - u16 MaximumServiceRecordCount = buffer.Read16(10); + const u16 transaction_id = buffer.Read16(1); + u8* service_search_pattern = buffer.GetPointer(5); + const u16 maximum_service_record_count = buffer.Read16(10); - SDPSendServiceSearchResponse(cid, TransactionID, pServiceSearchPattern, - MaximumServiceRecordCount); + SDPSendServiceSearchResponse(cid, transaction_id, service_search_pattern, + maximum_service_record_count); } break; @@ -820,28 +820,28 @@ void WiimoteDevice::HandleSDP(u16 cid, u8* _pData, u32 _Size) { WARN_LOG(IOS_WIIMOTE, "!!! SDP_ServiceAttributeRequest !!!"); - u16 startAttrID, endAttrID; + u16 start_attr_id, end_attr_id; u32 offset = 1; - u16 TransactionID = buffer.Read16(offset); + const u16 transaction_id = buffer.Read16(offset); offset += 2; - // u16 ParameterLength = buffer.Read16(offset); + // u16 parameter_length = buffer.Read16(offset); offset += 2; - u32 ServiceHandle = buffer.Read32(offset); + const u32 service_handle = buffer.Read32(offset); offset += 4; - u16 MaximumAttributeByteCount = buffer.Read16(offset); + const u16 maximum_attribute_byte_count = buffer.Read16(offset); offset += 2; - offset += ParseAttribList(buffer.GetPointer(offset), startAttrID, endAttrID); - u8* pContinuationState = buffer.GetPointer(offset); + offset += ParseAttribList(buffer.GetPointer(offset), start_attr_id, end_attr_id); + u8* continuation_state = buffer.GetPointer(offset); - SDPSendServiceAttributeResponse(cid, TransactionID, ServiceHandle, startAttrID, endAttrID, - MaximumAttributeByteCount, pContinuationState); + SDPSendServiceAttributeResponse(cid, transaction_id, service_handle, start_attr_id, end_attr_id, + maximum_attribute_byte_count, continuation_state); } break; default: - ERROR_LOG(IOS_WIIMOTE, "WIIMOTE: Unknown SDP command %x", _pData[0]); - PanicAlert("WIIMOTE: Unknown SDP command %x", _pData[0]); + ERROR_LOG(IOS_WIIMOTE, "WIIMOTE: Unknown SDP command %x", data[0]); + PanicAlert("WIIMOTE: Unknown SDP command %x", data[0]); break; } } @@ -857,58 +857,58 @@ void WiimoteDevice::HandleSDP(u16 cid, u8* _pData, u32 _Size) // // -void WiimoteDevice::SendCommandToACL(u8 _Ident, u8 _Code, u8 _CommandLength, u8* _pCommandData) +void WiimoteDevice::SendCommandToACL(u8 ident, u8 code, u8 command_length, u8* command_data) { - u8 DataFrame[1024]; - u32 Offset = 0; + u8 data_frame[1024]; + u32 offset = 0; - l2cap_hdr_t* pHeader = (l2cap_hdr_t*)&DataFrame[Offset]; - Offset += sizeof(l2cap_hdr_t); - pHeader->length = sizeof(l2cap_cmd_hdr_t) + _CommandLength; - pHeader->dcid = L2CAP_SIGNAL_CID; + l2cap_hdr_t* header = (l2cap_hdr_t*)&data_frame[offset]; + offset += sizeof(l2cap_hdr_t); + header->length = sizeof(l2cap_cmd_hdr_t) + command_length; + header->dcid = L2CAP_SIGNAL_CID; - l2cap_cmd_hdr_t* pCommand = (l2cap_cmd_hdr_t*)&DataFrame[Offset]; - Offset += sizeof(l2cap_cmd_hdr_t); - pCommand->code = _Code; - pCommand->ident = _Ident; - pCommand->length = _CommandLength; + l2cap_cmd_hdr_t* command = (l2cap_cmd_hdr_t*)&data_frame[offset]; + offset += sizeof(l2cap_cmd_hdr_t); + command->code = code; + command->ident = ident; + command->length = command_length; - memcpy(&DataFrame[Offset], _pCommandData, _CommandLength); + memcpy(&data_frame[offset], command_data, command_length); DEBUG_LOG(IOS_WIIMOTE, "Send ACL Command to CPU"); - DEBUG_LOG(IOS_WIIMOTE, " Ident: 0x%02x", _Ident); - DEBUG_LOG(IOS_WIIMOTE, " Code: 0x%02x", _Code); + DEBUG_LOG(IOS_WIIMOTE, " Ident: 0x%02x", ident); + DEBUG_LOG(IOS_WIIMOTE, " Code: 0x%02x", code); // send .... - m_pHost->SendACLPacket(GetConnectionHandle(), DataFrame, pHeader->length + sizeof(l2cap_hdr_t)); + m_pHost->SendACLPacket(GetConnectionHandle(), data_frame, header->length + sizeof(l2cap_hdr_t)); - // Debugger::PrintDataBuffer(LogTypes::WIIMOTE, DataFrame, pHeader->length + sizeof(l2cap_hdr_t), + // Debugger::PrintDataBuffer(LogTypes::WIIMOTE, data_frame, header->length + sizeof(l2cap_hdr_t), // "m_pHost->SendACLPacket: "); } -void WiimoteDevice::ReceiveL2capData(u16 scid, const void* _pData, u32 _Size) +void WiimoteDevice::ReceiveL2capData(u16 scid, const void* data, u32 size) { // Allocate DataFrame - u8 DataFrame[1024]; - u32 Offset = 0; - l2cap_hdr_t* pHeader = (l2cap_hdr_t*)DataFrame; - Offset += sizeof(l2cap_hdr_t); + u8 data_frame[1024]; + u32 offset = 0; + l2cap_hdr_t* header = (l2cap_hdr_t*)data_frame; + offset += sizeof(l2cap_hdr_t); // Check if we are already reporting on this channel DEBUG_ASSERT(DoesChannelExist(scid)); - SChannel& rChannel = m_Channel[scid]; + const SChannel& channel = m_Channel[scid]; // Add an additional 4 byte header to the Wiimote report - pHeader->dcid = rChannel.DCID; - pHeader->length = _Size; + header->dcid = channel.DCID; + header->length = size; - // Copy the Wiimote report to DataFrame - memcpy(DataFrame + Offset, _pData, _Size); - // Update Offset to the final size of the report - Offset += _Size; + // Copy the Wiimote report to data_frame + memcpy(data_frame + offset, data, size); + // Update offset to the final size of the report + offset += size; // Send the report - m_pHost->SendACLPacket(GetConnectionHandle(), DataFrame, Offset); + m_pHost->SendACLPacket(GetConnectionHandle(), data_frame, offset); } } // namespace IOS::HLE @@ -916,18 +916,18 @@ 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_WiimoteInterruptChannel(int _number, u16 _channelID, const void* _pData, u32 _Size) +void Callback_WiimoteInterruptChannel(int number, u16 channel_id, const void* opaque_data, u32 size) { - const u8* pData = (const u8*)_pData; + const u8* data = (const u8*)opaque_data; DEBUG_LOG(WIIMOTE, "===================="); - DEBUG_LOG(WIIMOTE, "Callback_WiimoteInterruptChannel: (Wiimote: #%i)", _number); - DEBUG_LOG(WIIMOTE, " Data: %s", ArrayToString(pData, _Size, 50).c_str()); - DEBUG_LOG(WIIMOTE, " Channel: %x", _channelID); + DEBUG_LOG(WIIMOTE, "Callback_WiimoteInterruptChannel: (Wiimote: #%i)", number); + DEBUG_LOG(WIIMOTE, " Data: %s", ArrayToString(data, size, 50).c_str()); + DEBUG_LOG(WIIMOTE, " Channel: %x", channel_id); const auto bt = std::static_pointer_cast( IOS::HLE::GetIOS()->GetDeviceByName("/dev/usb/oh1/57e/305")); if (bt) - bt->m_WiiMotes[_number].ReceiveL2capData(_channelID, _pData, _Size); + bt->m_WiiMotes[number].ReceiveL2capData(channel_id, opaque_data, size); } } diff --git a/Source/Core/Core/IOS/USB/Bluetooth/WiimoteDevice.h b/Source/Core/Core/IOS/USB/Bluetooth/WiimoteDevice.h index 43b2acaacb..4612de31fe 100644 --- a/Source/Core/Core/IOS/USB/Bluetooth/WiimoteDevice.h +++ b/Source/Core/Core/IOS/USB/Bluetooth/WiimoteDevice.h @@ -23,7 +23,7 @@ class BluetoothEmu; class WiimoteDevice { public: - WiimoteDevice(Device::BluetoothEmu* _pHost, int _Number, bdaddr_t _BD, bool ready = false); + WiimoteDevice(Device::BluetoothEmu* host, int number, bdaddr_t bd, bool ready = false); void DoState(PointerWrap& p); @@ -35,8 +35,8 @@ public: bool LinkChannel(); void ResetChannels(); void Activate(bool ready); - void ExecuteL2capCmd(u8* _pData, u32 _Size); // From CPU - void ReceiveL2capData(u16 scid, const void* _pData, u32 _Size); // From Wiimote + void ExecuteL2capCmd(u8* ptr, u32 size); // From CPU + void ReceiveL2capData(u16 scid, const void* data, u32 size); // From Wiimote void EventConnectionAccepted(); void EventDisconnect(); @@ -99,28 +99,28 @@ private: CChannelMap m_Channel; bool DoesChannelExist(u16 scid) const { return m_Channel.find(scid) != m_Channel.end(); } - void SendCommandToACL(u8 _Ident, u8 _Code, u8 _CommandLength, u8* _pCommandData); + void SendCommandToACL(u8 ident, u8 code, u8 command_length, u8* command_data); - void SignalChannel(u8* _pData, u32 _Size); + void SignalChannel(u8* data, u32 size); - void SendConnectionRequest(u16 _SCID, u16 _PSM); - void SendConfigurationRequest(u16 _SCID, u16 _pMTU = 0, u16 _pFlushTimeOut = 0); - void SendDisconnectRequest(u16 _SCID); + void SendConnectionRequest(u16 scid, u16 psm); + void SendConfigurationRequest(u16 scid, u16 mtu = 0, u16 flush_time_out = 0); + void SendDisconnectRequest(u16 scid); - void ReceiveConnectionReq(u8 _Ident, u8* _pData, u32 _Size); - void ReceiveConnectionResponse(u8 _Ident, u8* _pData, u32 _Size); - void ReceiveDisconnectionReq(u8 _Ident, u8* _pData, u32 _Size); - void ReceiveConfigurationReq(u8 _Ident, u8* _pData, u32 _Size); - void ReceiveConfigurationResponse(u8 _Ident, u8* _pData, u32 _Size); + void ReceiveConnectionReq(u8 ident, u8* data, u32 size); + void ReceiveConnectionResponse(u8 ident, u8* data, u32 size); + void ReceiveDisconnectionReq(u8 ident, u8* data, u32 size); + void ReceiveConfigurationReq(u8 ident, u8* data, u32 size); + void ReceiveConfigurationResponse(u8 ident, u8* data, u32 size); // some new ugly stuff // should be inside the plugin - void HandleSDP(u16 _SCID, u8* _pData, u32 _Size); - void SDPSendServiceSearchResponse(u16 _SCID, u16 _TransactionID, u8* _pServiceSearchPattern, - u16 _MaximumServiceRecordCount); + void HandleSDP(u16 cid, u8* data, u32 size); + void SDPSendServiceSearchResponse(u16 cid, u16 transaction_id, u8* service_search_pattern, + u16 maximum_service_record_count); - void SDPSendServiceAttributeResponse(u16 _SCID, u16 TransactionID, u32 _ServiceHandle, - u16 _StartAttrID, u16 _EndAttrID, - u16 _MaximumAttributeByteCount, u8* _pContinuationState); + void SDPSendServiceAttributeResponse(u16 cid, u16 transaction_id, u32 service_handle, + u16 start_attr_id, u16 end_attr_id, + u16 maximum_attribute_byte_count, u8* continuation_state); }; } // namespace IOS::HLE