ir: implement circle pad pro
This commit is contained in:
wwylele
parent
6843538f7c
commit
12bcf64ab5
|
|
@ -109,6 +109,7 @@ set(SRCS
|
|||
hle/service/hid/hid_spvr.cpp
|
||||
hle/service/hid/hid_user.cpp
|
||||
hle/service/http_c.cpp
|
||||
hle/service/ir/extra_hid.cpp
|
||||
hle/service/ir/ir.cpp
|
||||
hle/service/ir/ir_rst.cpp
|
||||
hle/service/ir/ir_u.cpp
|
||||
|
|
@ -297,6 +298,7 @@ set(HEADERS
|
|||
hle/service/hid/hid_spvr.h
|
||||
hle/service/hid/hid_user.h
|
||||
hle/service/http_c.h
|
||||
hle/service/ir/extra_hid.h
|
||||
hle/service/ir/ir.h
|
||||
hle/service/ir/ir_rst.h
|
||||
hle/service/ir/ir_u.h
|
||||
|
|
|
|||
|
|
@ -0,0 +1,231 @@
|
|||
// Copyright 2017 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include "common/alignment.h"
|
||||
#include "common/bit_field.h"
|
||||
#include "common/string_util.h"
|
||||
#include "core/core_timing.h"
|
||||
#include "core/hle/service/ir/extra_hid.h"
|
||||
#include "core/settings.h"
|
||||
|
||||
namespace Service {
|
||||
namespace IR {
|
||||
|
||||
enum class RequestID : u8 {
|
||||
/**
|
||||
* ConfigureHIDPolling request
|
||||
* Starts HID input polling, or changes the polling interval if it is already started.
|
||||
* Inputs:
|
||||
* byte 0: request ID
|
||||
* byte 1: polling interval in ms
|
||||
* byte 2: unknown
|
||||
*/
|
||||
ConfigureHIDPolling = 1,
|
||||
|
||||
/**
|
||||
* ReadCalibrationData request
|
||||
* Reads the calibration data stored in circle pad pro.
|
||||
* Inputs:
|
||||
* byte 0: request ID
|
||||
* byte 1: expected response time in ms?
|
||||
* byte 2-3: data offset (aligned to 0x10)
|
||||
* byte 4-5: data size (aligned to 0x10)
|
||||
*/
|
||||
ReadCalibrationData = 2,
|
||||
|
||||
// TODO(wwylele): there are three more request types (id = 3, 4 and 5)
|
||||
};
|
||||
|
||||
enum class ResponseID : u8 {
|
||||
|
||||
/**
|
||||
* PollHID response
|
||||
* Sends current HID status
|
||||
* Output:
|
||||
* byte 0: response ID
|
||||
* byte 1-3: Right circle pad position. This three bytes are two little-endian 12-bit
|
||||
* fields. The first one is for x-axis and the second one is for y-axis.
|
||||
* byte 4: bit[0:4] battery level; bit[5] ZL button; bit[6] ZR button; bit[7] R button
|
||||
* Note that for the three button fields, the bit is set when the button is NOT pressed.
|
||||
* byte 5: unknown
|
||||
*/
|
||||
PollHID = 0x10,
|
||||
|
||||
/**
|
||||
* ReadCalibrationData response
|
||||
* Sends the calibration data reads from circle pad pro.
|
||||
* Output:
|
||||
* byte 0: resonse ID
|
||||
* byte 1-2: data offset (aligned to 0x10)
|
||||
* byte 3-4: data size (aligned to 0x10)
|
||||
* byte 5-...: calibration data
|
||||
*/
|
||||
ReadCalibrationData = 0x11,
|
||||
};
|
||||
|
||||
ExtraHID::ExtraHID(SendFunc send_func) : IRDevice(send_func) {
|
||||
LoadInputDevices();
|
||||
|
||||
// The data below was retrieved from a New 3DS
|
||||
// TODO(wwylele): this data is probably writable (via request 3?) and thus should be saved to
|
||||
// and loaded from somewhere.
|
||||
calibration_data = std::array<u8, 0x40>{{
|
||||
// 0x00
|
||||
0x00, 0x00, 0x08, 0x80, 0x85, 0xEB, 0x11, 0x3F,
|
||||
// 0x08
|
||||
0x85, 0xEB, 0x11, 0x3F, 0xFF, 0xFF, 0xFF, 0xF5,
|
||||
// 0x10
|
||||
0xFF, 0x00, 0x08, 0x80, 0x85, 0xEB, 0x11, 0x3F,
|
||||
// 0x18
|
||||
0x85, 0xEB, 0x11, 0x3F, 0xFF, 0xFF, 0xFF, 0x65,
|
||||
// 0x20
|
||||
0xFF, 0x00, 0x08, 0x80, 0x85, 0xEB, 0x11, 0x3F,
|
||||
// 0x28
|
||||
0x85, 0xEB, 0x11, 0x3F, 0xFF, 0xFF, 0xFF, 0x65,
|
||||
// 0x30
|
||||
0xFF, 0x00, 0x08, 0x80, 0x85, 0xEB, 0x11, 0x3F,
|
||||
// 0x38
|
||||
0x85, 0xEB, 0x11, 0x3F, 0xFF, 0xFF, 0xFF, 0x65,
|
||||
}};
|
||||
|
||||
hid_polling_callback_id =
|
||||
CoreTiming::RegisterEvent("ExtraHID::SendHIDStatus", [this](u64, int cycles_late) {
|
||||
SendHIDStatus();
|
||||
CoreTiming::ScheduleEvent(msToCycles(hid_period) - cycles_late,
|
||||
hid_polling_callback_id);
|
||||
});
|
||||
}
|
||||
|
||||
ExtraHID::~ExtraHID() {
|
||||
OnDisconnect();
|
||||
}
|
||||
|
||||
void ExtraHID::OnConnect() {}
|
||||
|
||||
void ExtraHID::OnDisconnect() {
|
||||
CoreTiming::UnscheduleEvent(hid_polling_callback_id, 0);
|
||||
}
|
||||
|
||||
void ExtraHID::HandleConfigureHIDPollingRequest(const std::vector<u8>& request) {
|
||||
if (request.size() != 3) {
|
||||
LOG_ERROR(Service_IR, "Wrong request size (%zu): %s", request.size(),
|
||||
Common::ArrayToString(request.data(), request.size()).c_str());
|
||||
return;
|
||||
}
|
||||
|
||||
// Change HID input polling interval
|
||||
CoreTiming::UnscheduleEvent(hid_polling_callback_id, 0);
|
||||
hid_period = request[1];
|
||||
CoreTiming::ScheduleEvent(msToCycles(hid_period), hid_polling_callback_id);
|
||||
}
|
||||
|
||||
void ExtraHID::HandleReadCalibrationDataRequest(const std::vector<u8>& request_buf) {
|
||||
struct ReadCalibrationDataRequest {
|
||||
RequestID request_id;
|
||||
u8 expected_response_time;
|
||||
u16_le offset;
|
||||
u16_le size;
|
||||
};
|
||||
static_assert(sizeof(ReadCalibrationDataRequest) == 6,
|
||||
"ReadCalibrationDataRequest has wrong size");
|
||||
|
||||
if (request_buf.size() != sizeof(ReadCalibrationDataRequest)) {
|
||||
LOG_ERROR(Service_IR, "Wrong request size (%zu): %s", request_buf.size(),
|
||||
Common::ArrayToString(request_buf.data(), request_buf.size()).c_str());
|
||||
return;
|
||||
}
|
||||
|
||||
ReadCalibrationDataRequest request;
|
||||
std::memcpy(&request, request_buf.data(), sizeof(request));
|
||||
|
||||
const u16 offset = Common::AlignDown(request.offset, 16);
|
||||
const u16 size = Common::AlignDown(request.size, 16);
|
||||
|
||||
if (offset + size > calibration_data.size()) {
|
||||
LOG_ERROR(Service_IR, "Read beyond the end of calibration data! (offset=%u, size=%u)",
|
||||
offset, size);
|
||||
return;
|
||||
}
|
||||
|
||||
std::vector<u8> response(5);
|
||||
response[0] = static_cast<u8>(ResponseID::ReadCalibrationData);
|
||||
std::memcpy(&response[1], &request.offset, sizeof(request.offset));
|
||||
std::memcpy(&response[3], &request.size, sizeof(request.size));
|
||||
response.insert(response.end(), calibration_data.begin() + offset,
|
||||
calibration_data.begin() + offset + size);
|
||||
Send(response);
|
||||
}
|
||||
|
||||
void ExtraHID::OnReceive(const std::vector<u8>& data) {
|
||||
switch (static_cast<RequestID>(data[0])) {
|
||||
case RequestID::ConfigureHIDPolling:
|
||||
HandleConfigureHIDPollingRequest(data);
|
||||
break;
|
||||
case RequestID::ReadCalibrationData:
|
||||
HandleReadCalibrationDataRequest(data);
|
||||
break;
|
||||
default:
|
||||
LOG_ERROR(Service_IR, "Unknown request: %s",
|
||||
Common::ArrayToString(data.data(), data.size()).c_str());
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void ExtraHID::SendHIDStatus() {
|
||||
if (is_device_reload_pending.exchange(false))
|
||||
LoadInputDevices();
|
||||
|
||||
struct {
|
||||
union {
|
||||
BitField<0, 8, u32_le> header;
|
||||
BitField<8, 12, u32_le> c_stick_x;
|
||||
BitField<20, 12, u32_le> c_stick_y;
|
||||
} c_stick;
|
||||
union {
|
||||
BitField<0, 5, u8> battery_level;
|
||||
BitField<5, 1, u8> zl_not_held;
|
||||
BitField<6, 1, u8> zr_not_held;
|
||||
BitField<7, 1, u8> r_not_held;
|
||||
} buttons;
|
||||
u8 unknown;
|
||||
} response;
|
||||
static_assert(sizeof(response) == 6, "HID status response has wrong size!");
|
||||
|
||||
constexpr int C_STICK_CENTER = 0x800;
|
||||
// TODO(wwylele): this value is not accurately measured. We currently assume that the axis can
|
||||
// take values in the whole range of a 12-bit integer.
|
||||
constexpr int C_STICK_RADIUS = 0x7FF;
|
||||
|
||||
float x, y;
|
||||
std::tie(x, y) = c_stick->GetStatus();
|
||||
|
||||
response.c_stick.header.Assign(static_cast<u8>(ResponseID::PollHID));
|
||||
response.c_stick.c_stick_x.Assign(static_cast<u32>(C_STICK_CENTER + C_STICK_RADIUS * x));
|
||||
response.c_stick.c_stick_y.Assign(static_cast<u32>(C_STICK_CENTER + C_STICK_RADIUS * y));
|
||||
response.buttons.battery_level.Assign(0x1F);
|
||||
response.buttons.zl_not_held.Assign(!zl->GetStatus());
|
||||
response.buttons.zr_not_held.Assign(!zr->GetStatus());
|
||||
response.buttons.r_not_held.Assign(1);
|
||||
response.unknown = 0;
|
||||
|
||||
std::vector<u8> response_buffer(sizeof(response));
|
||||
memcpy(response_buffer.data(), &response, sizeof(response));
|
||||
Send(response_buffer);
|
||||
}
|
||||
|
||||
void ExtraHID::RequestInputDevicesReload() {
|
||||
is_device_reload_pending.store(true);
|
||||
}
|
||||
|
||||
void ExtraHID::LoadInputDevices() {
|
||||
zl = Input::CreateDevice<Input::ButtonDevice>(
|
||||
Settings::values.buttons[Settings::NativeButton::ZL]);
|
||||
zr = Input::CreateDevice<Input::ButtonDevice>(
|
||||
Settings::values.buttons[Settings::NativeButton::ZR]);
|
||||
c_stick = Input::CreateDevice<Input::AnalogDevice>(
|
||||
Settings::values.analogs[Settings::NativeAnalog::CStick]);
|
||||
}
|
||||
|
||||
} // namespace IR
|
||||
} // namespace Service
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
// Copyright 2017 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <atomic>
|
||||
#include "core/frontend/input.h"
|
||||
#include "core/hle/service/ir/ir_user.h"
|
||||
|
||||
namespace Service {
|
||||
namespace IR {
|
||||
|
||||
/**
|
||||
* An IRDevice emulating Circle Pad Pro or New 3DS additional HID hardware.
|
||||
* This device sends periodic udates at a rate configured by the 3DS, and sends calibration data if
|
||||
* requested.
|
||||
*/
|
||||
class ExtraHID final : public IRDevice {
|
||||
public:
|
||||
explicit ExtraHID(SendFunc send_func);
|
||||
~ExtraHID();
|
||||
|
||||
void OnConnect() override;
|
||||
void OnDisconnect() override;
|
||||
void OnReceive(const std::vector<u8>& data) override;
|
||||
|
||||
/// Requests input devices reload from current settings. Called when the input settings change.
|
||||
void RequestInputDevicesReload();
|
||||
|
||||
private:
|
||||
void SendHIDStatus();
|
||||
void HandleConfigureHIDPollingRequest(const std::vector<u8>& request);
|
||||
void HandleReadCalibrationDataRequest(const std::vector<u8>& request);
|
||||
void LoadInputDevices();
|
||||
|
||||
u8 hid_period;
|
||||
int hid_polling_callback_id;
|
||||
std::array<u8, 0x40> calibration_data;
|
||||
std::unique_ptr<Input::ButtonDevice> zl;
|
||||
std::unique_ptr<Input::ButtonDevice> zr;
|
||||
std::unique_ptr<Input::AnalogDevice> c_stick;
|
||||
std::atomic<bool> is_device_reload_pending;
|
||||
};
|
||||
|
||||
} // namespace IR
|
||||
} // namespace Service
|
||||
|
|
@ -2,110 +2,481 @@
|
|||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include <memory>
|
||||
#include <boost/crc.hpp>
|
||||
#include <boost/optional.hpp>
|
||||
#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<Kernel::Event> conn_status_event;
|
||||
static Kernel::SharedPtr<Kernel::SharedMemory> 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<Kernel::SharedMemory> 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<u8>& 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<u32>(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<Kernel::SharedMemory> shared_memory;
|
||||
u32 info_offset;
|
||||
u32 buffer_offset;
|
||||
u32 max_packet_count;
|
||||
u32 max_data_size;
|
||||
};
|
||||
|
||||
static Kernel::SharedPtr<Kernel::Event> conn_status_event, send_event, receive_event;
|
||||
static Kernel::SharedPtr<Kernel::SharedMemory> shared_memory;
|
||||
static std::unique_ptr<ExtraHID> extra_hid;
|
||||
static IRDevice* connected_device;
|
||||
static boost::optional<BufferManager> receive_buffer;
|
||||
|
||||
/// Wraps the payload into packet and puts it to the receive buffer
|
||||
static void PutToReceive(const std::vector<u8>& payload) {
|
||||
LOG_TRACE(Service_IR, "called, data=%s",
|
||||
Common::ArrayToString(payload.data(), payload.size()).c_str());
|
||||
size_t size = payload.size();
|
||||
|
||||
std::vector<u8> 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<u8>(size));
|
||||
} else if (size < 0x4000) {
|
||||
packet.push_back(static_cast<u8>(size >> 8) | 0x40);
|
||||
packet.push_back(static_cast<u8>(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<u32>();
|
||||
const u32 recv_buff_size = rp.Pop<u32>();
|
||||
const u32 recv_buff_packet_count = rp.Pop<u32>();
|
||||
const u32 send_buff_size = rp.Pop<u32>();
|
||||
const u32 send_buff_packet_count = rp.Pop<u32>();
|
||||
const u8 baud_rate = rp.Pop<u8>();
|
||||
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<Kernel::SharedMemory>(handle);
|
||||
transfer_shared_memory->name = "IR:TransferSharedMemory";
|
||||
shared_memory = Kernel::g_handle_table.Get<Kernel::SharedMemory>(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>();
|
||||
|
||||
conn_status_event->Signal();
|
||||
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;
|
||||
|
||||
cmd_buff[1] = RESULT_SUCCESS.raw;
|
||||
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;
|
||||
}
|
||||
|
||||
LOG_WARNING(Service_IR, "(STUBBED) called");
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.PushCopyHandles(Kernel::g_handle_table.Create(Service::IR::send_event).MoveFrom());
|
||||
|
||||
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();
|
||||
}
|
||||
|
||||
cmd_buff[1] = RESULT_SUCCESS.raw;
|
||||
u8* shared_memory_ptr = shared_memory->GetPointer();
|
||||
shared_memory_ptr[offsetof(SharedMemoryHeader, connection_status)] = 0;
|
||||
shared_memory_ptr[offsetof(SharedMemoryHeader, connected)] = 0;
|
||||
|
||||
LOG_WARNING(Service_IR, "(STUBBED) called");
|
||||
IPC::RequestBuilder rb(Kernel::GetCommandBuffer(), 0x09, 1, 0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
cmd_buff[1] = RESULT_SUCCESS.raw;
|
||||
shared_memory = nullptr;
|
||||
receive_buffer = boost::none;
|
||||
|
||||
LOG_WARNING(Service_IR, "(STUBBED) called");
|
||||
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<u32>();
|
||||
const VAddr address = rp.PopStaticBuffer();
|
||||
|
||||
std::vector<u8> 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<ErrorDescription>(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<u32>();
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
|
||||
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_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<ExtraHID>(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<u8>& data) {
|
||||
send_func(data);
|
||||
}
|
||||
|
||||
} // namespace IR
|
||||
|
|
|
|||
|
|
@ -4,11 +4,41 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include <functional>
|
||||
#include "core/hle/service/service.h"
|
||||
|
||||
namespace Service {
|
||||
namespace IR {
|
||||
|
||||
/// An interface representing a device that can communicate with 3DS via ir:USER service
|
||||
class IRDevice {
|
||||
public:
|
||||
/**
|
||||
* A function object that implements the method to send data to the 3DS, which takes a vector of
|
||||
* data to send.
|
||||
*/
|
||||
using SendFunc = std::function<void(const std::vector<u8>& data)>;
|
||||
|
||||
explicit IRDevice(SendFunc send_func);
|
||||
virtual ~IRDevice();
|
||||
|
||||
/// Called when connected with 3DS
|
||||
virtual void OnConnect() = 0;
|
||||
|
||||
/// Called when disconnected from 3DS
|
||||
virtual void OnDisconnect() = 0;
|
||||
|
||||
/// Called when data is received from the 3DS. This is invoked by the ir:USER send function.
|
||||
virtual void OnReceive(const std::vector<u8>& data) = 0;
|
||||
|
||||
protected:
|
||||
/// Sends data to the 3DS. The actual sending method is specified in the constructor
|
||||
void Send(const std::vector<u8>& data);
|
||||
|
||||
private:
|
||||
const SendFunc send_func;
|
||||
};
|
||||
|
||||
class IR_User_Interface : public Service::Interface {
|
||||
public:
|
||||
IR_User_Interface();
|
||||
|
|
@ -21,5 +51,8 @@ public:
|
|||
void InitUser();
|
||||
void ShutdownUser();
|
||||
|
||||
/// Reload input devices. Used when input configuration changed
|
||||
void ReloadInputDevices();
|
||||
|
||||
} // namespace IR
|
||||
} // namespace Service
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
#include "audio_core/audio_core.h"
|
||||
#include "core/gdbstub/gdbstub.h"
|
||||
#include "core/hle/service/hid/hid.h"
|
||||
#include "core/hle/service/ir/ir_user.h"
|
||||
#include "settings.h"
|
||||
#include "video_core/video_core.h"
|
||||
|
||||
|
|
@ -32,6 +33,7 @@ void Apply() {
|
|||
AudioCore::EnableStretching(values.enable_audio_stretching);
|
||||
|
||||
Service::HID::ReloadInputDevices();
|
||||
Service::IR::ReloadInputDevices();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
|
|
|||
Reference in New Issue