mirror of
https://github.com/Atmosphere-NX/Atmosphere.git
synced 2024-11-23 20:32:10 +00:00
460 lines
20 KiB
C++
460 lines
20 KiB
C++
/*
|
|
* Copyright (c) 2018-2020 Atmosphère-NX
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2, as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include <stratosphere.hpp>
|
|
#include "htclow_usb_impl.hpp"
|
|
|
|
namespace ams::htclow::driver {
|
|
|
|
namespace {
|
|
|
|
/* TODO: Should we identify differently than Nintendo does? */
|
|
/* It's kind of silly to identify as "NintendoSDK DevKit", but it's also kind of amusing. */
|
|
/* TBD */
|
|
|
|
constinit usb::UsbStringDescriptor LanguageStringDescriptor = { 4, usb::UsbDescriptorType_String, {0x0409}};
|
|
constinit usb::UsbStringDescriptor ManufacturerStringDescriptor = {18, usb::UsbDescriptorType_String, {'N', 'i', 'n', 't', 'e', 'n', 'd', 'o'}};
|
|
constinit usb::UsbStringDescriptor ProductStringFullSpeedDescriptor = {38, usb::UsbDescriptorType_String, {'N', 'i', 'n', 't', 'e', 'n', 'd', 'o', 'S', 'D', 'K', ' ', 'D', 'e', 'v', 'K', 'i', 't'}};
|
|
constinit usb::UsbStringDescriptor SerialNumberStringDescriptor = { 0, usb::UsbDescriptorType_String, {}};
|
|
constinit usb::UsbStringDescriptor InterfaceStringDescriptor = {16, usb::UsbDescriptorType_String, {'h', 't', 'c', ' ', 'u', 's', 'b'}};
|
|
|
|
constinit usb::UsbDeviceDescriptor UsbDeviceDescriptorFullSpeed = {
|
|
.bLength = usb::UsbDescriptorSize_Device,
|
|
.bDescriptorType = usb::UsbDescriptorType_Device,
|
|
.bcdUSB = 0x0110,
|
|
.bDeviceClass = 0x00,
|
|
.bDeviceSubClass = 0x00,
|
|
.bDeviceProtocol = 0x00,
|
|
.bMaxPacketSize0 = 0x40,
|
|
.idVendor = 0x057E,
|
|
.idProduct = 0x3005,
|
|
.bcdDevice = 0x0100,
|
|
.iManufacturer = 0x01,
|
|
.iProduct = 0x02,
|
|
.iSerialNumber = 0x03,
|
|
.bNumConfigurations = 0x01,
|
|
};
|
|
|
|
constinit usb::UsbDeviceDescriptor UsbDeviceDescriptorHighSpeed = {
|
|
.bLength = usb::UsbDescriptorSize_Device,
|
|
.bDescriptorType = usb::UsbDescriptorType_Device,
|
|
.bcdUSB = 0x0200,
|
|
.bDeviceClass = 0x00,
|
|
.bDeviceSubClass = 0x00,
|
|
.bDeviceProtocol = 0x00,
|
|
.bMaxPacketSize0 = 0x40,
|
|
.idVendor = 0x057E,
|
|
.idProduct = 0x3005,
|
|
.bcdDevice = 0x0100,
|
|
.iManufacturer = 0x01,
|
|
.iProduct = 0x02,
|
|
.iSerialNumber = 0x03,
|
|
.bNumConfigurations = 0x01,
|
|
};
|
|
|
|
constinit usb::UsbDeviceDescriptor UsbDeviceDescriptorSuperSpeed = {
|
|
.bLength = usb::UsbDescriptorSize_Device,
|
|
.bDescriptorType = usb::UsbDescriptorType_Device,
|
|
.bcdUSB = 0x0300,
|
|
.bDeviceClass = 0x00,
|
|
.bDeviceSubClass = 0x00,
|
|
.bDeviceProtocol = 0x00,
|
|
.bMaxPacketSize0 = 0x09,
|
|
.idVendor = 0x057E,
|
|
.idProduct = 0x3005,
|
|
.bcdDevice = 0x0100,
|
|
.iManufacturer = 0x01,
|
|
.iProduct = 0x02,
|
|
.iSerialNumber = 0x03,
|
|
.bNumConfigurations = 0x01,
|
|
};
|
|
|
|
constinit u8 BinaryObjectStore[] = {
|
|
0x05,
|
|
usb::UsbDescriptorType_Bos,
|
|
0x16, 0x00,
|
|
0x02,
|
|
|
|
0x07,
|
|
usb::UsbDescriptorType_DeviceCapability,
|
|
0x02,
|
|
0x02, 0x00, 0x00, 0x00,
|
|
|
|
0x0A,
|
|
usb::UsbDescriptorType_DeviceCapability,
|
|
0x03,
|
|
0x00,
|
|
0x0E, 0x00,
|
|
0x03,
|
|
0x00,
|
|
0x00, 0x00,
|
|
};
|
|
|
|
constinit usb::UsbInterfaceDescriptor UsbInterfaceDescriptor = {
|
|
.bLength = usb::UsbDescriptorSize_Interface,
|
|
.bDescriptorType = usb::UsbDescriptorType_Interface,
|
|
.bInterfaceNumber = 0x00,
|
|
.bAlternateSetting = 0x00,
|
|
.bNumEndpoints = 0x02,
|
|
.bInterfaceClass = 0xFF,
|
|
.bInterfaceSubClass = 0xFF,
|
|
.bInterfaceProtocol = 0xFF,
|
|
.iInterface = 0x04,
|
|
};
|
|
|
|
constinit usb::UsbEndpointDescriptor UsbEndpointDescriptorsFullSpeed[2] = {
|
|
{
|
|
.bLength = usb::UsbDescriptorSize_Endpoint,
|
|
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
|
|
.bEndpointAddress = 0x81,
|
|
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
|
|
.wMaxPacketSize = 0x40,
|
|
.bInterval = 0x00,
|
|
},
|
|
{
|
|
.bLength = usb::UsbDescriptorSize_Endpoint,
|
|
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
|
|
.bEndpointAddress = 0x01,
|
|
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
|
|
.wMaxPacketSize = 0x40,
|
|
.bInterval = 0x00,
|
|
}
|
|
};
|
|
|
|
constinit usb::UsbEndpointDescriptor UsbEndpointDescriptorsHighSpeed[2] = {
|
|
{
|
|
.bLength = usb::UsbDescriptorSize_Endpoint,
|
|
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
|
|
.bEndpointAddress = 0x81,
|
|
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
|
|
.wMaxPacketSize = 0x200,
|
|
.bInterval = 0x00,
|
|
},
|
|
{
|
|
.bLength = usb::UsbDescriptorSize_Endpoint,
|
|
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
|
|
.bEndpointAddress = 0x01,
|
|
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
|
|
.wMaxPacketSize = 0x200,
|
|
.bInterval = 0x00,
|
|
}
|
|
};
|
|
|
|
constinit usb::UsbEndpointDescriptor UsbEndpointDescriptorsSuperSpeed[2] = {
|
|
{
|
|
.bLength = usb::UsbDescriptorSize_Endpoint,
|
|
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
|
|
.bEndpointAddress = 0x81,
|
|
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
|
|
.wMaxPacketSize = 0x400,
|
|
.bInterval = 0x00,
|
|
},
|
|
{
|
|
.bLength = usb::UsbDescriptorSize_Endpoint,
|
|
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
|
|
.bEndpointAddress = 0x01,
|
|
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
|
|
.wMaxPacketSize = 0x400,
|
|
.bInterval = 0x00,
|
|
}
|
|
};
|
|
|
|
constinit usb::UsbEndpointCompanionDescriptor UsbEndpointCompanionDescriptor = {
|
|
.bLength = usb::UsbDescriptorSize_EndpointCompanion,
|
|
.bDescriptorType = usb::UsbDescriptorType_EndpointCompanion,
|
|
.bMaxBurst = 0x0F,
|
|
.bmAttributes = 0x00,
|
|
.wBytesPerInterval = 0x0000,
|
|
};
|
|
|
|
constexpr size_t UsbDmaBufferSize = 0x60000;
|
|
|
|
alignas(os::MemoryPageSize) constinit u8 g_usb_receive_buffer[UsbDmaBufferSize];
|
|
alignas(os::MemoryPageSize) constinit u8 g_usb_send_buffer[UsbDmaBufferSize];
|
|
alignas(os::ThreadStackAlignment) constinit u8 g_usb_indication_thread_stack[16_KB];
|
|
|
|
constinit UsbAvailabilityChangeCallback g_availability_change_callback = nullptr;
|
|
constinit void *g_availability_change_param = nullptr;
|
|
|
|
constinit bool g_usb_interface_initialized = false;
|
|
|
|
os::Event g_usb_break_event(os::EventClearMode_ManualClear);
|
|
|
|
constinit os::ThreadType g_usb_indication_thread = {};
|
|
|
|
constinit os::SdkMutex g_usb_driver_mutex;
|
|
|
|
usb::DsClient g_ds_client;
|
|
usb::DsInterface g_ds_interface;
|
|
usb::DsEndpoint g_ds_endpoints[2];
|
|
|
|
void InvokeAvailabilityChangeCallback(UsbAvailability availability) {
|
|
if (g_availability_change_callback) {
|
|
g_availability_change_callback(availability, g_availability_change_param);
|
|
}
|
|
}
|
|
|
|
Result ConvertUsbDriverResult(Result result) {
|
|
if (result.GetModule() == R_NAMESPACE_MODULE_ID(usb)) {
|
|
if (usb::ResultResourceBusy::Includes(result)) {
|
|
return htclow::ResultUsbDriverBusyError();
|
|
} else if (usb::ResultMemAllocFailure::Includes(result)) {
|
|
return htclow::ResultOutOfMemory();
|
|
} else {
|
|
return htclow::ResultUsbDriverUnknownError();
|
|
}
|
|
} else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Result InitializeDsClient() {
|
|
/* Initialize the client. */
|
|
R_TRY(ConvertUsbDriverResult(g_ds_client.Initialize(usb::ComplexId_Tegra21x)));
|
|
|
|
/* Clear device data. */
|
|
R_ABORT_UNLESS(g_ds_client.ClearDeviceData());
|
|
|
|
/* Add string descriptors. */
|
|
u8 index;
|
|
R_TRY(g_ds_client.AddUsbStringDescriptor(std::addressof(index), std::addressof(LanguageStringDescriptor)));
|
|
R_TRY(g_ds_client.AddUsbStringDescriptor(std::addressof(index), std::addressof(ManufacturerStringDescriptor)));
|
|
R_TRY(g_ds_client.AddUsbStringDescriptor(std::addressof(index), std::addressof(ProductStringFullSpeedDescriptor)));
|
|
R_TRY(g_ds_client.AddUsbStringDescriptor(std::addressof(index), std::addressof(SerialNumberStringDescriptor)));
|
|
R_TRY(g_ds_client.AddUsbStringDescriptor(std::addressof(index), std::addressof(InterfaceStringDescriptor)));
|
|
|
|
/* Add device descriptors. */
|
|
R_TRY(g_ds_client.SetUsbDeviceDescriptor(std::addressof(UsbDeviceDescriptorFullSpeed), usb::UsbDeviceSpeed_Full));
|
|
R_TRY(g_ds_client.SetUsbDeviceDescriptor(std::addressof(UsbDeviceDescriptorHighSpeed), usb::UsbDeviceSpeed_High));
|
|
R_TRY(g_ds_client.SetUsbDeviceDescriptor(std::addressof(UsbDeviceDescriptorSuperSpeed), usb::UsbDeviceSpeed_Super));
|
|
|
|
/* Set binary object store. */
|
|
R_TRY(g_ds_client.SetBinaryObjectStore(BinaryObjectStore, sizeof(BinaryObjectStore)));
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result InitializeDsInterface() {
|
|
/* Initialize the interface. */
|
|
R_TRY(ConvertUsbDriverResult(g_ds_interface.Initialize(std::addressof(g_ds_client), 0)));
|
|
|
|
/* Append the interface descriptors for all speeds. */
|
|
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Full, std::addressof(UsbInterfaceDescriptor), sizeof(usb::UsbInterfaceDescriptor)));
|
|
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Full, std::addressof(UsbEndpointDescriptorsFullSpeed[0]), sizeof(usb::UsbEndpointDescriptor)));
|
|
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Full, std::addressof(UsbEndpointDescriptorsFullSpeed[1]), sizeof(usb::UsbEndpointDescriptor)));
|
|
|
|
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_High, std::addressof(UsbInterfaceDescriptor), sizeof(usb::UsbInterfaceDescriptor)));
|
|
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_High, std::addressof(UsbEndpointDescriptorsHighSpeed[0]), sizeof(usb::UsbEndpointDescriptor)));
|
|
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_High, std::addressof(UsbEndpointDescriptorsHighSpeed[1]), sizeof(usb::UsbEndpointDescriptor)));
|
|
|
|
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Super, std::addressof(UsbInterfaceDescriptor), sizeof(usb::UsbInterfaceDescriptor)));
|
|
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Super, std::addressof(UsbEndpointDescriptorsSuperSpeed[0]), sizeof(usb::UsbEndpointDescriptor)));
|
|
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Super, std::addressof(UsbEndpointCompanionDescriptor), sizeof(usb::UsbEndpointCompanionDescriptor)));
|
|
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Super, std::addressof(UsbEndpointDescriptorsSuperSpeed[1]), sizeof(usb::UsbEndpointDescriptor)));
|
|
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Super, std::addressof(UsbEndpointCompanionDescriptor), sizeof(usb::UsbEndpointCompanionDescriptor)));
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result InitializeDsEndpoints() {
|
|
R_TRY(g_ds_endpoints[0].Initialize(std::addressof(g_ds_interface), 0x81));
|
|
R_TRY(g_ds_endpoints[1].Initialize(std::addressof(g_ds_interface), 0x01));
|
|
return ResultSuccess();
|
|
}
|
|
|
|
void UsbIndicationThreadFunction(void *arg) {
|
|
/* Get the state change event. */
|
|
os::SystemEventType *state_change_event = g_ds_client.GetStateChangeEvent();
|
|
|
|
/* Setup waitable manager. */
|
|
os::WaitableManagerType manager;
|
|
os::InitializeWaitableManager(std::addressof(manager));
|
|
|
|
/* Link waitable holders. */
|
|
os::WaitableHolderType state_change_holder;
|
|
os::WaitableHolderType break_holder;
|
|
os::InitializeWaitableHolder(std::addressof(state_change_holder), state_change_event);
|
|
os::LinkWaitableHolder(std::addressof(manager), std::addressof(state_change_holder));
|
|
os::InitializeWaitableHolder(std::addressof(break_holder), g_usb_break_event.GetBase());
|
|
os::LinkWaitableHolder(std::addressof(manager), std::addressof(break_holder));
|
|
|
|
/* Loop forever. */
|
|
while (true) {
|
|
/* If we should break, do so. */
|
|
if (os::WaitAny(std::addressof(manager)) == std::addressof(break_holder)) {
|
|
break;
|
|
}
|
|
|
|
/* Clear the state change event. */
|
|
os::ClearSystemEvent(state_change_event);
|
|
|
|
/* Get the new state. */
|
|
usb::UsbState usb_state;
|
|
R_ABORT_UNLESS(g_ds_client.GetState(std::addressof(usb_state)));
|
|
|
|
switch (usb_state) {
|
|
case UsbState_Detached:
|
|
case UsbState_Suspended:
|
|
InvokeAvailabilityChangeCallback(UsbAvailability_Unavailable);
|
|
break;
|
|
case UsbState_Configured:
|
|
InvokeAvailabilityChangeCallback(UsbAvailability_Available);
|
|
break;
|
|
default:
|
|
/* Nothing to do. */
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Clear the break event. */
|
|
g_usb_break_event.Clear();
|
|
|
|
/* Unlink all holders. */
|
|
os::UnlinkAllWaitableHolder(std::addressof(manager));
|
|
|
|
/* Finalize the waitable holders and manager. */
|
|
os::FinalizeWaitableHolder(std::addressof(break_holder));
|
|
os::FinalizeWaitableHolder(std::addressof(state_change_holder));
|
|
os::FinalizeWaitableManager(std::addressof(manager));
|
|
}
|
|
|
|
}
|
|
|
|
void SetUsbAvailabilityChangeCallback(UsbAvailabilityChangeCallback callback, void *param) {
|
|
g_availability_change_callback = callback;
|
|
g_availability_change_param = param;
|
|
}
|
|
|
|
void ClearUsbAvailabilityChangeCallback() {
|
|
g_availability_change_callback = nullptr;
|
|
g_availability_change_param = nullptr;
|
|
}
|
|
|
|
Result InitializeUsbInterface() {
|
|
/* Set the interface as initialized. */
|
|
g_usb_interface_initialized = true;
|
|
|
|
/* If we fail somewhere, finalize. */
|
|
auto init_guard = SCOPE_GUARD { FinalizeUsbInterface(); };
|
|
|
|
/* Get the serial number. */
|
|
{
|
|
settings::factory::SerialNumber serial_number;
|
|
serial_number.str[0] = '\x00';
|
|
|
|
if (R_FAILED(settings::factory::GetSerialNumber(std::addressof(serial_number))) || serial_number.str[0] == '\x00') {
|
|
std::strcpy(serial_number.str, "Corrupted S/N");
|
|
}
|
|
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
|
|
|
|
u16 *dst = SerialNumberStringDescriptor.wData;
|
|
u8 *src = reinterpret_cast<u8 *>(serial_number.str);
|
|
u8 count = 0;
|
|
|
|
#pragma GCC diagnostic pop
|
|
|
|
while (*src) {
|
|
*dst++ = static_cast<u16>(*src++);
|
|
++count;
|
|
}
|
|
|
|
SerialNumberStringDescriptor.bLength = 2 + (2 * count);
|
|
}
|
|
|
|
/* Initialize the client. */
|
|
R_TRY(InitializeDsClient());
|
|
|
|
/* Initialize the interface. */
|
|
R_TRY(InitializeDsInterface());
|
|
|
|
/* Initialize the endpoints. */
|
|
R_TRY(ConvertUsbDriverResult(InitializeDsEndpoints()));
|
|
|
|
/* Create the indication thread. */
|
|
R_ABORT_UNLESS(os::CreateThread(std::addressof(g_usb_indication_thread), &UsbIndicationThreadFunction, nullptr, g_usb_indication_thread_stack, sizeof(g_usb_indication_thread_stack), AMS_GET_SYSTEM_THREAD_PRIORITY(htc, HtclowUsbIndication)));
|
|
|
|
/* Set the thread name. */
|
|
os::SetThreadNamePointer(std::addressof(g_usb_indication_thread), AMS_GET_SYSTEM_THREAD_NAME(htc, HtclowUsbIndication));
|
|
|
|
/* Start the indication thread. */
|
|
os::StartThread(std::addressof(g_usb_indication_thread));
|
|
|
|
/* Enable the usb device. */
|
|
R_TRY(g_ds_client.EnableDevice());
|
|
|
|
/* We succeeded! */
|
|
init_guard.Cancel();
|
|
return ResultSuccess();
|
|
}
|
|
|
|
void FinalizeUsbInterface() {
|
|
g_usb_break_event.Signal();
|
|
os::WaitThread(std::addressof(g_usb_indication_thread));
|
|
os::DestroyThread(std::addressof(g_usb_indication_thread));
|
|
g_ds_client.DisableDevice();
|
|
g_ds_endpoints[1].Finalize();
|
|
g_ds_endpoints[0].Finalize();
|
|
g_ds_interface.Finalize();
|
|
g_ds_client.Finalize();
|
|
g_usb_interface_initialized = false;
|
|
}
|
|
|
|
Result SendUsb(int *out_transferred, const void *src, int src_size) {
|
|
/* Acquire exclusive access to the driver. */
|
|
std::scoped_lock lk(g_usb_driver_mutex);
|
|
|
|
/* Check that we can send the data. */
|
|
R_UNLESS(src_size <= static_cast<int>(UsbDmaBufferSize), htclow::ResultInvalidArgument());
|
|
|
|
/* Copy the data to the dma buffer. */
|
|
std::memcpy(g_usb_send_buffer, src, src_size);
|
|
|
|
/* Transfer data. */
|
|
u32 transferred;
|
|
R_UNLESS(R_SUCCEEDED(g_ds_endpoints[0].PostBuffer(std::addressof(transferred), g_usb_send_buffer, src_size)), htclow::ResultUsbDriverSendError());
|
|
R_UNLESS(transferred == static_cast<u32>(src_size), htclow::ResultUsbDriverSendError());
|
|
|
|
/* Set output transferred size. */
|
|
*out_transferred = src_size;
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result ReceiveUsb(int *out_transferred, void *dst, int dst_size) {
|
|
/* Check that we can send the data. */
|
|
R_UNLESS(dst_size <= static_cast<int>(UsbDmaBufferSize), htclow::ResultInvalidArgument());
|
|
|
|
/* Transfer data. */
|
|
u32 transferred;
|
|
R_UNLESS(R_SUCCEEDED(g_ds_endpoints[1].PostBuffer(std::addressof(transferred), g_usb_receive_buffer, dst_size)), htclow::ResultUsbDriverReceiveError());
|
|
R_UNLESS(transferred == static_cast<u32>(dst_size), htclow::ResultUsbDriverReceiveError());
|
|
|
|
/* Copy the data. */
|
|
std::memcpy(dst, g_usb_receive_buffer, dst_size);
|
|
|
|
/* Set output transferred size. */
|
|
*out_transferred = dst_size;
|
|
return ResultSuccess();
|
|
}
|
|
|
|
void CancelUsbSendReceive() {
|
|
if (g_usb_interface_initialized) {
|
|
g_ds_endpoints[0].Cancel();
|
|
g_ds_endpoints[1].Cancel();
|
|
}
|
|
}
|
|
|
|
}
|