3 files changed, 117 insertions, 29 deletions

diff --git a/src/core/hle/service/nvdrv/devices/nvhost_ctrl.h b/src/core/hle/service/nvdrv/devices/nvhost_ctrl.h
index 76a8b33c2..aa9b5a14b 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl.h
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl.h
@@ -26,12 +26,64 @@ private:
         IocSyncptIncrCommand = 0x40040015,
         IocSyncptWaitCommand = 0xC00C0016,
         IocModuleMutexCommand = 0x40080017,
-        IocModuleRegRDWRCommand = 0xC008010E,
+        IocModuleRegRDWRCommand = 0xC0180018,
         IocSyncptWaitexCommand = 0xC0100019,
         IocSyncptReadMaxCommand = 0xC008001A,
-        IocCtrlEventWaitCommand = 0xC010001D,
         IocGetConfigCommand = 0xC183001B,
+        IocCtrlEventSignalCommand = 0xC004001C,
+        IocCtrlEventWaitCommand = 0xC010001D,
+        IocCtrlEventWaitAsyncCommand = 0xC010001E,
+        IocCtrlEventRegisterCommand = 0xC004001F,
+        IocCtrlEventUnregisterCommand = 0xC0040020,
+        IocCtrlEventKillCommand = 0x40080021,
+    };
+    struct IocSyncptReadParams {
+        u32_le id;
+        u32_le value;
+    };
+    static_assert(sizeof(IocSyncptReadParams) == 8, "IocSyncptReadParams is incorrect size");
+
+    struct IocSyncptIncrParams {
+        u32_le id;
+    };
+    static_assert(sizeof(IocSyncptIncrParams) == 4, "IocSyncptIncrParams is incorrect size");
+
+    struct IocSyncptWaitParams {
+        u32_le id;
+        u32_le thresh;
+        s32_le timeout;
+    };
+    static_assert(sizeof(IocSyncptWaitParams) == 12, "IocSyncptWaitParams is incorrect size");
+
+    struct IocModuleMutexParams {
+        u32_le id;
+        u32_le lock; // (0 = unlock and 1 = lock)
+    };
+    static_assert(sizeof(IocModuleMutexParams) == 8, "IocModuleMutexParams is incorrect size");
+
+    struct IocModuleRegRDWRParams {
+        u32_le id;
+        u32_le num_offsets;
+        u32_le block_size;
+        u32_le offsets;
+        u32_le values;
+        u32_le write;
+    };
+    static_assert(sizeof(IocModuleRegRDWRParams) == 24, "IocModuleRegRDWRParams is incorrect size");
+
+    struct IocSyncptWaitexParams {
+        u32_le id;
+        u32_le thresh;
+        s32_le timeout;
+        u32_le value;
     };
+    static_assert(sizeof(IocSyncptWaitexParams) == 16, "IocSyncptWaitexParams is incorrect size");
+
+    struct IocSyncptReadMaxParams {
+        u32_le id;
+        u32_le value;
+    };
+    static_assert(sizeof(IocSyncptReadMaxParams) == 8, "IocSyncptReadMaxParams is incorrect size");
 
     struct IocGetConfigParams {
         std::array<char, 0x41> domain_str;
@@ -40,6 +92,12 @@ private:
     };
     static_assert(sizeof(IocGetConfigParams) == 387, "IocGetConfigParams is incorrect size");
 
+    struct IocCtrlEventSignalParams {
+        u32_le user_event_id;
+    };
+    static_assert(sizeof(IocCtrlEventSignalParams) == 4,
+                  "IocCtrlEventSignalParams is incorrect size");
+
     struct IocCtrlEventWaitParams {
         u32_le syncpt_id;
         u32_le threshold;
@@ -48,6 +106,32 @@ private:
     };
     static_assert(sizeof(IocCtrlEventWaitParams) == 16, "IocCtrlEventWaitParams is incorrect size");
 
+    struct IocCtrlEventWaitAsyncParams {
+        u32_le syncpt_id;
+        u32_le threshold;
+        u32_le timeout;
+        u32_le value;
+    };
+    static_assert(sizeof(IocCtrlEventWaitAsyncParams) == 16,
+                  "IocCtrlEventWaitAsyncParams is incorrect size");
+
+    struct IocCtrlEventRegisterParams {
+        u32_le user_event_id;
+    };
+    static_assert(sizeof(IocCtrlEventRegisterParams) == 4,
+                  "IocCtrlEventRegisterParams is incorrect size");
+
+    struct IocCtrlEventUnregisterParams {
+        u32_le user_event_id;
+    };
+    static_assert(sizeof(IocCtrlEventUnregisterParams) == 4,
+                  "IocCtrlEventUnregisterParams is incorrect size");
+
+    struct IocCtrlEventKill {
+        u64_le user_events;
+    };
+    static_assert(sizeof(IocCtrlEventKill) == 8, "IocCtrlEventKill is incorrect size");
+
     u32 NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output);
 
     u32 IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output);
