mika/libnx
1
0
Fork 0
mirror of https://github.com/switchbrew/libnx.git synced 2025-06-22 04:52:39 +02:00
Code Issues Packages Projects Releases Wiki Activity

nv: Use new IPC interface

Browse Source
This commit is contained in:
fincs 2019-09-19 13:23:16 +02:00
parent 20b26296af
commit 43ad77e8d2
No known key found for this signature in database
GPG Key ID: 62C7609ADA219C60
1 changed files with 93 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

339
nx/source/services/nv.c
View File

@ -2,8 +2,8 @@
#include "types.h" #include "types.h"
#include "result.h" #include "result.h"
#include "arm/atomics.h" #include "arm/atomics.h"
#include "kernel/ipc.h"
#include "kernel/tmem.h" #include "kernel/tmem.h"
#include "sf/service.h"
#include "services/applet.h" #include "services/applet.h"
#include "nvidia/ioctl.h" #include "nvidia/ioctl.h"
#include "services/nv.h" #include "services/nv.h"
@ -60,12 +60,8 @@ Result nvInitialize(void)
rc = _nvInitialize(CUR_PROCESS_HANDLE, g_nvTransfermem.handle, __nx_nv_transfermem_size); rc = _nvInitialize(CUR_PROCESS_HANDLE, g_nvTransfermem.handle, __nx_nv_transfermem_size);
// Clone the session handle - the cloned session is used to execute certain commands in parallel // Clone the session handle - the cloned session is used to execute certain commands in parallel
Handle nv_clone = INVALID_HANDLE;
if (R_SUCCEEDED(rc)) if (R_SUCCEEDED(rc))
rc = ipcCloneSession(g_nvSrv.session, 1, &nv_clone); rc = serviceCloneEx(&g_nvSrv, 1, &g_nvSrvClone);
if (R_SUCCEEDED(rc))
serviceCreate(&g_nvSrvClone, nv_clone);
if (R_SUCCEEDED(rc)) if (R_SUCCEEDED(rc))
{ {
@ -92,111 +88,36 @@ void nvExit(void)
} }
} }
static Result _nvInitialize(Handle proc, Handle sharedmem, u32 transfermem_size) { static Result _nvInitialize(Handle proc, Handle sharedmem, u32 transfermem_size)
IpcCommand c; {
ipcInitialize(&c); return serviceDispatchIn(&g_nvSrv, 3, transfermem_size,
.in_num_handles = 2,
struct { .in_handles = { proc, sharedmem },
u64 magic; );
u64 cmd_id;
u32 transfermem_size;
} *raw;
ipcSendHandleCopy(&c, proc);
ipcSendHandleCopy(&c, sharedmem);
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 3;
raw->transfermem_size = transfermem_size;
Result rc = serviceIpcDispatch(&g_nvSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }
static Result _nvSetClientPID(u64 AppletResourceUserId) { static Result _nvSetClientPID(u64 AppletResourceUserId)
IpcCommand c; {
ipcInitialize(&c); return serviceDispatchIn(&g_nvSrv, 8, AppletResourceUserId, .in_send_pid = true);
struct {
u64 magic;
u64 cmd_id;
u64 AppletResourceUserId;
} *raw;
ipcSendPid(&c);
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 8;
raw->AppletResourceUserId = AppletResourceUserId;
Result rc = serviceIpcDispatch(&g_nvSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result nvOpen(u32 *fd, const char *devicepath) { Result nvOpen(u32 *fd, const char *devicepath)
IpcCommand c; {
ipcInitialize(&c);
struct { struct {
u64 magic; u32 fd;
u64 cmd_id; u32 error;
} *raw; } out;
ipcAddSendBuffer(&c, devicepath, strlen(devicepath), 0); Result rc = serviceDispatchOut(&g_nvSrv, 0, out,
.buffer_attrs = { SfBufferAttr_In | SfBufferAttr_HipcMapAlias },
.buffers = { { devicepath, strlen(devicepath) } },
);
raw = ipcPrepareHeader(&c, sizeof(*raw)); if (R_SUCCEEDED(rc))
raw->magic = SFCI_MAGIC; rc = nvConvertError(out.error);
raw->cmd_id = 0;
Result rc = serviceIpcDispatch(&g_nvSrv); if (R_SUCCEEDED(rc) && fd)
*fd = out.fd;
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u32 fd;
u32 error;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc))
rc = nvConvertError(resp->error);
if (R_SUCCEEDED(rc))
*fd = resp->fd;
}
return rc; return rc;
} }
@ -214,194 +135,120 @@ static inline Service* _nvGetSessionForRequest(u32 request)
return &g_nvSrv; return &g_nvSrv;
} }
Result nvIoctl(u32 fd, u32 request, void* argp) { Result nvIoctl(u32 fd, u32 request, void* argp)
IpcCommand c; {
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
u32 fd;
u32 request;
} *raw;
size_t bufsize = _NV_IOC_SIZE(request); size_t bufsize = _NV_IOC_SIZE(request);
u32 dir = _NV_IOC_DIR(request); u32 dir = _NV_IOC_DIR(request);
void* buf_send = NULL, *buf_recv = NULL; void *buf_send = NULL, *buf_recv = NULL;
size_t buf_send_size = 0, buf_recv_size = 0; size_t buf_send_size = 0, buf_recv_size = 0;
if(dir & _NV_IOC_WRITE) { if (dir & _NV_IOC_WRITE) {
buf_send = argp; buf_send = argp;
buf_send_size = bufsize; buf_send_size = bufsize;
} }
if(dir & _NV_IOC_READ) { if (dir & _NV_IOC_READ) {
buf_recv = argp; buf_recv = argp;
buf_recv_size = bufsize; buf_recv_size = bufsize;
} }
ipcAddSendSmart(&c, g_nvIpcBufferSize, buf_send, buf_send_size, 0); const struct {
ipcAddRecvSmart(&c, g_nvIpcBufferSize, buf_recv, buf_recv_size, 0); u32 fd;
u32 request;
} in = { fd, request };
raw = ipcPrepareHeader(&c, sizeof(*raw)); u32 error = 0;
raw->magic = SFCI_MAGIC; Result rc = serviceDispatchInOut(_nvGetSessionForRequest(request), 1, in, error,
raw->cmd_id = 1; .buffer_attrs = {
raw->fd = fd; SfBufferAttr_HipcAutoSelect | SfBufferAttr_In,
raw->request = request; SfBufferAttr_HipcAutoSelect | SfBufferAttr_Out,
},
.buffers = {
{ buf_send, buf_send_size },
{ buf_recv, buf_recv_size },
},
);
Result rc = serviceIpcDispatch(_nvGetSessionForRequest(request)); if (R_SUCCEEDED(rc))
rc = nvConvertError(error);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u32 error;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc))
rc = nvConvertError(resp->error);
}
return rc; return rc;
} }
Result nvIoctl2(u32 fd, u32 request, void* argp, const void* inbuf, size_t inbuf_size) { Result nvIoctl2(u32 fd, u32 request, void* argp, const void* inbuf, size_t inbuf_size)
IpcCommand c; {
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
u32 fd;
u32 request;
} *raw;
size_t bufsize = _NV_IOC_SIZE(request); size_t bufsize = _NV_IOC_SIZE(request);
u32 dir = _NV_IOC_DIR(request); u32 dir = _NV_IOC_DIR(request);
void* buf_send = NULL, *buf_recv = NULL; void *buf_send = NULL, *buf_recv = NULL;
size_t buf_send_size = 0, buf_recv_size = 0; size_t buf_send_size = 0, buf_recv_size = 0;
if(dir & _NV_IOC_WRITE) { if (dir & _NV_IOC_WRITE) {
buf_send = argp; buf_send = argp;
buf_send_size = bufsize; buf_send_size = bufsize;
} }
if(dir & _NV_IOC_READ) { if (dir & _NV_IOC_READ) {
buf_recv = argp; buf_recv = argp;
buf_recv_size = bufsize; buf_recv_size = bufsize;
} }
ipcAddSendSmart(&c, g_nvIpcBufferSize, buf_send, buf_send_size, 0); const struct {
ipcAddSendSmart(&c, g_nvIpcBufferSize, inbuf, inbuf_size, 1);
ipcAddRecvSmart(&c, g_nvIpcBufferSize, buf_recv, buf_recv_size, 0);
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 11;
raw->fd = fd;
raw->request = request;
Result rc = serviceIpcDispatch(_nvGetSessionForRequest(request));
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u32 error;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc))
rc = nvConvertError(resp->error);
}
return rc;
}
Result nvClose(u32 fd) {
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
u32 fd; u32 fd;
} *raw; u32 request;
} in = { fd, request };
raw = ipcPrepareHeader(&c, sizeof(*raw)); u32 error = 0;
raw->magic = SFCI_MAGIC; Result rc = serviceDispatchInOut(_nvGetSessionForRequest(request), 11, in, error,
raw->cmd_id = 2; .buffer_attrs = {
raw->fd = fd; SfBufferAttr_HipcAutoSelect | SfBufferAttr_In,
SfBufferAttr_HipcAutoSelect | SfBufferAttr_In,
SfBufferAttr_HipcAutoSelect | SfBufferAttr_Out,
},
.buffers = {
{ buf_send, buf_send_size },
{ inbuf, inbuf_size },
{ buf_recv, buf_recv_size },
},
);
Result rc = serviceIpcDispatch(&g_nvSrv); if (R_SUCCEEDED(rc))
rc = nvConvertError(error);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u32 error;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc))
rc = nvConvertError(resp->error);
}
return rc; return rc;
} }
Result nvQueryEvent(u32 fd, u32 event_id, Event *event_out) { Result nvClose(u32 fd)
IpcCommand c; {
ipcInitialize(&c); u32 error = 0;
Result rc = serviceDispatchInOut(&g_nvSrv, 2, fd, error);
struct { if (R_SUCCEEDED(rc))
u64 magic; rc = nvConvertError(error);
u64 cmd_id;
return rc;
}
Result nvQueryEvent(u32 fd, u32 event_id, Event *event_out)
{
const struct {
u32 fd; u32 fd;
u32 event_id; u32 event_id;
} *raw; } in = { fd, event_id };
raw = ipcPrepareHeader(&c, sizeof(*raw)); u32 error = 0;
raw->magic = SFCI_MAGIC; Handle event;
raw->cmd_id = 4; Result rc = serviceDispatchInOut(&g_nvSrv, 4, in, error,
raw->fd = fd; .out_handle_attrs = { SfOutHandleAttr_HipcCopy },
raw->event_id = event_id; .out_handles = &event,
);
Result rc = serviceIpcDispatch(&g_nvSrv); if (R_SUCCEEDED(rc))
rc = nvConvertError(error);
if (R_SUCCEEDED(rc)) { if (R_SUCCEEDED(rc))
IpcParsedCommand r; eventLoadRemote(event_out, event, true);
ipcParse(&r);
struct {
u64 magic;
u64 result;
u32 error;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc))
rc = nvConvertError(resp->error);
if (R_SUCCEEDED(rc))
eventLoadRemote(event_out, r.Handles[0], true);
}
return rc; return rc;
} }