OmniNX/Horizon-OC-pro
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hocclk: format code

Browse Source 
use clang format file provided for optimal formatting
This commit is contained in:
souldbminersmwc
2026-06-04 19:52:11 -04:00
parent c6a8884c14
commit 88bfa9a4ec
118 changed files with 7111 additions and 9615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
Source/hoc-clk/sysmodule/src/ipc/ipc_server.c
View File

@@ -12,9 +12,9 @@
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*
*/
/* --------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
* <p-sam@d3vs.net>, <natinusala@gmail.com>, <m4x@m4xw.net>
@@ -24,14 +24,12 @@
* --------------------------------------------------------------------------
*/
#include "ipc_server.h"
#include <string.h>
Result ipcServerInit(IpcServer* server, const char* name, u32 max_sessions)
{
if(max_sessions < 1 || max_sessions > (MAX_WAIT_OBJECTS - 1))
{
#include "ipc_server.h"
Result ipcServerInit(IpcServer *server, const char *name, u32 max_sessions) {
if (max_sessions < 1 || max_sessions > (MAX_WAIT_OBJECTS - 1)) {
return MAKERESULT(Module_Libnx, LibnxError_BadInput);
}
@@ -40,27 +38,22 @@ Result ipcServerInit(IpcServer* server, const char* name, u32 max_sessions)
server->count = 0;
Result rc = smRegisterService(&server->handles[0], server->srvName, false, max_sessions);
if(R_SUCCEEDED(rc))
{
if (R_SUCCEEDED(rc)) {
server->count = 1;
}
return rc;
}
Result ipcServerExit(IpcServer* server)
{
for(u32 i = 0; i < server->count; i++)
{
Result ipcServerExit(IpcServer *server) {
for (u32 i = 0; i < server->count; i++) {
svcCloseHandle(server->handles[i]);
}
server->count = 0;
return smUnregisterService(server->srvName);
}
static Result _ipcServerAddSession(IpcServer* server, Handle session)
{
if(server->count >= server->max)
{
static Result _ipcServerAddSession(IpcServer *server, Handle session) {
if (server->count >= server->max) {
return MAKERESULT(Module_Libnx, LibnxError_OutOfMemory);
}
@@ -69,84 +62,70 @@ static Result _ipcServerAddSession(IpcServer* server, Handle session)
return 0;
}
static Result _ipcServerDeleteSession(IpcServer* server, u32 index)
{
if(!index || index >= server->count)
{
static Result _ipcServerDeleteSession(IpcServer *server, u32 index) {
if (!index || index >= server->count) {
return MAKERESULT(Module_Libnx, LibnxError_BadInput);
}
svcCloseHandle(server->handles[index]);
for(u32 j = index; j < (server->count - 1); j++)
{
for (u32 j = index; j < (server->count - 1); j++) {
server->handles[j] = server->handles[j + 1];
}
server->count--;
return 0;
}
static Result _ipcServerParseRequest(IpcServerRequest* r)
{
u8* base = armGetTls();
static Result _ipcServerParseRequest(IpcServerRequest *r) {
u8 *base = armGetTls();
r->hipc = hipcParseRequest(base);
r->data.cmdId = 0;
r->data.size = 0;
r->data.ptr = NULL;
r->data.ptr = NULL;
if(r->hipc.meta.type == CmifCommandType_Request)
{
IpcServerRawHeader* header = cmifGetAlignedDataStart(r->hipc.data.data_words, base);
if (r->hipc.meta.type == CmifCommandType_Request) {
IpcServerRawHeader *header = cmifGetAlignedDataStart(r->hipc.data.data_words, base);
size_t dataSize = r->hipc.meta.num_data_words * 4;
if(!header || dataSize < sizeof(IpcServerRawHeader) || header->magic != CMIF_IN_HEADER_MAGIC)
{
if (!header || dataSize < sizeof(IpcServerRawHeader) || header->magic != CMIF_IN_HEADER_MAGIC) {
return MAKERESULT(Module_Libnx, LibnxError_BadInput);
}
r->data.cmdId = header->cmdId;
if(dataSize > sizeof(IpcServerRawHeader))
{
if (dataSize > sizeof(IpcServerRawHeader)) {
r->data.size = dataSize - sizeof(IpcServerRawHeader);
r->data.ptr = ((u8*)header) + sizeof(IpcServerRawHeader);
r->data.ptr = ((u8 *)header) + sizeof(IpcServerRawHeader);
}
}
return 0;
}
static void _ipcServerPrepareResponse(Result rc, void* data, size_t dataSize)
{
u8* base = armGetTls();
HipcRequest hipc = hipcMakeRequestInline(base,
.type = CmifCommandType_Request,
.num_data_words = (sizeof(IpcServerRawHeader) + dataSize + 0x10) / 4,
);
static void _ipcServerPrepareResponse(Result rc, void *data, size_t dataSize) {
u8 *base = armGetTls();
HipcRequest hipc =
hipcMakeRequestInline(base, .type = CmifCommandType_Request, .num_data_words = (sizeof(IpcServerRawHeader) + dataSize + 0x10) / 4, );
IpcServerRawHeader* rawHeader = cmifGetAlignedDataStart(hipc.data_words, base);
IpcServerRawHeader *rawHeader = cmifGetAlignedDataStart(hipc.data_words, base);
rawHeader->magic = CMIF_OUT_HEADER_MAGIC;
rawHeader->result = rc;
if(R_SUCCEEDED(rc))
{
memcpy(((u8*)rawHeader) + sizeof(IpcServerRawHeader), data, dataSize);
if (R_SUCCEEDED(rc)) {
memcpy(((u8 *)rawHeader) + sizeof(IpcServerRawHeader), data, dataSize);
}
}
static Result _ipcServerProcessNewSession(IpcServer* server)
{
static Result _ipcServerProcessNewSession(IpcServer *server) {
Handle session;
Result rc = svcAcceptSession(&session, server->handles[0]);
if(R_SUCCEEDED(rc) && R_FAILED(rc = _ipcServerAddSession(server, session)))
{
if (R_SUCCEEDED(rc) && R_FAILED(rc = _ipcServerAddSession(server, session))) {
svcCloseHandle(session);
}
return rc;
}
static Result _ipcServerProcessSession(IpcServer* server, IpcServerRequestHandler handler, void* userdata, u32 handleIndex)
{
static Result _ipcServerProcessSession(IpcServer *server, IpcServerRequestHandler handler, void *userdata, u32 handleIndex) {
s32 unusedIndex;
IpcServerRequest r;
size_t dataSize = 0;
@@ -154,21 +133,14 @@ static Result _ipcServerProcessSession(IpcServer* server, IpcServerRequestHandle
bool close = false;
Result rc = svcReplyAndReceive(&unusedIndex, &server->handles[handleIndex], 1, 0, UINT64_MAX);
if(R_SUCCEEDED(rc))
{
if (R_SUCCEEDED(rc)) {
rc = _ipcServerParseRequest(&r);
}
if(R_SUCCEEDED(rc))
{
switch(r.hipc.meta.type)
{
if (R_SUCCEEDED(rc)) {
switch (r.hipc.meta.type) {
case CmifCommandType_Request:
_ipcServerPrepareResponse(
handler(userdata, &r, data, &dataSize),
data,
dataSize
);
_ipcServerPrepareResponse(handler(userdata, &r, data, &dataSize), data, dataSize);
break;
case CmifCommandType_Close:
_ipcServerPrepareResponse(0, NULL, 0);
@@ -180,42 +152,33 @@ static Result _ipcServerProcessSession(IpcServer* server, IpcServerRequestHandle
}
rc = svcReplyAndReceive(&unusedIndex, &server->handles[handleIndex], 0, server->handles[handleIndex], 0);
if(rc == KERNELRESULT(TimedOut))
{
if (rc == KERNELRESULT(TimedOut)) {
rc = 0;
}
}
if(R_FAILED(rc) || close)
{
if (R_FAILED(rc) || close) {
_ipcServerDeleteSession(server, handleIndex);
}
return rc;
}
Result ipcServerProcess(IpcServer* server, IpcServerRequestHandler handler, void* userdata)
{
Result ipcServerProcess(IpcServer *server, IpcServerRequestHandler handler, void *userdata) {
s32 handleIndex = -1;
Result rc = svcWaitSynchronization(&handleIndex, server->handles, server->count, UINT64_MAX);
if(R_SUCCEEDED(rc) && (handleIndex < 0 || handleIndex >= server->count))
{
if (R_SUCCEEDED(rc) && (handleIndex < 0 || handleIndex >= server->count)) {
rc = MAKERESULT(Module_Libnx, LibnxError_NotFound);
}
if(R_SUCCEEDED(rc))
{
if(handleIndex)
{
if (R_SUCCEEDED(rc)) {
if (handleIndex) {
rc = _ipcServerProcessSession(server, handler, userdata, handleIndex);
}
else
{
} else {
rc = _ipcServerProcessNewSession(server);
}
}
return rc;
}

35
Source/hoc-clk/sysmodule/src/ipc/ipc_server.h
View File

@@ -12,9 +12,9 @@
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*
*/
/* --------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
* <p-sam@d3vs.net>, <natinusala@gmail.com>, <m4x@m4xw.net>
@@ -24,55 +24,48 @@
* --------------------------------------------------------------------------
*/
#pragma once
#ifdef __cplusplus
extern "C"
{
extern "C" {
#endif
#include <switch.h>
#define IPC_SERVER_EXT_RESPONSE_MAX_DATA_SIZE (0x100 - 0x10 - sizeof(IpcServerRawHeader))
typedef struct
{
typedef struct {
u64 magic;
union
{
union {
u64 cmdId;
u64 result;
};
} IpcServerRawHeader;
typedef struct
{
typedef struct {
SmServiceName srvName;
Handle handles[MAX_WAIT_OBJECTS];
u32 max;
u32 count;
} IpcServer;
typedef struct
{
typedef struct {
u64 cmdId;
void* ptr;
void *ptr;
size_t size;
} IpcServerRequestData;
typedef struct
{
typedef struct {
HipcParsedRequest hipc;
IpcServerRequestData data;
} IpcServerRequest;
typedef Result (*IpcServerRequestHandler)(void* userdata, const IpcServerRequest* r, u8* out_data, size_t* out_dataSize);
typedef Result (*IpcServerRequestHandler)(void *userdata, const IpcServerRequest *r, u8 *out_data, size_t *out_dataSize);
Result ipcServerInit(IpcServer* server, const char* name, u32 max_sessions);
Result ipcServerExit(IpcServer* server);
Result ipcServerProcess(IpcServer* server, IpcServerRequestHandler handler, void* userdata);
Result ipcServerParseCommand(const IpcServerRequest* r, size_t* out_datasize, void** out_data, u64* out_cmd);
Result ipcServerInit(IpcServer *server, const char *name, u32 max_sessions);
Result ipcServerExit(IpcServer *server);
Result ipcServerProcess(IpcServer *server, IpcServerRequestHandler handler, void *userdata);
Result ipcServerParseCommand(const IpcServerRequest *r, size_t *out_datasize, void **out_data, u64 *out_cmd);
#ifdef __cplusplus
}

89
Source/hoc-clk/sysmodule/src/ipc/ipc_service.cpp
View File

@@ -24,21 +24,22 @@
* --------------------------------------------------------------------------
*/
#include "ipc_service.hpp"
#include <cstring>
#include <switch.h>
#include "../hos/apm_ext.h"
#include <i2c.h>
#include <t210.h>
#include <max17050.h>
#include <switch.h>
#include <t210.h>
#include <tmp451.h>
#include "../file/config.hpp"
#include "../file/errors.hpp"
#include "../file/file_utils.hpp"
#include "../file/kip.hpp"
#include "../hos/apm_ext.h"
#include "../mgr/clock_manager.hpp"
#include "ipc_service.hpp"
#include <ipc_server.h>
#include <lockable_mutex.h>
#include "../file/file_utils.hpp"
#include "../file/errors.hpp"
#include "../mgr/clock_manager.hpp"
#include "../file/config.hpp"
#include "../file/kip.hpp"
namespace ipcService {
namespace {
@@ -48,19 +49,19 @@ namespace ipcService {
LockableMutex gThreadMutex;
IpcServer gServer;
Result GetApiVersion(u32* out_version) {
Result GetApiVersion(u32 *out_version) {
*out_version = HOCCLK_IPC_API_VERSION;
return 0;
}
Result GetVersionString(char* out_buf, size_t bufSize) {
Result GetVersionString(char *out_buf, size_t bufSize) {
if (bufSize) {
strncpy(out_buf, TARGET_VERSION, bufSize-1);
strncpy(out_buf, TARGET_VERSION, bufSize - 1);
}
return 0;
}
Result GetCurrentContext(HocClkContext* out_ctx) {
Result GetCurrentContext(HocClkContext *out_ctx) {
*out_ctx = clockManager::GetCurrentContext();
return 0;
}
@@ -70,7 +71,7 @@ namespace ipcService {
return 0;
}
Result GetProfileCount(std::uint64_t* tid, std::uint8_t* out_count) {
Result GetProfileCount(std::uint64_t *tid, std::uint8_t *out_count) {
if (!config::HasProfilesLoaded()) {
return HOCCLK_ERROR(ConfigNotLoaded);
}
@@ -78,7 +79,7 @@ namespace ipcService {
return 0;
}
Result GetProfiles(std::uint64_t* tid, HocClkTitleProfileList* out_profiles) {
Result GetProfiles(std::uint64_t *tid, HocClkTitleProfileList *out_profiles) {
if (!config::HasProfilesLoaded()) {
return HOCCLK_ERROR(ConfigNotLoaded);
}
@@ -86,7 +87,7 @@ namespace ipcService {
return 0;
}
Result SetProfiles(HocClkIpc_SetProfiles_Args* args) {
Result SetProfiles(HocClkIpc_SetProfiles_Args *args) {
if (!config::HasProfilesLoaded()) {
return HOCCLK_ERROR(ConfigNotLoaded);
}
@@ -97,12 +98,12 @@ namespace ipcService {
return 0;
}
Result SetEnabled(std::uint8_t* enabled) {
Result SetEnabled(std::uint8_t *enabled) {
config::SetEnabled(*enabled);
return 0;
}
Result SetOverride(HocClkIpc_SetOverride_Args* args) {
Result SetOverride(HocClkIpc_SetOverride_Args *args) {
if (!HOCCLK_ENUM_VALID(HocClkModule, args->module)) {
return HOCCLK_ERROR(Generic);
}
@@ -110,7 +111,7 @@ namespace ipcService {
return 0;
}
Result GetConfigValuesHandler(HocClkConfigValueList* out_configValues) {
Result GetConfigValuesHandler(HocClkConfigValueList *out_configValues) {
if (!config::HasProfilesLoaded()) {
return HOCCLK_ERROR(ConfigNotLoaded);
}
@@ -118,7 +119,7 @@ namespace ipcService {
return 0;
}
Result SetConfigValuesHandler(HocClkConfigValueList* configValues) {
Result SetConfigValuesHandler(HocClkConfigValueList *configValues) {
if (!config::HasProfilesLoaded()) {
return HOCCLK_ERROR(ConfigNotLoaded);
}
@@ -129,30 +130,28 @@ namespace ipcService {
return 0;
}
Result GetFreqList(HocClkIpc_GetFreqList_Args* args, std::uint32_t* out_list, std::size_t size, std::uint32_t* out_count) {
Result GetFreqList(HocClkIpc_GetFreqList_Args *args, std::uint32_t *out_list, std::size_t size, std::uint32_t *out_count) {
if (!HOCCLK_ENUM_VALID(HocClkModule, args->module)) {
return HOCCLK_ERROR(Generic);
}
if (args->maxCount != size/sizeof(*out_list)) {
if (args->maxCount != size / sizeof(*out_list)) {
return HOCCLK_ERROR(Generic);
}
clockManager::GetFreqList(args->module, out_list, args->maxCount, out_count);
return 0;
}
Result ServiceHandlerFunc(void* arg, const IpcServerRequest* r, u8* out_data, size_t* out_dataSize) {
Result ServiceHandlerFunc(void *arg, const IpcServerRequest *r, u8 *out_data, size_t *out_dataSize) {
(void)arg;
switch (r->data.cmdId) {
case HocClkIpcCmd_GetApiVersion:
*out_dataSize = sizeof(u32);
return GetApiVersion((u32*)out_data);
return GetApiVersion((u32 *)out_data);
case HocClkIpcCmd_GetVersionString:
if (r->hipc.meta.num_recv_buffers >= 1) {
return GetVersionString(
(char*)hipcGetBufferAddress(r->hipc.data.recv_buffers),
hipcGetBufferSize(r->hipc.data.recv_buffers)
);
return GetVersionString((char *)hipcGetBufferAddress(r->hipc.data.recv_buffers),
hipcGetBufferSize(r->hipc.data.recv_buffers));
}
break;
@@ -160,7 +159,7 @@ namespace ipcService {
if (r->data.size >= sizeof(std::uint64_t) && r->hipc.meta.num_recv_buffers >= 1) {
size_t bufSize = hipcGetBufferSize(r->hipc.data.recv_buffers);
if (bufSize >= sizeof(HocClkContext)) {
return GetCurrentContext((HocClkContext*)hipcGetBufferAddress(r->hipc.data.recv_buffers));
return GetCurrentContext((HocClkContext *)hipcGetBufferAddress(r->hipc.data.recv_buffers));
}
}
break;
@@ -171,7 +170,7 @@ namespace ipcService {
case HocClkIpcCmd_GetProfileCount:
if (r->data.size >= sizeof(std::uint64_t)) {
*out_dataSize = sizeof(std::uint8_t);
return GetProfileCount((std::uint64_t*)r->data.ptr, (std::uint8_t*)out_data);
return GetProfileCount((std::uint64_t *)r->data.ptr, (std::uint8_t *)out_data);
}
break;
@@ -179,26 +178,27 @@ namespace ipcService {
if (r->data.size >= sizeof(std::uint64_t) && r->hipc.meta.num_recv_buffers >= 1) {
size_t bufSize = hipcGetBufferSize(r->hipc.data.recv_buffers);
if (bufSize >= sizeof(HocClkTitleProfileList)) {
return GetProfiles((std::uint64_t*)r->data.ptr, (HocClkTitleProfileList*)hipcGetBufferAddress(r->hipc.data.recv_buffers));
return GetProfiles((std::uint64_t *)r->data.ptr,
(HocClkTitleProfileList *)hipcGetBufferAddress(r->hipc.data.recv_buffers));
}
}
break;
case HocClkIpcCmd_SetProfiles:
if (r->data.size >= sizeof(HocClkIpc_SetProfiles_Args)) {
return SetProfiles((HocClkIpc_SetProfiles_Args*)r->data.ptr);
return SetProfiles((HocClkIpc_SetProfiles_Args *)r->data.ptr);
}
break;
case HocClkIpcCmd_SetEnabled:
if (r->data.size >= sizeof(std::uint8_t)) {
return SetEnabled((std::uint8_t*)r->data.ptr);
return SetEnabled((std::uint8_t *)r->data.ptr);
}
break;
case HocClkIpcCmd_SetOverride:
if (r->data.size >= sizeof(HocClkIpc_SetOverride_Args)) {
return SetOverride((HocClkIpc_SetOverride_Args*)r->data.ptr);
return SetOverride((HocClkIpc_SetOverride_Args *)r->data.ptr);
}
break;
@@ -206,7 +206,7 @@ namespace ipcService {
if (r->hipc.meta.num_recv_buffers >= 1) {
size_t bufSize = hipcGetBufferSize(r->hipc.data.recv_buffers);
if (bufSize >= sizeof(HocClkConfigValueList)) {
return GetConfigValuesHandler((HocClkConfigValueList*)hipcGetBufferAddress(r->hipc.data.recv_buffers));
return GetConfigValuesHandler((HocClkConfigValueList *)hipcGetBufferAddress(r->hipc.data.recv_buffers));
}
}
break;
@@ -215,7 +215,7 @@ namespace ipcService {
if (r->hipc.meta.num_send_buffers >= 1) {
size_t bufSize = hipcGetBufferSize(r->hipc.data.send_buffers);
if (bufSize >= sizeof(HocClkConfigValueList)) {
return SetConfigValuesHandler((HocClkConfigValueList*)hipcGetBufferAddress(r->hipc.data.send_buffers));
return SetConfigValuesHandler((HocClkConfigValueList *)hipcGetBufferAddress(r->hipc.data.send_buffers));
}
}
break;
@@ -223,12 +223,9 @@ namespace ipcService {
case HocClkIpcCmd_GetFreqList:
if (r->data.size >= sizeof(HocClkIpc_GetFreqList_Args) && r->hipc.meta.num_recv_buffers >= 1) {
*out_dataSize = sizeof(std::uint32_t);
return GetFreqList(
(HocClkIpc_GetFreqList_Args*)r->data.ptr,
(std::uint32_t*)hipcGetBufferAddress(r->hipc.data.recv_buffers),
hipcGetBufferSize(r->hipc.data.recv_buffers),
(std::uint32_t*)out_data
);
return GetFreqList((HocClkIpc_GetFreqList_Args *)r->data.ptr,
(std::uint32_t *)hipcGetBufferAddress(r->hipc.data.recv_buffers),
hipcGetBufferSize(r->hipc.data.recv_buffers), (std::uint32_t *)out_data);
}
break;
@@ -243,7 +240,7 @@ namespace ipcService {
return HOCCLK_ERROR(Generic);
}
void ProcessThreadFunc(void* arg) {
void ProcessThreadFunc(void *arg) {
(void)arg;
Result rc;
while (true) {
@@ -259,7 +256,7 @@ namespace ipcService {
}
}
}
} // namespace
void Initialize() {
std::int32_t priority;
@@ -281,7 +278,7 @@ namespace ipcService {
}
void SetRunning(bool running) {
std::scoped_lock lock{gThreadMutex};
std::scoped_lock lock{ gThreadMutex };
if (gRunning == running) {
return;
}
@@ -297,4 +294,4 @@ namespace ipcService {
}
}
}
} // namespace ipcService

2
Source/hoc-clk/sysmodule/src/ipc/ipc_service.hpp
View File

@@ -35,4 +35,4 @@ namespace ipcService {
void Exit();
void SetRunning(bool running);
}
} // namespace ipcService