diff --git a/src/core/hle/service/nvdrv/devices/nvmap.cpp b/src/core/hle/service/nvdrv/devices/nvmap.cpp
index d66fb3a9c..23fe98190 100644
--- a/src/core/hle/service/nvdrv/devices/nvmap.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvmap.cpp
@@ -119,25 +119,25 @@ u32 nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
     IocParamParams params;
     std::memcpy(&params, input.data(), sizeof(params));
 
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called type={}", params.type);
+    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called type={}", params.param);
 
     auto object = GetObject(params.handle);
     ASSERT(object);
     ASSERT(object->status == Object::Status::Allocated);
 
-    switch (static_cast<ParamTypes>(params.type)) {
+    switch (static_cast<ParamTypes>(params.param)) {
     case ParamTypes::Size:
-        params.value = object->size;
+        params.result = object->size;
         break;
     case ParamTypes::Alignment:
-        params.value = object->align;
+        params.result = object->align;
         break;
     case ParamTypes::Heap:
         // TODO(Subv): Seems to be a hardcoded value?
-        params.value = 0x40000000;
+        params.result = 0x40000000;
         break;
     case ParamTypes::Kind:
-        params.value = object->kind;
+        params.result = object->kind;
         break;
     default:
         UNIMPLEMENTED();
diff --git a/src/core/hle/service/nvdrv/devices/nvmap.h b/src/core/hle/service/nvdrv/devices/nvmap.h
index 5a3044167..39fafaa7c 100644
--- a/src/core/hle/service/nvdrv/devices/nvmap.h
+++ b/src/core/hle/service/nvdrv/devices/nvmap.h
@@ -59,17 +59,25 @@ private:
         Create = 0xC0080101,
         FromId = 0xC0080103,
         Alloc = 0xC0200104,
+        Free = 0xC0180105,
         Param = 0xC00C0109,
         GetId = 0xC008010E,
-        Free = 0xC0180105,
     };
-
     struct IocCreateParams {
         // Input
         u32_le size;
         // Output
         u32_le handle;
     };
+    static_assert(sizeof(IocCreateParams) == 8, "IocCreateParams has wrong size");
+
+    struct IocFromIdParams {
+        // Input
+        u32_le id;
+        // Output
+        u32_le handle;
+    };
+    static_assert(sizeof(IocFromIdParams) == 8, "IocFromIdParams has wrong size");
 
     struct IocAllocParams {
         // Input
@@ -81,37 +89,33 @@ private:
         INSERT_PADDING_BYTES(7);
         u64_le addr;
     };
+    static_assert(sizeof(IocAllocParams) == 32, "IocAllocParams has wrong size");
 
-    struct IocGetIdParams {
-        // Output
-        u32_le id;
-        // Input
-        u32_le handle;
-    };
-
-    struct IocFromIdParams {
-        // Input
-        u32_le id;
-        // Output
+    struct IocFreeParams {
         u32_le handle;
+        INSERT_PADDING_BYTES(4);
+        u64_le refcount;
+        u32_le size;
+        u32_le flags;
     };
+    static_assert(sizeof(IocFreeParams) == 24, "IocFreeParams has wrong size");
 
     struct IocParamParams {
         // Input
         u32_le handle;
-        u32_le type;
+        u32_le param;
         // Output
-        u32_le value;
+        u32_le result;
     };
+    static_assert(sizeof(IocParamParams) == 12, "IocParamParams has wrong size");
 
-    struct IocFreeParams {
+    struct IocGetIdParams {
+        // Output
+        u32_le id;
+        // Input
         u32_le handle;
-        INSERT_PADDING_BYTES(4);
-        u64_le refcount;
-        u32_le size;
-        u32_le flags;
     };
-    static_assert(sizeof(IocFreeParams) == 24, "IocFreeParams has wrong size");
+    static_assert(sizeof(IocGetIdParams) == 8, "IocGetIdParams has wrong size");
 
     u32 IocCreate(const std::vector<u8>& input, std::vector<u8>& output);
     u32 IocAlloc(const std::vector<u8>& input, std::vector<u8>& output);