From 12bcf64ab512df5e6034429c7b2a12981df19a5e Mon Sep 17 00:00:00 2001 From: wwylele Date: Sat, 25 Feb 2017 21:21:52 +0200 Subject: ir: implement circle pad pro --- src/core/hle/service/ir/ir_user.cpp | 489 ++++++++++++++++++++++++++++++++---- 1 file changed, 445 insertions(+), 44 deletions(-) (limited to 'src/core/hle/service/ir/ir_user.cpp') diff --git a/src/core/hle/service/ir/ir_user.cpp b/src/core/hle/service/ir/ir_user.cpp index b326d7fc7..bccf6bce7 100644 --- a/src/core/hle/service/ir/ir_user.cpp +++ b/src/core/hle/service/ir/ir_user.cpp @@ -2,110 +2,481 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. +#include +#include +#include +#include "common/string_util.h" +#include "common/swap.h" #include "core/hle/kernel/event.h" #include "core/hle/kernel/shared_memory.h" +#include "core/hle/service/ir/extra_hid.h" #include "core/hle/service/ir/ir.h" #include "core/hle/service/ir/ir_user.h" namespace Service { namespace IR { -static Kernel::SharedPtr conn_status_event; -static Kernel::SharedPtr transfer_shared_memory; +// This is a header that will present in the ir:USER shared memory if it is initialized with +// InitializeIrNopShared service function. Otherwise the shared memory doesn't have this header if +// it is initialized with InitializeIrNop service function. +struct SharedMemoryHeader { + u32_le latest_receive_error_result; + u32_le latest_send_error_result; + // TODO(wwylele): for these fields below, make them enum when the meaning of values is known. + u8 connection_status; + u8 trying_to_connect_status; + u8 connection_role; + u8 machine_id; + u8 connected; + u8 network_id; + u8 initialized; + u8 unknown; + + // This is not the end of the shared memory. It is followed by a receive buffer and a send + // buffer. We handle receive buffer in the BufferManager class. For the send buffer, because + // games usually don't access it, we don't emulate it. +}; +static_assert(sizeof(SharedMemoryHeader) == 16, "SharedMemoryHeader has wrong size!"); + +/** + * A manager of the send/receive buffers in the shared memory. Currently it is only used for the + * receive buffer. + * + * A buffer consists of three parts: + * - BufferInfo: stores available count of packets, and their position in the PacketInfo + * circular queue. + * - PacketInfo circular queue: stores the position of each avaiable packets in the Packet data + * buffer. Each entry is a pair of {offset, size}. + * - Packet data circular buffer: stores the actual data of packets. + * + * IR packets can be put into and get from the buffer. + * + * When a new packet is put into the buffer, its data is put into the data circular buffer, + * following the end of previous packet data. A new entry is also added to the PacketInfo circular + * queue pointing to the added packet data. Then BufferInfo is updated. + * + * Packets can be released from the other end of the buffer. When releasing a packet, the front + * entry in thePacketInfo circular queue is removed, and as a result the corresponding memory in the + * data circular buffer is also released. BufferInfo is updated as well. + * + * The client application usually has a similar manager constructed over the same shared memory + * region, performing the same put/get/release operation. This way the client and the service + * communicate via a pair of manager of the same buffer. + * + * TODO(wwylele): implement Get function, which is used by ReceiveIrnop service function. + */ +class BufferManager { +public: + BufferManager(Kernel::SharedPtr shared_memory_, u32 info_offset_, + u32 buffer_offset_, u32 max_packet_count_, u32 buffer_size) + : shared_memory(shared_memory_), info_offset(info_offset_), buffer_offset(buffer_offset_), + max_packet_count(max_packet_count_), + max_data_size(buffer_size - sizeof(PacketInfo) * max_packet_count_) { + UpdateBufferInfo(); + } + + /** + * Puts a packet to the head of the buffer. + * @params packet The data of the packet to put. + * @returns whether the operation is successful. + */ + bool Put(const std::vector& packet) { + if (info.packet_count == max_packet_count) + return false; + + u32 write_offset; + + // finds free space offset in data buffer + if (info.packet_count == 0) { + write_offset = 0; + if (packet.size() > max_data_size) + return false; + } else { + const u32 last_index = (info.end_index + max_packet_count - 1) % max_packet_count; + const PacketInfo first = GetPacketInfo(info.begin_index); + const PacketInfo last = GetPacketInfo(last_index); + write_offset = (last.offset + last.size) % max_data_size; + const u32 free_space = (first.offset + max_data_size - write_offset) % max_data_size; + if (packet.size() > free_space) + return false; + } + + // writes packet info + PacketInfo packet_info{write_offset, static_cast(packet.size())}; + SetPacketInfo(info.end_index, packet_info); + + // writes packet data + for (size_t i = 0; i < packet.size(); ++i) { + *GetDataBufferPointer((write_offset + i) % max_data_size) = packet[i]; + } + + // updates buffer info + info.end_index++; + info.end_index %= max_packet_count; + info.packet_count++; + UpdateBufferInfo(); + return true; + } + + /** + * Release packets from the tail of the buffer + * @params count Numbers of packets to release. + * @returns whether the operation is successful. + */ + bool Release(u32 count) { + if (info.packet_count < count) + return false; + + info.packet_count -= count; + info.begin_index += count; + info.begin_index %= max_packet_count; + UpdateBufferInfo(); + return true; + } + +private: + struct BufferInfo { + u32_le begin_index; + u32_le end_index; + u32_le packet_count; + u32_le unknown; + }; + static_assert(sizeof(BufferInfo) == 16, "BufferInfo has wrong size!"); + + struct PacketInfo { + u32_le offset; + u32_le size; + }; + static_assert(sizeof(PacketInfo) == 8, "PacketInfo has wrong size!"); + + u8* GetPacketInfoPointer(u32 index) { + return shared_memory->GetPointer(buffer_offset + sizeof(PacketInfo) * index); + } + + void SetPacketInfo(u32 index, const PacketInfo& packet_info) { + memcpy(GetPacketInfoPointer(index), &packet_info, sizeof(PacketInfo)); + } + + PacketInfo GetPacketInfo(u32 index) { + PacketInfo packet_info; + memcpy(&packet_info, GetPacketInfoPointer(index), sizeof(PacketInfo)); + return packet_info; + } + + u8* GetDataBufferPointer(u32 offset) { + return shared_memory->GetPointer(buffer_offset + sizeof(PacketInfo) * max_packet_count + + offset); + } + + void UpdateBufferInfo() { + if (info_offset) { + memcpy(shared_memory->GetPointer(info_offset), &info, sizeof(info)); + } + } + + BufferInfo info{0, 0, 0, 0}; + Kernel::SharedPtr shared_memory; + u32 info_offset; + u32 buffer_offset; + u32 max_packet_count; + u32 max_data_size; +}; + +static Kernel::SharedPtr conn_status_event, send_event, receive_event; +static Kernel::SharedPtr shared_memory; +static std::unique_ptr extra_hid; +static IRDevice* connected_device; +static boost::optional receive_buffer; + +/// Wraps the payload into packet and puts it to the receive buffer +static void PutToReceive(const std::vector& payload) { + LOG_TRACE(Service_IR, "called, data=%s", + Common::ArrayToString(payload.data(), payload.size()).c_str()); + size_t size = payload.size(); + + std::vector packet; + + // Builds packet header. For the format info: + // https://www.3dbrew.org/wiki/IRUSER_Shared_Memory#Packet_structure + + // fixed value + packet.push_back(0xA5); + // destination network ID + u8 network_id = *(shared_memory->GetPointer(offsetof(SharedMemoryHeader, network_id))); + packet.push_back(network_id); + + // puts the size info. + // The highest bit of the first byte is unknown, which is set to zero here. The second highest + // bit is a flag that determines whether the size info is in extended form. If the packet size + // can be represent within 6 bits, the short form (1 byte) of size info is chosen, the size is + // put to the lower bits of this byte, and the flag is clear. If the packet size cannot be + // represent within 6 bits, the extended form (2 bytes) is chosen, the lower 8 bits of the size + // is put to the second byte, the higher bits of the size is put to the lower bits of the first + // byte, and the flag is set. Note that the packet size must be within 14 bits due to this + // format restriction, or it will overlap with the flag bit. + if (size < 0x40) { + packet.push_back(static_cast(size)); + } else if (size < 0x4000) { + packet.push_back(static_cast(size >> 8) | 0x40); + packet.push_back(static_cast(size)); + } else { + ASSERT(false); + } + + // puts the payload + packet.insert(packet.end(), payload.begin(), payload.end()); + + // calculates CRC and puts to the end + packet.push_back(boost::crc<8, 0x07, 0, 0, false, false>(packet.data(), packet.size())); + + if (receive_buffer->Put(packet)) { + receive_event->Signal(); + } else { + LOG_ERROR(Service_IR, "receive buffer is full!"); + } +} /** * IR::InitializeIrNopShared service function + * Initializes ir:USER service with a user provided shared memory. The shared memory is configured + * to shared mode (with SharedMemoryHeader at the beginning of the shared memory). * Inputs: - * 1 : Size of transfer buffer + * 1 : Size of shared memory * 2 : Recv buffer size - * 3 : unknown + * 3 : Recv buffer packet count * 4 : Send buffer size - * 5 : unknown + * 5 : Send buffer packet count * 6 : BaudRate (u8) - * 7 : 0 - * 8 : Handle of transfer shared memory + * 7 : 0 (Handle descriptor) + * 8 : Handle of shared memory * Outputs: * 1 : Result of function, 0 on success, otherwise error code */ static void InitializeIrNopShared(Interface* self) { - u32* cmd_buff = Kernel::GetCommandBuffer(); + IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0x18, 6, 2); + const u32 shared_buff_size = rp.Pop(); + const u32 recv_buff_size = rp.Pop(); + const u32 recv_buff_packet_count = rp.Pop(); + const u32 send_buff_size = rp.Pop(); + const u32 send_buff_packet_count = rp.Pop(); + const u8 baud_rate = rp.Pop(); + const Kernel::Handle handle = rp.PopHandle(); - u32 transfer_buff_size = cmd_buff[1]; - u32 recv_buff_size = cmd_buff[2]; - u32 unk1 = cmd_buff[3]; - u32 send_buff_size = cmd_buff[4]; - u32 unk2 = cmd_buff[5]; - u8 baud_rate = cmd_buff[6] & 0xFF; - Kernel::Handle handle = cmd_buff[8]; + IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); - if (Kernel::g_handle_table.IsValid(handle)) { - transfer_shared_memory = Kernel::g_handle_table.Get(handle); - transfer_shared_memory->name = "IR:TransferSharedMemory"; + shared_memory = Kernel::g_handle_table.Get(handle); + if (!shared_memory) { + LOG_CRITICAL(Service_IR, "invalid shared memory handle 0x%08X", handle); + rb.Push(ResultCode(ErrorDescription::InvalidHandle, ErrorModule::OS, + ErrorSummary::WrongArgument, ErrorLevel::Permanent)); + return; } + shared_memory->name = "IR_USER: shared memory"; - cmd_buff[1] = RESULT_SUCCESS.raw; + receive_buffer = + BufferManager(shared_memory, 0x10, 0x20, recv_buff_packet_count, recv_buff_size); + SharedMemoryHeader shared_memory_init{}; + shared_memory_init.initialized = 1; + std::memcpy(shared_memory->GetPointer(), &shared_memory_init, sizeof(SharedMemoryHeader)); - LOG_WARNING(Service_IR, "(STUBBED) called, transfer_buff_size=%d, recv_buff_size=%d, " - "unk1=%d, send_buff_size=%d, unk2=%d, baud_rate=%u, handle=0x%08X", - transfer_buff_size, recv_buff_size, unk1, send_buff_size, unk2, baud_rate, handle); + rb.Push(RESULT_SUCCESS); + + LOG_INFO(Service_IR, "called, shared_buff_size=%u, recv_buff_size=%u, " + "recv_buff_packet_count=%u, send_buff_size=%u, " + "send_buff_packet_count=%u, baud_rate=%u, handle=0x%08X", + shared_buff_size, recv_buff_size, recv_buff_packet_count, send_buff_size, + send_buff_packet_count, baud_rate, handle); } /** * IR::RequireConnection service function + * Searches for an IR device and connects to it. After connecting to the device, applications can + * use SendIrNop function, ReceiveIrNop function (or read from the buffer directly) to communicate + * with the device. * Inputs: - * 1 : unknown (u8), looks like always 1 + * 1 : device ID? always 1 for circle pad pro * Outputs: * 1 : Result of function, 0 on success, otherwise error code */ static void RequireConnection(Interface* self) { - u32* cmd_buff = Kernel::GetCommandBuffer(); + IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0x06, 1, 0); + const u8 device_id = rp.Pop(); + + u8* shared_memory_ptr = shared_memory->GetPointer(); + if (device_id == 1) { + // These values are observed on a New 3DS. The meaning of them is unclear. + // TODO (wwylele): should assign network_id a (random?) number + shared_memory_ptr[offsetof(SharedMemoryHeader, connection_status)] = 2; + shared_memory_ptr[offsetof(SharedMemoryHeader, connection_role)] = 2; + shared_memory_ptr[offsetof(SharedMemoryHeader, connected)] = 1; + + connected_device = extra_hid.get(); + connected_device->OnConnect(); + conn_status_event->Signal(); + } else { + LOG_WARNING(Service_IR, "unknown device id %u. Won't connect.", device_id); + shared_memory_ptr[offsetof(SharedMemoryHeader, connection_status)] = 1; + shared_memory_ptr[offsetof(SharedMemoryHeader, trying_to_connect_status)] = 2; + } + + IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); + rb.Push(RESULT_SUCCESS); + + LOG_INFO(Service_IR, "called, device_id = %u", device_id); +} + +/** + * IR::GetReceiveEvent service function + * Gets an event that is signaled when a packet is received from the IR device. + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + * 2 : 0 (Handle descriptor) + * 3 : Receive event handle + */ +void GetReceiveEvent(Interface* self) { + IPC::RequestBuilder rb(Kernel::GetCommandBuffer(), 0x0A, 1, 2); - conn_status_event->Signal(); + rb.Push(RESULT_SUCCESS); + rb.PushCopyHandles(Kernel::g_handle_table.Create(Service::IR::receive_event).MoveFrom()); + + LOG_INFO(Service_IR, "called"); +} + +/** + * IR::GetSendEvent service function + * Gets an event that is signaled when the sending of a packet is complete + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + * 2 : 0 (Handle descriptor) + * 3 : Send event handle + */ +void GetSendEvent(Interface* self) { + IPC::RequestBuilder rb(Kernel::GetCommandBuffer(), 0x0B, 1, 2); - cmd_buff[1] = RESULT_SUCCESS.raw; + rb.Push(RESULT_SUCCESS); + rb.PushCopyHandles(Kernel::g_handle_table.Create(Service::IR::send_event).MoveFrom()); - LOG_WARNING(Service_IR, "(STUBBED) called"); + LOG_INFO(Service_IR, "called"); } /** * IR::Disconnect service function + * Disconnects from the current connected IR device. * Outputs: * 1 : Result of function, 0 on success, otherwise error code */ static void Disconnect(Interface* self) { - u32* cmd_buff = Kernel::GetCommandBuffer(); + if (connected_device) { + connected_device->OnDisconnect(); + connected_device = nullptr; + conn_status_event->Signal(); + } + + u8* shared_memory_ptr = shared_memory->GetPointer(); + shared_memory_ptr[offsetof(SharedMemoryHeader, connection_status)] = 0; + shared_memory_ptr[offsetof(SharedMemoryHeader, connected)] = 0; - cmd_buff[1] = RESULT_SUCCESS.raw; + IPC::RequestBuilder rb(Kernel::GetCommandBuffer(), 0x09, 1, 0); + rb.Push(RESULT_SUCCESS); - LOG_WARNING(Service_IR, "(STUBBED) called"); + LOG_INFO(Service_IR, "called"); } /** * IR::GetConnectionStatusEvent service function + * Gets an event that is signaled when the connection status is changed * Outputs: * 1 : Result of function, 0 on success, otherwise error code - * 2 : Connection Status Event handle + * 2 : 0 (Handle descriptor) + * 3 : Connection Status Event handle */ static void GetConnectionStatusEvent(Interface* self) { - u32* cmd_buff = Kernel::GetCommandBuffer(); + IPC::RequestBuilder rb(Kernel::GetCommandBuffer(), 0x0C, 1, 2); - cmd_buff[1] = RESULT_SUCCESS.raw; - cmd_buff[3] = Kernel::g_handle_table.Create(Service::IR::conn_status_event).MoveFrom(); + rb.Push(RESULT_SUCCESS); + rb.PushCopyHandles(Kernel::g_handle_table.Create(Service::IR::conn_status_event).MoveFrom()); - LOG_WARNING(Service_IR, "(STUBBED) called"); + LOG_INFO(Service_IR, "called"); } /** * IR::FinalizeIrNop service function + * Finalize ir:USER service. * Outputs: * 1 : Result of function, 0 on success, otherwise error code */ static void FinalizeIrNop(Interface* self) { - u32* cmd_buff = Kernel::GetCommandBuffer(); + if (connected_device) { + connected_device->OnDisconnect(); + connected_device = nullptr; + } + + shared_memory = nullptr; + receive_buffer = boost::none; + + IPC::RequestBuilder rb(Kernel::GetCommandBuffer(), 0x02, 1, 0); + rb.Push(RESULT_SUCCESS); + + LOG_INFO(Service_IR, "called"); +} + +/** + * IR::SendIrNop service function + * Sends a packet to the connected IR device + * Inpus: + * 1 : Size of data to send + * 2 : 2 + (size << 14) (Static buffer descriptor) + * 3 : Data buffer address + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + */ +static void SendIrNop(Interface* self) { + IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0x0D, 1, 2); + const u32 size = rp.Pop(); + const VAddr address = rp.PopStaticBuffer(); + + std::vector buffer(size); + Memory::ReadBlock(address, buffer.data(), size); + + IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); + if (connected_device) { + connected_device->OnReceive(buffer); + send_event->Signal(); + rb.Push(RESULT_SUCCESS); + } else { + LOG_ERROR(Service_IR, "not connected"); + rb.Push(ResultCode(static_cast(13), ErrorModule::IR, + ErrorSummary::InvalidState, ErrorLevel::Status)); + } + + LOG_TRACE(Service_IR, "called, data=%s", Common::ArrayToString(buffer.data(), size).c_str()); +} + +/** + * IR::ReleaseReceivedData function + * Release a specified amount of packet from the receive buffer. This is called after the + * application reads received packet from the buffer directly, to release the buffer space for + * future packets. + * Inpus: + * 1 : Number of packets to release + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + */ +static void ReleaseReceivedData(Interface* self) { + IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0x19, 1, 0); + u32 count = rp.Pop(); + + IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); - cmd_buff[1] = RESULT_SUCCESS.raw; + if (receive_buffer->Release(count)) { + rb.Push(RESULT_SUCCESS); + } else { + LOG_ERROR(Service_IR, "failed to release %u packets", count); + rb.Push(ResultCode(ErrorDescription::NoData, ErrorModule::IR, ErrorSummary::NotFound, + ErrorLevel::Status)); + } - LOG_WARNING(Service_IR, "(STUBBED) called"); + LOG_TRACE(Service_IR, "called, count=%u", count); } const Interface::FunctionInfo FunctionTable[] = { @@ -118,10 +489,10 @@ const Interface::FunctionInfo FunctionTable[] = { {0x000702C0, nullptr, "AutoConnection"}, {0x00080000, nullptr, "AnyConnection"}, {0x00090000, Disconnect, "Disconnect"}, - {0x000A0000, nullptr, "GetReceiveEvent"}, - {0x000B0000, nullptr, "GetSendEvent"}, + {0x000A0000, GetReceiveEvent, "GetReceiveEvent"}, + {0x000B0000, GetSendEvent, "GetSendEvent"}, {0x000C0000, GetConnectionStatusEvent, "GetConnectionStatusEvent"}, - {0x000D0042, nullptr, "SendIrNop"}, + {0x000D0042, SendIrNop, "SendIrNop"}, {0x000E0042, nullptr, "SendIrNopLarge"}, {0x000F0040, nullptr, "ReceiveIrnop"}, {0x00100042, nullptr, "ReceiveIrnopLarge"}, @@ -133,7 +504,7 @@ const Interface::FunctionInfo FunctionTable[] = { {0x00160000, nullptr, "GetSendSizeFreeAndUsed"}, {0x00170000, nullptr, "GetConnectionRole"}, {0x00180182, InitializeIrNopShared, "InitializeIrNopShared"}, - {0x00190040, nullptr, "ReleaseReceivedData"}, + {0x00190040, ReleaseReceivedData, "ReleaseReceivedData"}, {0x001A0040, nullptr, "SetOwnMachineId"}, }; @@ -144,13 +515,43 @@ IR_User_Interface::IR_User_Interface() { void InitUser() { using namespace Kernel; - transfer_shared_memory = nullptr; + shared_memory = nullptr; + conn_status_event = Event::Create(ResetType::OneShot, "IR:ConnectionStatusEvent"); + send_event = Event::Create(ResetType::OneShot, "IR:SendEvent"); + receive_event = Event::Create(ResetType::OneShot, "IR:ReceiveEvent"); + + receive_buffer = boost::none; + + extra_hid = std::make_unique(PutToReceive); + + connected_device = nullptr; } void ShutdownUser() { - transfer_shared_memory = nullptr; + if (connected_device) { + connected_device->OnDisconnect(); + connected_device = nullptr; + } + + extra_hid = nullptr; + receive_buffer = boost::none; + shared_memory = nullptr; conn_status_event = nullptr; + send_event = nullptr; + receive_event = nullptr; +} + +void ReloadInputDevices() { + if (extra_hid) + extra_hid->RequestInputDevicesReload(); +} + +IRDevice::IRDevice(SendFunc send_func_) : send_func(send_func_) {} +IRDevice::~IRDevice() = default; + +void IRDevice::Send(const std::vector& data) { + send_func(data); } } // namespace IR -- cgit v1.2.3