mirrors/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2025-07-23 18:45:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into fontlib

Browse Source
This commit is contained in:
georgemoralis 2025-04-01 09:42:21 +03:00 committed by GitHub
commit cb77f4ab36
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
12 changed files with 551 additions and 384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored
View File

@ -107,3 +107,6 @@
path = externals/MoltenVK/cereal path = externals/MoltenVK/cereal
url = https://github.com/USCiLab/cereal url = https://github.com/USCiLab/cereal
shallow = true shallow = true
[submodule "externals/libusb"]
path = externals/libusb
url = https://github.com/libusb/libusb-cmake.git

7
CMakeLists.txt
View File

@ -224,10 +224,7 @@ find_package(xxHash 0.8.2 MODULE)
find_package(ZLIB 1.3 MODULE) find_package(ZLIB 1.3 MODULE)
find_package(Zydis 5.0.0 CONFIG) find_package(Zydis 5.0.0 CONFIG)
find_package(pugixml 1.14 CONFIG) find_package(pugixml 1.14 CONFIG)
find_package(libusb 1.0.27 MODULE)
if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR NOT MSVC)
find_package(cryptopp 8.9.0 MODULE)
endif()
if (APPLE) if (APPLE)
find_package(date 3.0.1 CONFIG) find_package(date 3.0.1 CONFIG)
@ -1067,7 +1064,7 @@ endif()
create_target_directory_groups(shadps4) create_target_directory_groups(shadps4)
target_link_libraries(shadps4 PRIVATE magic_enum::magic_enum fmt::fmt toml11::toml11 tsl::robin_map xbyak::xbyak Tracy::TracyClient RenderDoc::API FFmpeg::ffmpeg Dear_ImGui gcn half::half ZLIB::ZLIB PNG::PNG) target_link_libraries(shadps4 PRIVATE magic_enum::magic_enum fmt::fmt toml11::toml11 tsl::robin_map xbyak::xbyak Tracy::TracyClient RenderDoc::API FFmpeg::ffmpeg Dear_ImGui gcn half::half ZLIB::ZLIB PNG::PNG)
target_link_libraries(shadps4 PRIVATE Boost::headers GPUOpen::VulkanMemoryAllocator LibAtrac9 sirit Vulkan::Headers xxHash::xxhash Zydis::Zydis glslang::glslang SDL3::SDL3 pugixml::pugixml stb::headers) target_link_libraries(shadps4 PRIVATE Boost::headers GPUOpen::VulkanMemoryAllocator LibAtrac9 sirit Vulkan::Headers xxHash::xxhash Zydis::Zydis glslang::glslang SDL3::SDL3 pugixml::pugixml stb::headers libusb::usb)
target_compile_definitions(shadps4 PRIVATE IMGUI_USER_CONFIG="imgui/imgui_config.h") target_compile_definitions(shadps4 PRIVATE IMGUI_USER_CONFIG="imgui/imgui_config.h")
target_compile_definitions(Dear_ImGui PRIVATE IMGUI_USER_CONFIG="${PROJECT_SOURCE_DIR}/src/imgui/imgui_config.h") target_compile_definitions(Dear_ImGui PRIVATE IMGUI_USER_CONFIG="${PROJECT_SOURCE_DIR}/src/imgui/imgui_config.h")

15
cmake/Findcryptopp.cmake
View File

@ -1,15 +0,0 @@
# SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
# SPDX-License-Identifier: GPL-2.0-or-later
find_package(PkgConfig QUIET)
pkg_search_module(CRYPTOPP QUIET IMPORTED_TARGET libcryptopp)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(cryptopp
REQUIRED_VARS CRYPTOPP_LINK_LIBRARIES
VERSION_VAR CRYPTOPP_VERSION
)
if (cryptopp_FOUND AND NOT TARGET cryptopp::cryptopp)
add_library(cryptopp::cryptopp ALIAS PkgConfig::CRYPTOPP)
endif()

15
cmake/Findlibusb.cmake Normal file
View File

@ -0,0 +1,15 @@
# SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project
# SPDX-License-Identifier: GPL-2.0-or-later
find_package(PkgConfig QUIET)
pkg_search_module(LIBUSB QUIET IMPORTED_TARGET libusb-1.0)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(libusb
REQUIRED_VARS LIBUSB_LINK_LIBRARIES
VERSION_VAR LIBUSB_VERSION
)
if (libusb_FOUND AND NOT TARGET libusb::usb)
add_library(libusb::usb ALIAS PkgConfig::LIBUSB)
endif()

6
externals/CMakeLists.txt vendored
View File

@ -201,6 +201,12 @@ if (NOT TARGET pugixml::pugixml)
add_subdirectory(pugixml) add_subdirectory(pugixml)
endif() endif()
# libusb
if (NOT TARGET libusb::usb)
add_subdirectory(libusb)
add_library(libusb::usb ALIAS usb-1.0)
endif()
# Discord RPC # Discord RPC
if (ENABLE_DISCORD_RPC) if (ENABLE_DISCORD_RPC)
add_subdirectory(discord-rpc) add_subdirectory(discord-rpc)

1
externals/libusb vendored Submodule

@ -0,0 +1 @@
Subproject commit 8f0b4a38fc3eefa2b26a99dff89e1c12bf37afd4

152
src/core/libraries/ngs2/ngs2.cpp
View File

@ -18,36 +18,32 @@ namespace Libraries::Ngs2 {
s32 PS4_SYSV_ABI sceNgs2CalcWaveformBlock(const OrbisNgs2WaveformFormat* format, u32 samplePos, s32 PS4_SYSV_ABI sceNgs2CalcWaveformBlock(const OrbisNgs2WaveformFormat* format, u32 samplePos,
u32 numSamples, OrbisNgs2WaveformBlock* outBlock) { u32 numSamples, OrbisNgs2WaveformBlock* outBlock) {
LOG_INFO(Lib_Ngs2, "samplePos = {}, numSamples = {}", samplePos, numSamples); LOG_ERROR(Lib_Ngs2, "samplePos = {}, numSamples = {}", samplePos, numSamples);
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2GetWaveformFrameInfo(const OrbisNgs2WaveformFormat* format, s32 PS4_SYSV_ABI sceNgs2GetWaveformFrameInfo(const OrbisNgs2WaveformFormat* format,
u32* outFrameSize, u32* outNumFrameSamples, u32* outFrameSize, u32* outNumFrameSamples,
u32* outUnitsPerFrame, u32* outNumDelaySamples) { u32* outUnitsPerFrame, u32* outNumDelaySamples) {
LOG_INFO(Lib_Ngs2, "called"); LOG_ERROR(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2ParseWaveformData(const void* data, size_t dataSize, s32 PS4_SYSV_ABI sceNgs2ParseWaveformData(const void* data, size_t dataSize,
OrbisNgs2WaveformInfo* outInfo) { OrbisNgs2WaveformInfo* outInfo) {
LOG_INFO(Lib_Ngs2, "dataSize = {}", dataSize); LOG_ERROR(Lib_Ngs2, "dataSize = {}", dataSize);
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2ParseWaveformFile(const char* path, u64 offset, s32 PS4_SYSV_ABI sceNgs2ParseWaveformFile(const char* path, u64 offset,
OrbisNgs2WaveformInfo* outInfo) { OrbisNgs2WaveformInfo* outInfo) {
LOG_INFO(Lib_Ngs2, "path = {}, offset = {}", path, offset); LOG_ERROR(Lib_Ngs2, "path = {}, offset = {}", path, offset);
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2ParseWaveformUser(OrbisNgs2ParseReadHandler handler, uintptr_t userData, s32 PS4_SYSV_ABI sceNgs2ParseWaveformUser(OrbisNgs2ParseReadHandler handler, uintptr_t userData,
OrbisNgs2WaveformInfo* outInfo) { OrbisNgs2WaveformInfo* outInfo) {
LOG_INFO(Lib_Ngs2, "userData = {}", userData); LOG_ERROR(Lib_Ngs2, "userData = {}", userData);
if (!handler) {
LOG_ERROR(Lib_Ngs2, "handler is nullptr");
return ORBIS_NGS2_ERROR_INVALID_HANDLE;
}
return ORBIS_OK; return ORBIS_OK;
} }
@ -55,7 +51,7 @@ s32 PS4_SYSV_ABI sceNgs2RackCreate(OrbisNgs2Handle systemHandle, u32 rackId,
const OrbisNgs2RackOption* option, const OrbisNgs2RackOption* option,
const OrbisNgs2ContextBufferInfo* bufferInfo, const OrbisNgs2ContextBufferInfo* bufferInfo,
OrbisNgs2Handle* outHandle) { OrbisNgs2Handle* outHandle) {
LOG_INFO(Lib_Ngs2, "rackId = {}", rackId); LOG_ERROR(Lib_Ngs2, "rackId = {}", rackId);
if (!systemHandle) { if (!systemHandle) {
LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr"); LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE; return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE;
@ -67,7 +63,7 @@ s32 PS4_SYSV_ABI sceNgs2RackCreateWithAllocator(OrbisNgs2Handle systemHandle, u3
const OrbisNgs2RackOption* option, const OrbisNgs2RackOption* option,
const OrbisNgs2BufferAllocator* allocator, const OrbisNgs2BufferAllocator* allocator,
OrbisNgs2Handle* outHandle) { OrbisNgs2Handle* outHandle) {
LOG_INFO(Lib_Ngs2, "rackId = {}", rackId); LOG_ERROR(Lib_Ngs2, "rackId = {}", rackId);
if (!systemHandle) { if (!systemHandle) {
LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr"); LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE; return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE;
@ -77,73 +73,45 @@ s32 PS4_SYSV_ABI sceNgs2RackCreateWithAllocator(OrbisNgs2Handle systemHandle, u3
s32 PS4_SYSV_ABI sceNgs2RackDestroy(OrbisNgs2Handle rackHandle, s32 PS4_SYSV_ABI sceNgs2RackDestroy(OrbisNgs2Handle rackHandle,
OrbisNgs2ContextBufferInfo* outBufferInfo) { OrbisNgs2ContextBufferInfo* outBufferInfo) {
if (!rackHandle) { LOG_ERROR(Lib_Ngs2, "called");
LOG_ERROR(Lib_Ngs2, "rackHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_RACK_HANDLE;
}
LOG_INFO(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2RackGetInfo(OrbisNgs2Handle rackHandle, OrbisNgs2RackInfo* outInfo, s32 PS4_SYSV_ABI sceNgs2RackGetInfo(OrbisNgs2Handle rackHandle, OrbisNgs2RackInfo* outInfo,
size_t infoSize) { size_t infoSize) {
LOG_INFO(Lib_Ngs2, "infoSize = {}", infoSize); LOG_ERROR(Lib_Ngs2, "infoSize = {}", infoSize);
if (!rackHandle) {
LOG_ERROR(Lib_Ngs2, "rackHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_RACK_HANDLE;
}
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2RackGetUserData(OrbisNgs2Handle rackHandle, uintptr_t* outUserData) { s32 PS4_SYSV_ABI sceNgs2RackGetUserData(OrbisNgs2Handle rackHandle, uintptr_t* outUserData) {
if (!rackHandle) { LOG_ERROR(Lib_Ngs2, "called");
LOG_ERROR(Lib_Ngs2, "rackHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_RACK_HANDLE;
}
LOG_INFO(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2RackGetVoiceHandle(OrbisNgs2Handle rackHandle, u32 voiceIndex, s32 PS4_SYSV_ABI sceNgs2RackGetVoiceHandle(OrbisNgs2Handle rackHandle, u32 voiceIndex,
OrbisNgs2Handle* outHandle) { OrbisNgs2Handle* outHandle) {
LOG_INFO(Lib_Ngs2, "voiceIndex = {}", voiceIndex); LOG_DEBUG(Lib_Ngs2, "(STUBBED) voiceIndex = {}", voiceIndex);
if (!rackHandle) {
LOG_ERROR(Lib_Ngs2, "rackHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_RACK_HANDLE;
}
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2RackLock(OrbisNgs2Handle rackHandle) { s32 PS4_SYSV_ABI sceNgs2RackLock(OrbisNgs2Handle rackHandle) {
if (!rackHandle) { LOG_ERROR(Lib_Ngs2, "called");
LOG_ERROR(Lib_Ngs2, "rackHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_RACK_HANDLE;
}
LOG_INFO(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2RackQueryBufferSize(u32 rackId, const OrbisNgs2RackOption* option, s32 PS4_SYSV_ABI sceNgs2RackQueryBufferSize(u32 rackId, const OrbisNgs2RackOption* option,
OrbisNgs2ContextBufferInfo* outBufferInfo) { OrbisNgs2ContextBufferInfo* outBufferInfo) {
LOG_INFO(Lib_Ngs2, "rackId = {}", rackId); LOG_ERROR(Lib_Ngs2, "rackId = {}", rackId);
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2RackSetUserData(OrbisNgs2Handle rackHandle, uintptr_t userData) { s32 PS4_SYSV_ABI sceNgs2RackSetUserData(OrbisNgs2Handle rackHandle, uintptr_t userData) {
LOG_INFO(Lib_Ngs2, "userData = {}", userData); LOG_ERROR(Lib_Ngs2, "userData = {}", userData);
if (!rackHandle) {
LOG_ERROR(Lib_Ngs2, "rackHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_RACK_HANDLE;
}
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2RackUnlock(OrbisNgs2Handle rackHandle) { s32 PS4_SYSV_ABI sceNgs2RackUnlock(OrbisNgs2Handle rackHandle) {
if (!rackHandle) { LOG_ERROR(Lib_Ngs2, "called");
LOG_ERROR(Lib_Ngs2, "rackHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_RACK_HANDLE;
}
LOG_INFO(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
@ -188,17 +156,17 @@ s32 PS4_SYSV_ABI sceNgs2SystemCreateWithAllocator(const OrbisNgs2SystemOption* o
OrbisNgs2BufferAllocHandler hostAlloc = allocator->allocHandler; OrbisNgs2BufferAllocHandler hostAlloc = allocator->allocHandler;
if (outHandle) { if (outHandle) {
OrbisNgs2BufferFreeHandler hostFree = allocator->freeHandler; OrbisNgs2BufferFreeHandler hostFree = allocator->freeHandler;
OrbisNgs2ContextBufferInfo* bufferInfo = 0; OrbisNgs2ContextBufferInfo bufferInfo;
result = SystemSetup(option, bufferInfo, 0, 0); result = SystemSetup(option, &bufferInfo, 0, 0);
if (result >= 0) { if (result >= 0) {
uintptr_t sysUserData = allocator->userData; uintptr_t sysUserData = allocator->userData;
result = hostAlloc(bufferInfo); result = Core::ExecuteGuest(hostAlloc, &bufferInfo);
if (result >= 0) { if (result >= 0) {
OrbisNgs2Handle* handleCopy = outHandle; OrbisNgs2Handle* handleCopy = outHandle;
result = SystemSetup(option, bufferInfo, hostFree, handleCopy); result = SystemSetup(option, &bufferInfo, hostFree, handleCopy);
if (result < 0) { if (result < 0) {
if (hostFree) { if (hostFree) {
hostFree(bufferInfo); Core::ExecuteGuest(hostFree, &bufferInfo);
} }
} }
} }
@ -226,13 +194,13 @@ s32 PS4_SYSV_ABI sceNgs2SystemDestroy(OrbisNgs2Handle systemHandle,
} }
s32 PS4_SYSV_ABI sceNgs2SystemEnumHandles(OrbisNgs2Handle* aOutHandle, u32 maxHandles) { s32 PS4_SYSV_ABI sceNgs2SystemEnumHandles(OrbisNgs2Handle* aOutHandle, u32 maxHandles) {
LOG_INFO(Lib_Ngs2, "maxHandles = {}", maxHandles); LOG_ERROR(Lib_Ngs2, "maxHandles = {}", maxHandles);
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2SystemEnumRackHandles(OrbisNgs2Handle systemHandle, s32 PS4_SYSV_ABI sceNgs2SystemEnumRackHandles(OrbisNgs2Handle systemHandle,
OrbisNgs2Handle* aOutHandle, u32 maxHandles) { OrbisNgs2Handle* aOutHandle, u32 maxHandles) {
LOG_INFO(Lib_Ngs2, "maxHandles = {}", maxHandles); LOG_ERROR(Lib_Ngs2, "maxHandles = {}", maxHandles);
if (!systemHandle) { if (!systemHandle) {
LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr"); LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE; return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE;
@ -242,11 +210,7 @@ s32 PS4_SYSV_ABI sceNgs2SystemEnumRackHandles(OrbisNgs2Handle systemHandle,
s32 PS4_SYSV_ABI sceNgs2SystemGetInfo(OrbisNgs2Handle rackHandle, OrbisNgs2SystemInfo* outInfo, s32 PS4_SYSV_ABI sceNgs2SystemGetInfo(OrbisNgs2Handle rackHandle, OrbisNgs2SystemInfo* outInfo,
size_t infoSize) { size_t infoSize) {
LOG_INFO(Lib_Ngs2, "infoSize = {}", infoSize); LOG_ERROR(Lib_Ngs2, "infoSize = {}", infoSize);
if (!rackHandle) {
LOG_ERROR(Lib_Ngs2, "rackHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_RACK_HANDLE;
}
return ORBIS_OK; return ORBIS_OK;
} }
@ -255,7 +219,7 @@ s32 PS4_SYSV_ABI sceNgs2SystemGetUserData(OrbisNgs2Handle systemHandle, uintptr_
LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr"); LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE; return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE;
} }
LOG_INFO(Lib_Ngs2, "called"); LOG_ERROR(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
@ -264,7 +228,7 @@ s32 PS4_SYSV_ABI sceNgs2SystemLock(OrbisNgs2Handle systemHandle) {
LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr"); LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE; return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE;
} }
LOG_INFO(Lib_Ngs2, "called"); LOG_ERROR(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
@ -285,7 +249,7 @@ s32 PS4_SYSV_ABI sceNgs2SystemQueryBufferSize(const OrbisNgs2SystemOption* optio
s32 PS4_SYSV_ABI sceNgs2SystemRender(OrbisNgs2Handle systemHandle, s32 PS4_SYSV_ABI sceNgs2SystemRender(OrbisNgs2Handle systemHandle,
const OrbisNgs2RenderBufferInfo* aBufferInfo, const OrbisNgs2RenderBufferInfo* aBufferInfo,
u32 numBufferInfo) { u32 numBufferInfo) {
LOG_INFO(Lib_Ngs2, "numBufferInfo = {}", numBufferInfo); LOG_DEBUG(Lib_Ngs2, "(STUBBED) numBufferInfo = {}", numBufferInfo);
if (!systemHandle) { if (!systemHandle) {
LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr"); LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE; return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE;
@ -308,7 +272,7 @@ static s32 PS4_SYSV_ABI sceNgs2SystemResetOption(OrbisNgs2SystemOption* outOptio
} }
s32 PS4_SYSV_ABI sceNgs2SystemSetGrainSamples(OrbisNgs2Handle systemHandle, u32 numSamples) { s32 PS4_SYSV_ABI sceNgs2SystemSetGrainSamples(OrbisNgs2Handle systemHandle, u32 numSamples) {
LOG_INFO(Lib_Ngs2, "numSamples = {}", numSamples); LOG_ERROR(Lib_Ngs2, "numSamples = {}", numSamples);
if (!systemHandle) { if (!systemHandle) {
LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr"); LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE; return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE;
@ -317,7 +281,7 @@ s32 PS4_SYSV_ABI sceNgs2SystemSetGrainSamples(OrbisNgs2Handle systemHandle, u32
} }
s32 PS4_SYSV_ABI sceNgs2SystemSetSampleRate(OrbisNgs2Handle systemHandle, u32 sampleRate) { s32 PS4_SYSV_ABI sceNgs2SystemSetSampleRate(OrbisNgs2Handle systemHandle, u32 sampleRate) {
LOG_INFO(Lib_Ngs2, "sampleRate = {}", sampleRate); LOG_ERROR(Lib_Ngs2, "sampleRate = {}", sampleRate);
if (!systemHandle) { if (!systemHandle) {
LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr"); LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE; return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE;
@ -326,7 +290,7 @@ s32 PS4_SYSV_ABI sceNgs2SystemSetSampleRate(OrbisNgs2Handle systemHandle, u32 sa
} }
s32 PS4_SYSV_ABI sceNgs2SystemSetUserData(OrbisNgs2Handle systemHandle, uintptr_t userData) { s32 PS4_SYSV_ABI sceNgs2SystemSetUserData(OrbisNgs2Handle systemHandle, uintptr_t userData) {
LOG_INFO(Lib_Ngs2, "userData = {}", userData); LOG_ERROR(Lib_Ngs2, "userData = {}", userData);
if (!systemHandle) { if (!systemHandle) {
LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr"); LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE; return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE;
@ -339,66 +303,42 @@ s32 PS4_SYSV_ABI sceNgs2SystemUnlock(OrbisNgs2Handle systemHandle) {
LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr"); LOG_ERROR(Lib_Ngs2, "systemHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE; return ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE;
} }
LOG_INFO(Lib_Ngs2, "called"); LOG_ERROR(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2VoiceControl(OrbisNgs2Handle voiceHandle, s32 PS4_SYSV_ABI sceNgs2VoiceControl(OrbisNgs2Handle voiceHandle,
const OrbisNgs2VoiceParamHeader* paramList) { const OrbisNgs2VoiceParamHeader* paramList) {
if (!voiceHandle) { LOG_ERROR(Lib_Ngs2, "called");
LOG_ERROR(Lib_Ngs2, "voiceHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_VOICE_HANDLE;
}
LOG_INFO(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2VoiceGetMatrixInfo(OrbisNgs2Handle voiceHandle, u32 matrixId, s32 PS4_SYSV_ABI sceNgs2VoiceGetMatrixInfo(OrbisNgs2Handle voiceHandle, u32 matrixId,
OrbisNgs2VoiceMatrixInfo* outInfo, size_t outInfoSize) { OrbisNgs2VoiceMatrixInfo* outInfo, size_t outInfoSize) {
LOG_INFO(Lib_Ngs2, "matrixId = {}, outInfoSize = {}", matrixId, outInfoSize); LOG_ERROR(Lib_Ngs2, "matrixId = {}, outInfoSize = {}", matrixId, outInfoSize);
if (!voiceHandle) {
LOG_ERROR(Lib_Ngs2, "voiceHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_VOICE_HANDLE;
}
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2VoiceGetOwner(OrbisNgs2Handle voiceHandle, OrbisNgs2Handle* outRackHandle, s32 PS4_SYSV_ABI sceNgs2VoiceGetOwner(OrbisNgs2Handle voiceHandle, OrbisNgs2Handle* outRackHandle,
u32* outVoiceId) { u32* outVoiceId) {
if (!voiceHandle) { LOG_ERROR(Lib_Ngs2, "called");
LOG_ERROR(Lib_Ngs2, "voiceHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_VOICE_HANDLE;
}
LOG_INFO(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2VoiceGetPortInfo(OrbisNgs2Handle voiceHandle, u32 port, s32 PS4_SYSV_ABI sceNgs2VoiceGetPortInfo(OrbisNgs2Handle voiceHandle, u32 port,
OrbisNgs2VoicePortInfo* outInfo, size_t outInfoSize) { OrbisNgs2VoicePortInfo* outInfo, size_t outInfoSize) {
LOG_INFO(Lib_Ngs2, "port = {}, outInfoSize = {}", port, outInfoSize); LOG_ERROR(Lib_Ngs2, "port = {}, outInfoSize = {}", port, outInfoSize);
if (!voiceHandle) {
LOG_ERROR(Lib_Ngs2, "voiceHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_VOICE_HANDLE;
}
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2VoiceGetState(OrbisNgs2Handle voiceHandle, OrbisNgs2VoiceState* outState, s32 PS4_SYSV_ABI sceNgs2VoiceGetState(OrbisNgs2Handle voiceHandle, OrbisNgs2VoiceState* outState,
size_t stateSize) { size_t stateSize) {
LOG_INFO(Lib_Ngs2, "stateSize = {}", stateSize); LOG_ERROR(Lib_Ngs2, "stateSize = {}", stateSize);
if (!voiceHandle) {
LOG_ERROR(Lib_Ngs2, "voiceHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_VOICE_HANDLE;
}
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2VoiceGetStateFlags(OrbisNgs2Handle voiceHandle, u32* outStateFlags) { s32 PS4_SYSV_ABI sceNgs2VoiceGetStateFlags(OrbisNgs2Handle voiceHandle, u32* outStateFlags) {
if (!voiceHandle) { LOG_ERROR(Lib_Ngs2, "called");
LOG_ERROR(Lib_Ngs2, "voiceHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_VOICE_HANDLE;
}
LOG_INFO(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
@ -407,36 +347,32 @@ s32 PS4_SYSV_ABI sceNgs2VoiceGetStateFlags(OrbisNgs2Handle voiceHandle, u32* out
s32 PS4_SYSV_ABI sceNgs2CustomRackGetModuleInfo(OrbisNgs2Handle rackHandle, u32 moduleIndex, s32 PS4_SYSV_ABI sceNgs2CustomRackGetModuleInfo(OrbisNgs2Handle rackHandle, u32 moduleIndex,
OrbisNgs2CustomModuleInfo* outInfo, OrbisNgs2CustomModuleInfo* outInfo,
size_t infoSize) { size_t infoSize) {
LOG_INFO(Lib_Ngs2, "moduleIndex = {}, infoSize = {}", moduleIndex, infoSize); LOG_ERROR(Lib_Ngs2, "moduleIndex = {}, infoSize = {}", moduleIndex, infoSize);
if (!rackHandle) {
LOG_ERROR(Lib_Ngs2, "rackHandle is nullptr");
return ORBIS_NGS2_ERROR_INVALID_RACK_HANDLE;
}
return ORBIS_OK; return ORBIS_OK;
} }
// Ngs2Geom // Ngs2Geom
s32 PS4_SYSV_ABI sceNgs2GeomResetListenerParam(OrbisNgs2GeomListenerParam* outListenerParam) { s32 PS4_SYSV_ABI sceNgs2GeomResetListenerParam(OrbisNgs2GeomListenerParam* outListenerParam) {
LOG_INFO(Lib_Ngs2, "called"); LOG_ERROR(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2GeomResetSourceParam(OrbisNgs2GeomSourceParam* outSourceParam) { s32 PS4_SYSV_ABI sceNgs2GeomResetSourceParam(OrbisNgs2GeomSourceParam* outSourceParam) {
LOG_INFO(Lib_Ngs2, "called"); LOG_ERROR(Lib_Ngs2, "called");
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2GeomCalcListener(const OrbisNgs2GeomListenerParam* param, s32 PS4_SYSV_ABI sceNgs2GeomCalcListener(const OrbisNgs2GeomListenerParam* param,
OrbisNgs2GeomListenerWork* outWork, u32 flags) { OrbisNgs2GeomListenerWork* outWork, u32 flags) {
LOG_INFO(Lib_Ngs2, "flags = {}", flags); LOG_ERROR(Lib_Ngs2, "flags = {}", flags);
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2GeomApply(const OrbisNgs2GeomListenerWork* listener, s32 PS4_SYSV_ABI sceNgs2GeomApply(const OrbisNgs2GeomListenerWork* listener,
const OrbisNgs2GeomSourceParam* source, const OrbisNgs2GeomSourceParam* source,
OrbisNgs2GeomAttribute* outAttrib, u32 flags) { OrbisNgs2GeomAttribute* outAttrib, u32 flags) {
LOG_INFO(Lib_Ngs2, "flags = {}", flags); LOG_ERROR(Lib_Ngs2, "flags = {}", flags);
return ORBIS_OK; return ORBIS_OK;
} }
@ -444,15 +380,15 @@ s32 PS4_SYSV_ABI sceNgs2GeomApply(const OrbisNgs2GeomListenerWork* listener,
s32 PS4_SYSV_ABI sceNgs2PanInit(OrbisNgs2PanWork* work, const float* aSpeakerAngle, float unitAngle, s32 PS4_SYSV_ABI sceNgs2PanInit(OrbisNgs2PanWork* work, const float* aSpeakerAngle, float unitAngle,
u32 numSpeakers) { u32 numSpeakers) {
LOG_INFO(Lib_Ngs2, "aSpeakerAngle = {}, unitAngle = {}, numSpeakers = {}", *aSpeakerAngle, LOG_ERROR(Lib_Ngs2, "aSpeakerAngle = {}, unitAngle = {}, numSpeakers = {}", *aSpeakerAngle,
unitAngle, numSpeakers); unitAngle, numSpeakers);
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceNgs2PanGetVolumeMatrix(OrbisNgs2PanWork* work, const OrbisNgs2PanParam* aParam, s32 PS4_SYSV_ABI sceNgs2PanGetVolumeMatrix(OrbisNgs2PanWork* work, const OrbisNgs2PanParam* aParam,
u32 numParams, u32 matrixFormat, u32 numParams, u32 matrixFormat,
float* outVolumeMatrix) { float* outVolumeMatrix) {
LOG_INFO(Lib_Ngs2, "numParams = {}, matrixFormat = {}", numParams, matrixFormat); LOG_ERROR(Lib_Ngs2, "numParams = {}, matrixFormat = {}", numParams, matrixFormat);
return ORBIS_OK; return ORBIS_OK;
} }

18
src/core/libraries/ngs2/ngs2.h
View File

@ -16,7 +16,8 @@ class SymbolsResolver;
namespace Libraries::Ngs2 { namespace Libraries::Ngs2 {
typedef s32 (*OrbisNgs2ParseReadHandler)(uintptr_t userData, u32 offset, void* data, size_t size); using OrbisNgs2ParseReadHandler = s32 PS4_SYSV_ABI (*)(uintptr_t user_data, u32 offset, void* data,
size_t size);
enum class OrbisNgs2HandleType : u32 { enum class OrbisNgs2HandleType : u32 {
Invalid = 0, Invalid = 0,
@ -90,7 +91,7 @@ struct OrbisNgs2UserFxProcessContext {
u32 sampleRate; u32 sampleRate;
}; };
typedef s32 (*OrbisNgs2UserFxProcessHandler)(OrbisNgs2UserFxProcessContext* context); using OrbisNgs2UserFxProcessHandler = s32 PS4_SYSV_ABI (*)(OrbisNgs2UserFxProcessContext* context);
struct OrbisNgs2UserFx2SetupContext { struct OrbisNgs2UserFx2SetupContext {
void* common; void* common;
@ -102,7 +103,7 @@ struct OrbisNgs2UserFx2SetupContext {
u64 reserved[4]; u64 reserved[4];
}; };
typedef s32 (*OrbisNgs2UserFx2SetupHandler)(OrbisNgs2UserFx2SetupContext* context); using OrbisNgs2UserFx2SetupHandler = s32 PS4_SYSV_ABI (*)(OrbisNgs2UserFx2SetupContext* context);
struct OrbisNgs2UserFx2CleanupContext { struct OrbisNgs2UserFx2CleanupContext {
void* common; void* common;
@ -114,7 +115,8 @@ struct OrbisNgs2UserFx2CleanupContext {
u64 reserved[4]; u64 reserved[4];
}; };
typedef s32 (*OrbisNgs2UserFx2CleanupHandler)(OrbisNgs2UserFx2CleanupContext* context); using OrbisNgs2UserFx2CleanupHandler =
s32 PS4_SYSV_ABI (*)(OrbisNgs2UserFx2CleanupContext* context);
struct OrbisNgs2UserFx2ControlContext { struct OrbisNgs2UserFx2ControlContext {
const void* data; const void* data;
@ -125,7 +127,8 @@ struct OrbisNgs2UserFx2ControlContext {
u64 reserved[4]; u64 reserved[4];
}; };
typedef s32 (*OrbisNgs2UserFx2ControlHandler)(OrbisNgs2UserFx2ControlContext* context); using OrbisNgs2UserFx2ControlHandler =
s32 PS4_SYSV_ABI (*)(OrbisNgs2UserFx2ControlContext* context);
struct OrbisNgs2UserFx2ProcessContext { struct OrbisNgs2UserFx2ProcessContext {
float** aChannelData; float** aChannelData;
@ -143,7 +146,8 @@ struct OrbisNgs2UserFx2ProcessContext {
u64 reserved2[4]; u64 reserved2[4];
}; };
typedef s32 (*OrbisNgs2UserFx2ProcessHandler)(OrbisNgs2UserFx2ProcessContext* context); using OrbisNgs2UserFx2ProcessHandler =
s32 PS4_SYSV_ABI (*)(OrbisNgs2UserFx2ProcessContext* context);
struct OrbisNgs2BufferAllocator { struct OrbisNgs2BufferAllocator {
OrbisNgs2BufferAllocHandler allocHandler; OrbisNgs2BufferAllocHandler allocHandler;
@ -237,7 +241,7 @@ struct OrbisNgs2VoiceCallbackInfo {
} param; } param;
}; };
typedef void (*OrbisNgs2VoiceCallbackHandler)(const OrbisNgs2VoiceCallbackInfo* info); using OrbisNgs2VoiceCallbackHandler = void PS4_SYSV_ABI (*)(const OrbisNgs2VoiceCallbackInfo* info);
struct OrbisNgs2VoiceCallbackParam { struct OrbisNgs2VoiceCallbackParam {
OrbisNgs2VoiceParamHeader header; OrbisNgs2VoiceParamHeader header;

5
src/core/libraries/ngs2/ngs2_impl.h
View File

@ -30,8 +30,9 @@ struct OrbisNgs2SystemOption {
u32 aReserved[6]; u32 aReserved[6];
}; };
typedef s32 (*OrbisNgs2BufferAllocHandler)(OrbisNgs2ContextBufferInfo* ioBufferInfo); using OrbisNgs2BufferAllocHandler =
typedef s32 (*OrbisNgs2BufferFreeHandler)(OrbisNgs2ContextBufferInfo* ioBufferInfo); s32 PS4_SYSV_ABI (*)(OrbisNgs2ContextBufferInfo* io_buffer_info);
using OrbisNgs2BufferFreeHandler = s32 PS4_SYSV_ABI (*)(OrbisNgs2ContextBufferInfo* io_buffer_info);
struct OrbisNgs2SystemInfo { struct OrbisNgs2SystemInfo {
char name[ORBIS_NGS2_SYSTEM_NAME_LENGTH]; // 0 char name[ORBIS_NGS2_SYSTEM_NAME_LENGTH]; // 0

3
src/core/libraries/ngs2/ngs2_report.h
View File

@ -18,7 +18,8 @@ struct OrbisNgs2ReportDataHeader {
s32 result; s32 result;
}; };
typedef void (*OrbisNgs2ReportHandler)(const OrbisNgs2ReportDataHeader* data, uintptr_t userData); using OrbisNgs2ReportHandler = void PS4_SYSV_ABI (*)(const OrbisNgs2ReportDataHeader* data,
uintptr_t user_data);
struct OrbisNgs2ReportMessageData { struct OrbisNgs2ReportMessageData {
OrbisNgs2ReportDataHeader header; OrbisNgs2ReportDataHeader header;

512
src/core/libraries/usbd/usbd.cpp
View File

@ -7,311 +7,455 @@
#include "core/libraries/libs.h" #include "core/libraries/libs.h"
#include "usbd.h" #include "usbd.h"
#include <fmt/format.h>
#include <libusb.h>
namespace Libraries::Usbd { namespace Libraries::Usbd {
int PS4_SYSV_ABI sceUsbdAllocTransfer() { s32 libusb_to_orbis_error(int retVal) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); if (retVal == LIBUSB_ERROR_OTHER)
return ORBIS_OK; return 0x802400FF;
if (retVal < 0) {
LOG_ERROR(Lib_Usbd, "libusb returned: {}", libusb_error_name(retVal));
return 0x80240000 - retVal;
}
return retVal;
} }
int PS4_SYSV_ABI sceUsbdAttachKernelDriver() { libusb_context* g_libusb_context;
LOG_ERROR(Lib_Usbd, "(STUBBED) called");
return ORBIS_OK; #if defined(_WIN32)
bool s_has_removed_driver = false;
#endif
s32 PS4_SYSV_ABI sceUsbdInit() {
LOG_DEBUG(Lib_Usbd, "called");
return libusb_to_orbis_error(libusb_init(&g_libusb_context));
} }
int PS4_SYSV_ABI sceUsbdBulkTransfer() { void PS4_SYSV_ABI sceUsbdExit() {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
libusb_exit(g_libusb_context);
} }
int PS4_SYSV_ABI sceUsbdCancelTransfer() { s64 PS4_SYSV_ABI sceUsbdGetDeviceList(SceUsbdDevice*** list) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_get_device_list(g_libusb_context, list));
} }
int PS4_SYSV_ABI sceUsbdCheckConnected() { void PS4_SYSV_ABI sceUsbdFreeDeviceList(SceUsbdDevice** list, s32 unref_devices) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
libusb_free_device_list(list, unref_devices);
} }
int PS4_SYSV_ABI sceUsbdClaimInterface() { SceUsbdDevice* PS4_SYSV_ABI sceUsbdRefDevice(SceUsbdDevice* device) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_ref_device(device);
} }
int PS4_SYSV_ABI sceUsbdClearHalt() { void PS4_SYSV_ABI sceUsbdUnrefDevice(SceUsbdDevice* device) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
libusb_unref_device(device);
} }
int PS4_SYSV_ABI sceUsbdClose() { s32 PS4_SYSV_ABI sceUsbdGetConfiguration(SceUsbdDeviceHandle* dev_handle, s32* config) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_get_configuration(dev_handle, config));
} }
int PS4_SYSV_ABI sceUsbdControlTransfer() { s32 PS4_SYSV_ABI sceUsbdGetDeviceDescriptor(SceUsbdDevice* device, SceUsbdDeviceDescriptor* desc) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_get_device_descriptor(device, desc));
} }
int PS4_SYSV_ABI sceUsbdControlTransferGetData() { s32 PS4_SYSV_ABI sceUsbdGetActiveConfigDescriptor(SceUsbdDevice* device,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); SceUsbdConfigDescriptor** config) {
return ORBIS_OK; LOG_DEBUG(Lib_Usbd, "called");
return libusb_to_orbis_error(libusb_get_active_config_descriptor(device, config));
} }
int PS4_SYSV_ABI sceUsbdControlTransferGetSetup() { s32 PS4_SYSV_ABI sceUsbdGetConfigDescriptor(SceUsbdDevice* device, u8 config_index,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); SceUsbdConfigDescriptor** config) {
return ORBIS_OK; LOG_DEBUG(Lib_Usbd, "called");
return libusb_to_orbis_error(libusb_get_config_descriptor(device, config_index, config));
} }
int PS4_SYSV_ABI sceUsbdDetachKernelDriver() { s32 PS4_SYSV_ABI sceUsbdGetConfigDescriptorByValue(SceUsbdDevice* device, u8 bConfigurationValue,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); SceUsbdConfigDescriptor** config) {
return ORBIS_OK; LOG_DEBUG(Lib_Usbd, "called");
return libusb_to_orbis_error(
libusb_get_config_descriptor_by_value(device, bConfigurationValue, config));
} }
int PS4_SYSV_ABI sceUsbdEventHandlerActive() { void PS4_SYSV_ABI sceUsbdFreeConfigDescriptor(SceUsbdConfigDescriptor* config) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
libusb_free_config_descriptor(config);
} }
int PS4_SYSV_ABI sceUsbdEventHandlingOk() { u8 PS4_SYSV_ABI sceUsbdGetBusNumber(SceUsbdDevice* device) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_get_bus_number(device);
} }
int PS4_SYSV_ABI sceUsbdExit() { u8 PS4_SYSV_ABI sceUsbdGetDeviceAddress(SceUsbdDevice* device) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_get_device_address(device);
} }
int PS4_SYSV_ABI sceUsbdFillBulkTransfer() { SceUsbdSpeed PS4_SYSV_ABI sceUsbdGetDeviceSpeed(SceUsbdDevice* device) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return static_cast<SceUsbdSpeed>(libusb_get_device_speed(device));
} }
int PS4_SYSV_ABI sceUsbdFillControlSetup() { s32 PS4_SYSV_ABI sceUsbdGetMaxPacketSize(SceUsbdDevice* device, u8 endpoint) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_get_max_packet_size(device, endpoint));
} }
int PS4_SYSV_ABI sceUsbdFillControlTransfer() { s32 PS4_SYSV_ABI sceUsbdGetMaxIsoPacketSize(SceUsbdDevice* device, u8 endpoint) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_get_max_iso_packet_size(device, endpoint));
} }
int PS4_SYSV_ABI sceUsbdFillInterruptTransfer() { s32 PS4_SYSV_ABI sceUsbdOpen(SceUsbdDevice* device, SceUsbdDeviceHandle** dev_handle) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_open(device, dev_handle));
} }
int PS4_SYSV_ABI sceUsbdFillIsoTransfer() { void PS4_SYSV_ABI sceUsbdClose(SceUsbdDeviceHandle* dev_handle) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
libusb_close(dev_handle);
} }
int PS4_SYSV_ABI sceUsbdFreeConfigDescriptor() { SceUsbdDevice* PS4_SYSV_ABI sceUsbdGetDevice(SceUsbdDeviceHandle* dev_handle) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_get_device(dev_handle);
} }
int PS4_SYSV_ABI sceUsbdFreeDeviceList() { s32 PS4_SYSV_ABI sceUsbdSetConfiguration(SceUsbdDeviceHandle* dev_handle, s32 config) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_set_configuration(dev_handle, config));
} }
int PS4_SYSV_ABI sceUsbdFreeTransfer() { s32 PS4_SYSV_ABI sceUsbdClaimInterface(SceUsbdDeviceHandle* dev_handle, s32 interface_number) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
if (sceUsbdKernelDriverActive(dev_handle, interface_number)) {
sceUsbdDetachKernelDriver(dev_handle, interface_number);
}
return libusb_to_orbis_error(libusb_claim_interface(dev_handle, interface_number));
} }
int PS4_SYSV_ABI sceUsbdGetActiveConfigDescriptor() { s32 PS4_SYSV_ABI sceUsbdReleaseInterface(SceUsbdDeviceHandle* dev_handle, s32 interface_number) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_release_interface(dev_handle, interface_number));
} }
int PS4_SYSV_ABI sceUsbdGetBusNumber() { SceUsbdDeviceHandle* PS4_SYSV_ABI sceUsbdOpenDeviceWithVidPid(u16 vendor_id, u16 product_id) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_open_device_with_vid_pid(g_libusb_context, vendor_id, product_id);
} }
int PS4_SYSV_ABI sceUsbdGetConfigDescriptor() { s32 PS4_SYSV_ABI sceUsbdSetInterfaceAltSetting(SceUsbdDeviceHandle* dev_handle,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); int interface_number, int alternate_setting) {
return ORBIS_OK; LOG_DEBUG(Lib_Usbd, "called");
return libusb_to_orbis_error(
libusb_set_interface_alt_setting(dev_handle, interface_number, alternate_setting));
} }
int PS4_SYSV_ABI sceUsbdGetConfigDescriptorByValue() { s32 PS4_SYSV_ABI sceUsbdClearHalt(SceUsbdDeviceHandle* dev_handle, uint8_t endpoint) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_clear_halt(dev_handle, endpoint));
} }
int PS4_SYSV_ABI sceUsbdGetConfiguration() { s32 PS4_SYSV_ABI sceUsbdResetDevice(SceUsbdDeviceHandle* dev_handle) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_reset_device(dev_handle));
} }
int PS4_SYSV_ABI sceUsbdGetDescriptor() { s32 PS4_SYSV_ABI sceUsbdKernelDriverActive(SceUsbdDeviceHandle* dev_handle, int interface_number) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
#if defined(_WIN32)
if (!s_has_removed_driver)
return 1;
else
return 0;
#endif
return libusb_to_orbis_error(libusb_kernel_driver_active(dev_handle, interface_number));
} }
int PS4_SYSV_ABI sceUsbdGetDevice() { s32 PS4_SYSV_ABI sceUsbdDetachKernelDriver(SceUsbdDeviceHandle* dev_handle, int interface_number) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
#if defined(_WIN32)
s_has_removed_driver = true;
return 0;
#endif
return libusb_to_orbis_error(libusb_detach_kernel_driver(dev_handle, interface_number));
} }
int PS4_SYSV_ABI sceUsbdGetDeviceAddress() { s32 PS4_SYSV_ABI sceUsbdAttachKernelDriver(SceUsbdDeviceHandle* dev_handle, int interface_number) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
#if defined(_WIN32)
s_has_removed_driver = false;
return 0;
#endif
return libusb_to_orbis_error(libusb_attach_kernel_driver(dev_handle, interface_number));
} }
int PS4_SYSV_ABI sceUsbdGetDeviceDescriptor() { u8* PS4_SYSV_ABI sceUsbdControlTransferGetData(SceUsbdTransfer* transfer) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_control_transfer_get_data(transfer);
} }
int PS4_SYSV_ABI sceUsbdGetDeviceList() { SceUsbdControlSetup* PS4_SYSV_ABI sceUsbdControlTransferGetSetup(SceUsbdTransfer* transfer) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_control_transfer_get_setup(transfer);
} }
int PS4_SYSV_ABI sceUsbdGetDeviceSpeed() { void PS4_SYSV_ABI sceUsbdFillControlSetup(u8* buf, u8 bmRequestType, u8 bRequest, u16 wValue,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); u16 wIndex, u16 wLength) {
return ORBIS_OK; LOG_DEBUG(Lib_Usbd, "called");
return libusb_fill_control_setup(buf, bmRequestType, bRequest, wValue, wIndex, wLength);
} }
int PS4_SYSV_ABI sceUsbdGetIsoPacketBuffer() { SceUsbdTransfer* PS4_SYSV_ABI sceUsbdAllocTransfer(int iso_packets) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_alloc_transfer(iso_packets);
} }
int PS4_SYSV_ABI sceUsbdGetMaxIsoPacketSize() { s32 PS4_SYSV_ABI sceUsbdSubmitTransfer(SceUsbdTransfer* transfer) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_submit_transfer(transfer));
} }
int PS4_SYSV_ABI sceUsbdGetMaxPacketSize() { s32 PS4_SYSV_ABI sceUsbdCancelTransfer(SceUsbdTransfer* transfer) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_cancel_transfer(transfer));
} }
int PS4_SYSV_ABI sceUsbdGetStringDescriptor() { void PS4_SYSV_ABI sceUsbdFreeTransfer(SceUsbdTransfer* transfer) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
libusb_free_transfer(transfer);
} }
int PS4_SYSV_ABI sceUsbdGetStringDescriptorAscii() { void PS4_SYSV_ABI sceUsbdFillControlTransfer(SceUsbdTransfer* transfer,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); SceUsbdDeviceHandle* dev_handle, u8* buffer,
return ORBIS_OK; SceUsbdTransferCallback callback, void* user_data,
u32 timeout) {
LOG_DEBUG(Lib_Usbd, "called");
libusb_fill_control_transfer(transfer, dev_handle, buffer, callback, user_data, timeout);
} }
int PS4_SYSV_ABI sceUsbdHandleEvents() { void PS4_SYSV_ABI sceUsbdFillBulkTransfer(SceUsbdTransfer* transfer,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); SceUsbdDeviceHandle* dev_handle, uint8_t endpoint,
return ORBIS_OK; u8* buffer, s32 length, SceUsbdTransferCallback callback,
void* user_data, u32 timeout) {
LOG_DEBUG(Lib_Usbd, "called");
libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer, length, callback, user_data,
timeout);
} }
int PS4_SYSV_ABI sceUsbdHandleEventsLocked() { void PS4_SYSV_ABI sceUsbdFillInterruptTransfer(SceUsbdTransfer* transfer,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); SceUsbdDeviceHandle* dev_handle, uint8_t endpoint,
return ORBIS_OK; u8* buffer, s32 length,
SceUsbdTransferCallback callback, void* user_data,
u32 timeout) {
LOG_DEBUG(Lib_Usbd, "called");
libusb_fill_interrupt_transfer(transfer, dev_handle, endpoint, buffer, length, callback,
user_data, timeout);
} }
int PS4_SYSV_ABI sceUsbdHandleEventsTimeout() { void PS4_SYSV_ABI sceUsbdFillIsoTransfer(SceUsbdTransfer* transfer, SceUsbdDeviceHandle* dev_handle,
LOG_DEBUG(Lib_Usbd, "(STUBBED) called"); uint8_t endpoint, u8* buffer, s32 length,
return ORBIS_OK; s32 num_iso_packets, SceUsbdTransferCallback callback,
void* user_data, u32 timeout) {
LOG_DEBUG(Lib_Usbd, "called");
libusb_fill_iso_transfer(transfer, dev_handle, endpoint, buffer, length, num_iso_packets,
callback, user_data, timeout);
} }
int PS4_SYSV_ABI sceUsbdInit() { void PS4_SYSV_ABI sceUsbdSetIsoPacketLengths(SceUsbdTransfer* transfer, u32 length) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return 0x80240005; // Skip
libusb_set_iso_packet_lengths(transfer, length);
} }
int PS4_SYSV_ABI sceUsbdInterruptTransfer() { u8* PS4_SYSV_ABI sceUsbdGetIsoPacketBuffer(SceUsbdTransfer* transfer, u32 packet) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_get_iso_packet_buffer(transfer, packet);
} }
int PS4_SYSV_ABI sceUsbdKernelDriverActive() { s32 PS4_SYSV_ABI sceUsbdControlTransfer(SceUsbdDeviceHandle* dev_handle, u8 request_type,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); u8 bRequest, u16 wValue, u16 wIndex, u8* data, s32 wLength,
return ORBIS_OK; u32 timeout) {
LOG_DEBUG(Lib_Usbd, "called");
return libusb_to_orbis_error(libusb_control_transfer(dev_handle, request_type, bRequest, wValue,
wIndex, data, wLength, timeout));
} }
int PS4_SYSV_ABI sceUsbdLockEvents() { s32 PS4_SYSV_ABI sceUsbdBulkTransfer(SceUsbdDeviceHandle* dev_handle, u8 endpoint, u8* data,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); s32 length, s32* actual_length, u32 timeout) {
return ORBIS_OK; LOG_DEBUG(Lib_Usbd, "called");
return libusb_to_orbis_error(
libusb_bulk_transfer(dev_handle, endpoint, data, length, actual_length, timeout));
} }
int PS4_SYSV_ABI sceUsbdLockEventWaiters() { s32 PS4_SYSV_ABI sceUsbdInterruptTransfer(SceUsbdDeviceHandle* dev_handle, u8 endpoint, u8* data,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); s32 length, s32* actual_length, u32 timeout) {
return ORBIS_OK; LOG_DEBUG(Lib_Usbd, "called");
return libusb_to_orbis_error(
libusb_interrupt_transfer(dev_handle, endpoint, data, length, actual_length, timeout));
} }
int PS4_SYSV_ABI sceUsbdOpen() { s32 PS4_SYSV_ABI sceUsbdGetDescriptor(SceUsbdDeviceHandle* dev_handle, u8 descType, u8 descIndex,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); u8* data, s32 length) {
return ORBIS_OK; LOG_DEBUG(Lib_Usbd, "called");
return libusb_to_orbis_error(
libusb_get_descriptor(dev_handle, descType, descIndex, data, length));
} }
int PS4_SYSV_ABI sceUsbdOpenDeviceWithVidPid() { s32 PS4_SYSV_ABI sceUsbdGetStringDescriptor(SceUsbdDeviceHandle* dev_handle, u8 desc_index,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); u16 langid, u8* data, s32 length) {
return ORBIS_OK; LOG_DEBUG(Lib_Usbd, "called");
return libusb_to_orbis_error(
libusb_get_string_descriptor(dev_handle, desc_index, langid, data, length));
} }
int PS4_SYSV_ABI sceUsbdRefDevice() { s32 PS4_SYSV_ABI sceUsbdGetStringDescriptorAscii(SceUsbdDeviceHandle* dev_handle, u8 desc_index,
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); u8* data, s32 length) {
return ORBIS_OK; LOG_DEBUG(Lib_Usbd, "called");
return libusb_to_orbis_error(
libusb_get_string_descriptor_ascii(dev_handle, desc_index, data, length));
} }
int PS4_SYSV_ABI sceUsbdReleaseInterface() { s32 PS4_SYSV_ABI sceUsbdTryLockEvents() {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_try_lock_events(g_libusb_context);
} }
int PS4_SYSV_ABI sceUsbdResetDevice() { void PS4_SYSV_ABI sceUsbdLockEvents() {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
libusb_lock_events(g_libusb_context);
} }
int PS4_SYSV_ABI sceUsbdSetConfiguration() { void PS4_SYSV_ABI sceUsbdUnlockEvents() {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
libusb_unlock_events(g_libusb_context);
} }
int PS4_SYSV_ABI sceUsbdSetInterfaceAltSetting() { s32 PS4_SYSV_ABI sceUsbdEventHandlingOk() {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_event_handling_ok(g_libusb_context);
} }
int PS4_SYSV_ABI sceUsbdSetIsoPacketLengths() { s32 PS4_SYSV_ABI sceUsbdEventHandlerActive() {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_event_handler_active(g_libusb_context);
} }
int PS4_SYSV_ABI sceUsbdSubmitTransfer() { void PS4_SYSV_ABI sceUsbdLockEventWaiters() {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
libusb_lock_event_waiters(g_libusb_context);
} }
int PS4_SYSV_ABI sceUsbdTryLockEvents() { void PS4_SYSV_ABI sceUsbdUnlockEventWaiters() {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
libusb_unlock_event_waiters(g_libusb_context);
} }
int PS4_SYSV_ABI sceUsbdUnlockEvents() { s32 PS4_SYSV_ABI sceUsbdWaitForEvent(timeval* tv) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_wait_for_event(g_libusb_context, tv));
} }
int PS4_SYSV_ABI sceUsbdUnlockEventWaiters() { s32 PS4_SYSV_ABI sceUsbdHandleEventsTimeout(timeval* tv) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_handle_events_timeout(g_libusb_context, tv));
} }
int PS4_SYSV_ABI sceUsbdUnrefDevice() { s32 PS4_SYSV_ABI sceUsbdHandleEvents() {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_handle_events(g_libusb_context));
} }
int PS4_SYSV_ABI sceUsbdWaitForEvent() { s32 PS4_SYSV_ABI sceUsbdHandleEventsLocked(timeval* tv) {
LOG_ERROR(Lib_Usbd, "(STUBBED) called"); LOG_DEBUG(Lib_Usbd, "called");
return ORBIS_OK;
return libusb_to_orbis_error(libusb_handle_events_locked(g_libusb_context, tv));
}
s32 PS4_SYSV_ABI sceUsbdCheckConnected(SceUsbdDeviceHandle* dev_handle) {
LOG_DEBUG(Lib_Usbd, "called");
// There's no libusb version of this function.
// Simulate by querying data.
int config;
int r = libusb_get_configuration(dev_handle, &config);
return libusb_to_orbis_error(r);
} }
int PS4_SYSV_ABI Func_65F6EF33E38FFF50() { int PS4_SYSV_ABI Func_65F6EF33E38FFF50() {
@ -406,4 +550,4 @@ void RegisterlibSceUsbd(Core::Loader::SymbolsResolver* sym) {
LIB_FUNCTION("1WtDBgcgseA", "libSceUsbd", 1, "libSceUsbd", 1, 1, Func_D56B43060720B1E0); LIB_FUNCTION("1WtDBgcgseA", "libSceUsbd", 1, "libSceUsbd", 1, 1, Func_D56B43060720B1E0);
}; };
} // namespace Libraries::Usbd } // namespace Libraries::Usbd

198
src/core/libraries/usbd/usbd.h
View File

@ -1,76 +1,150 @@
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project // SPDX - FileCopyrightText : Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#pragma once #pragma once
#include "common/types.h" #include "common/types.h"
extern "C" {
struct libusb_device;
struct libusb_device_handle;
struct libusb_device_descriptor;
struct libusb_config_descriptor;
struct libusb_transfer;
struct libusb_control_setup;
struct timeval;
}
namespace Core::Loader { namespace Core::Loader {
class SymbolsResolver; class SymbolsResolver;
} }
namespace Libraries::Usbd { namespace Libraries::Usbd {
int PS4_SYSV_ABI sceUsbdAllocTransfer(); using SceUsbdDevice = libusb_device;
int PS4_SYSV_ABI sceUsbdAttachKernelDriver(); using SceUsbdDeviceHandle = libusb_device_handle;
int PS4_SYSV_ABI sceUsbdBulkTransfer(); using SceUsbdDeviceDescriptor = libusb_device_descriptor;
int PS4_SYSV_ABI sceUsbdCancelTransfer(); using SceUsbdConfigDescriptor = libusb_config_descriptor;
int PS4_SYSV_ABI sceUsbdCheckConnected(); using SceUsbdTransfer = libusb_transfer;
int PS4_SYSV_ABI sceUsbdClaimInterface(); using SceUsbdControlSetup = libusb_control_setup;
int PS4_SYSV_ABI sceUsbdClearHalt(); using SceUsbdTransferCallback = void (*)(SceUsbdTransfer* transfer);
int PS4_SYSV_ABI sceUsbdClose();
int PS4_SYSV_ABI sceUsbdControlTransfer(); enum class SceUsbdSpeed : u32 {
int PS4_SYSV_ABI sceUsbdControlTransferGetData(); UNKNOWN = 0,
int PS4_SYSV_ABI sceUsbdControlTransferGetSetup(); LOW = 1,
int PS4_SYSV_ABI sceUsbdDetachKernelDriver(); FULL = 2,
int PS4_SYSV_ABI sceUsbdEventHandlerActive(); HIGH = 3,
int PS4_SYSV_ABI sceUsbdEventHandlingOk(); SUPER = 4,
int PS4_SYSV_ABI sceUsbdExit(); SUPER_PLUS = 5
int PS4_SYSV_ABI sceUsbdFillBulkTransfer(); };
int PS4_SYSV_ABI sceUsbdFillControlSetup();
int PS4_SYSV_ABI sceUsbdFillControlTransfer(); s32 PS4_SYSV_ABI sceUsbdInit();
int PS4_SYSV_ABI sceUsbdFillInterruptTransfer(); void PS4_SYSV_ABI sceUsbdExit();
int PS4_SYSV_ABI sceUsbdFillIsoTransfer();
int PS4_SYSV_ABI sceUsbdFreeConfigDescriptor(); s64 PS4_SYSV_ABI sceUsbdGetDeviceList(SceUsbdDevice*** list);
int PS4_SYSV_ABI sceUsbdFreeDeviceList(); void PS4_SYSV_ABI sceUsbdFreeDeviceList(SceUsbdDevice** list, s32 unref_devices);
int PS4_SYSV_ABI sceUsbdFreeTransfer();
int PS4_SYSV_ABI sceUsbdGetActiveConfigDescriptor(); SceUsbdDevice* PS4_SYSV_ABI sceUsbdRefDevice(SceUsbdDevice* device);
int PS4_SYSV_ABI sceUsbdGetBusNumber(); void PS4_SYSV_ABI sceUsbdUnrefDevice(SceUsbdDevice* device);
int PS4_SYSV_ABI sceUsbdGetConfigDescriptor();
int PS4_SYSV_ABI sceUsbdGetConfigDescriptorByValue(); s32 PS4_SYSV_ABI sceUsbdGetConfiguration(SceUsbdDeviceHandle* dev_handle, s32* config);
int PS4_SYSV_ABI sceUsbdGetConfiguration(); s32 PS4_SYSV_ABI sceUsbdGetDeviceDescriptor(SceUsbdDevice* device, SceUsbdDeviceDescriptor* desc);
int PS4_SYSV_ABI sceUsbdGetDescriptor(); s32 PS4_SYSV_ABI sceUsbdGetActiveConfigDescriptor(SceUsbdDevice* device,
int PS4_SYSV_ABI sceUsbdGetDevice(); SceUsbdConfigDescriptor** config);
int PS4_SYSV_ABI sceUsbdGetDeviceAddress(); s32 PS4_SYSV_ABI sceUsbdGetConfigDescriptor(SceUsbdDevice* device, u8 config_index,
int PS4_SYSV_ABI sceUsbdGetDeviceDescriptor(); SceUsbdConfigDescriptor** config);
int PS4_SYSV_ABI sceUsbdGetDeviceList(); s32 PS4_SYSV_ABI sceUsbdGetConfigDescriptorByValue(SceUsbdDevice* device, u8 bConfigurationValue,
int PS4_SYSV_ABI sceUsbdGetDeviceSpeed(); SceUsbdConfigDescriptor** config);
int PS4_SYSV_ABI sceUsbdGetIsoPacketBuffer(); void PS4_SYSV_ABI sceUsbdFreeConfigDescriptor(SceUsbdConfigDescriptor* config);
int PS4_SYSV_ABI sceUsbdGetMaxIsoPacketSize();
int PS4_SYSV_ABI sceUsbdGetMaxPacketSize(); u8 PS4_SYSV_ABI sceUsbdGetBusNumber(SceUsbdDevice* device);
int PS4_SYSV_ABI sceUsbdGetStringDescriptor(); u8 PS4_SYSV_ABI sceUsbdGetDeviceAddress(SceUsbdDevice* device);
int PS4_SYSV_ABI sceUsbdGetStringDescriptorAscii();
int PS4_SYSV_ABI sceUsbdHandleEvents(); SceUsbdSpeed PS4_SYSV_ABI sceUsbdGetDeviceSpeed(SceUsbdDevice* device);
int PS4_SYSV_ABI sceUsbdHandleEventsLocked(); s32 PS4_SYSV_ABI sceUsbdGetMaxPacketSize(SceUsbdDevice* device, u8 endpoint);
int PS4_SYSV_ABI sceUsbdHandleEventsTimeout(); s32 PS4_SYSV_ABI sceUsbdGetMaxIsoPacketSize(SceUsbdDevice* device, u8 endpoint);
int PS4_SYSV_ABI sceUsbdInit();
int PS4_SYSV_ABI sceUsbdInterruptTransfer(); s32 PS4_SYSV_ABI sceUsbdOpen(SceUsbdDevice* device, SceUsbdDeviceHandle** dev_handle);
int PS4_SYSV_ABI sceUsbdKernelDriverActive(); void PS4_SYSV_ABI sceUsbdClose(SceUsbdDeviceHandle* dev_handle);
int PS4_SYSV_ABI sceUsbdLockEvents(); SceUsbdDevice* PS4_SYSV_ABI sceUsbdGetDevice(SceUsbdDeviceHandle* dev_handle);
int PS4_SYSV_ABI sceUsbdLockEventWaiters();
int PS4_SYSV_ABI sceUsbdOpen(); s32 PS4_SYSV_ABI sceUsbdSetConfiguration(SceUsbdDeviceHandle* dev_handle, s32 config);
int PS4_SYSV_ABI sceUsbdOpenDeviceWithVidPid(); s32 PS4_SYSV_ABI sceUsbdClaimInterface(SceUsbdDeviceHandle* dev_handle, s32 interface_number);
int PS4_SYSV_ABI sceUsbdRefDevice(); s32 PS4_SYSV_ABI sceUsbdReleaseInterface(SceUsbdDeviceHandle* dev_handle, s32 interface_number);
int PS4_SYSV_ABI sceUsbdReleaseInterface();
int PS4_SYSV_ABI sceUsbdResetDevice(); SceUsbdDeviceHandle* PS4_SYSV_ABI sceUsbdOpenDeviceWithVidPid(u16 vendor_id, u16 product_id);
int PS4_SYSV_ABI sceUsbdSetConfiguration();
int PS4_SYSV_ABI sceUsbdSetInterfaceAltSetting(); s32 PS4_SYSV_ABI sceUsbdSetInterfaceAltSetting(SceUsbdDeviceHandle* dev_handle,
int PS4_SYSV_ABI sceUsbdSetIsoPacketLengths(); int interface_number, int alternate_setting);
int PS4_SYSV_ABI sceUsbdSubmitTransfer(); s32 PS4_SYSV_ABI sceUsbdClearHalt(SceUsbdDeviceHandle* dev_handle, u8 endpoint);
int PS4_SYSV_ABI sceUsbdTryLockEvents(); s32 PS4_SYSV_ABI sceUsbdResetDevice(SceUsbdDeviceHandle* dev_handle);
int PS4_SYSV_ABI sceUsbdUnlockEvents();
int PS4_SYSV_ABI sceUsbdUnlockEventWaiters(); s32 PS4_SYSV_ABI sceUsbdKernelDriverActive(SceUsbdDeviceHandle* dev_handle, int interface_number);
int PS4_SYSV_ABI sceUsbdUnrefDevice(); s32 PS4_SYSV_ABI sceUsbdDetachKernelDriver(SceUsbdDeviceHandle* dev_handle, int interface_number);
int PS4_SYSV_ABI sceUsbdWaitForEvent(); s32 PS4_SYSV_ABI sceUsbdAttachKernelDriver(SceUsbdDeviceHandle* dev_handle, int interface_number);
u8* PS4_SYSV_ABI sceUsbdControlTransferGetData(SceUsbdTransfer* transfer);
SceUsbdControlSetup* PS4_SYSV_ABI sceUsbdControlTransferGetSetup(SceUsbdTransfer* transfer);
void PS4_SYSV_ABI sceUsbdFillControlSetup(u8* buf, u8 bmRequestType, u8 bRequest, u16 wValue,
u16 wIndex, u16 wLength);
SceUsbdTransfer* PS4_SYSV_ABI sceUsbdAllocTransfer(int iso_packets);
s32 PS4_SYSV_ABI sceUsbdSubmitTransfer(SceUsbdTransfer* transfer);
s32 PS4_SYSV_ABI sceUsbdCancelTransfer(SceUsbdTransfer* transfer);
void PS4_SYSV_ABI sceUsbdFreeTransfer(SceUsbdTransfer* transfer);
void PS4_SYSV_ABI sceUsbdFillControlTransfer(SceUsbdTransfer* transfer,
SceUsbdDeviceHandle* dev_handle, u8* buffer,
SceUsbdTransferCallback callback, void* user_data,
u32 timeout);
void PS4_SYSV_ABI sceUsbdFillBulkTransfer(SceUsbdTransfer* transfer,
SceUsbdDeviceHandle* dev_handle, u8 endpoint, u8* buffer,
s32 length, SceUsbdTransferCallback callback,
void* user_data, u32 timeout);
void PS4_SYSV_ABI sceUsbdFillInterruptTransfer(SceUsbdTransfer* transfer,
SceUsbdDeviceHandle* dev_handle, u8 endpoint,
u8* buffer, s32 length,
SceUsbdTransferCallback callback, void* user_data,
u32 timeout);
void PS4_SYSV_ABI sceUsbdFillIsoTransfer(SceUsbdTransfer* transfer, SceUsbdDeviceHandle* dev_handle,
u8 endpoint, u8* buffer, s32 length, s32 num_iso_packets,
SceUsbdTransferCallback callback, void* userData,
u32 timeout);
void PS4_SYSV_ABI sceUsbdSetIsoPacketLengths(SceUsbdTransfer* transfer, u32 length);
u8* PS4_SYSV_ABI sceUsbdGetIsoPacketBuffer(SceUsbdTransfer* transfer, u32 packet);
s32 PS4_SYSV_ABI sceUsbdControlTransfer(SceUsbdDeviceHandle* dev_handle, u8 request_type,
u8 bRequest, u16 wValue, u16 wIndex, u8* data, s32 wLength,
u32 timeout);
s32 PS4_SYSV_ABI sceUsbdBulkTransfer(SceUsbdDeviceHandle* dev_handle, u8 endpoint, u8* data,
s32 length, s32* actual_length, u32 timeout);
s32 PS4_SYSV_ABI sceUsbdInterruptTransfer(SceUsbdDeviceHandle* dev_handle, u8 endpoint, u8* data,
s32 length, s32* actual_length, u32 timeout);
s32 PS4_SYSV_ABI sceUsbdGetDescriptor(SceUsbdDeviceHandle* dev_handle, u8 descType, u8 descIndex,
u8* data, s32 length);
s32 PS4_SYSV_ABI sceUsbdGetStringDescriptor(SceUsbdDeviceHandle* dev_handle, u8 desc_index,
u16 langid, u8* data, s32 length);
s32 PS4_SYSV_ABI sceUsbdGetStringDescriptorAscii(SceUsbdDeviceHandle* dev_handle, u8 desc_index,
u8* data, s32 length);
s32 PS4_SYSV_ABI sceUsbdTryLockEvents();
void PS4_SYSV_ABI sceUsbdLockEvents();
void PS4_SYSV_ABI sceUsbdUnlockEvents();
s32 PS4_SYSV_ABI sceUsbdEventHandlingOk();
s32 PS4_SYSV_ABI sceUsbdEventHandlerActive();
void PS4_SYSV_ABI sceUsbdLockEventWaiters();
void PS4_SYSV_ABI sceUsbdUnlockEventWaiters();
s32 PS4_SYSV_ABI sceUsbdWaitForEvent(timeval* tv);
s32 PS4_SYSV_ABI sceUsbdHandleEventsTimeout(timeval* tv);
s32 PS4_SYSV_ABI sceUsbdHandleEvents();
s32 PS4_SYSV_ABI sceUsbdHandleEventsLocked(timeval* tv);
s32 PS4_SYSV_ABI sceUsbdCheckConnected(SceUsbdDeviceHandle* dev_handle);
int PS4_SYSV_ABI Func_65F6EF33E38FFF50(); int PS4_SYSV_ABI Func_65F6EF33E38FFF50();
int PS4_SYSV_ABI Func_97F056BAD90AADE7(); int PS4_SYSV_ABI Func_97F056BAD90AADE7();
int PS4_SYSV_ABI Func_C55104A33B35B264(); int PS4_SYSV_ABI Func_C55104A33B35B264();