4 files changed, 16 insertions, 57 deletions

diff --git a/src/core/hle/kernel/event.cpp b/src/core/hle/kernel/event.cpp
index 9dd3d0f5d..540199e03 100644
--- a/src/core/hle/kernel/event.cpp
+++ b/src/core/hle/kernel/event.cpp
@@ -25,66 +25,36 @@ public:
     ResetType intitial_reset_type;          ///< ResetType specified at Event initialization
     ResetType reset_type;                   ///< Current ResetType
 
-    bool locked;                            ///< Event signal wait
+    bool signaled;                          ///< Whether the event has already been signaled
     std::string name;                       ///< Name of event (optional)
 
     ResultVal<bool> WaitSynchronization() override {
-        bool wait = locked;
-        if (locked) {
+        bool wait = !signaled;
+        if (wait) {
             AddWaitingThread(GetCurrentThread());
             Kernel::WaitCurrentThread(WAITTYPE_EVENT, this);
         }
-        if (reset_type != RESETTYPE_STICKY) {
-            locked = true;
-        }
         return MakeResult<bool>(wait);
     }
 };
 
-/**
- * Changes whether an event is locked or not
- * @param handle Handle to event to change
- * @param locked Boolean locked value to set event
- * @return Result of operation, 0 on success, otherwise error code
- */
-ResultCode SetEventLocked(const Handle handle, const bool locked) {
-    Event* evt = g_handle_table.Get<Event>(handle).get();
-    if (evt == nullptr) return InvalidHandle(ErrorModule::Kernel);
-
-    evt->locked = locked;
-
-    return RESULT_SUCCESS;
-}
-
-/**
- * Signals an event
- * @param handle Handle to event to signal
- * @return Result of operation, 0 on success, otherwise error code
- */
 ResultCode SignalEvent(const Handle handle) {
     Event* evt = g_handle_table.Get<Event>(handle).get();
-    if (evt == nullptr) return InvalidHandle(ErrorModule::Kernel);
+    if (evt == nullptr)
+        return InvalidHandle(ErrorModule::Kernel);
 
-    // If any thread is signalled awake by this event, assume the event was "caught" and reset
-    // the event. This will result in the next thread waiting on the event to block. Otherwise,
-    // the event will not be reset, and the next thread to call WaitSynchronization on it will
-    // not block. Not sure if this is correct behavior, but it seems to work.
-    // TODO(bunnei): Test how this works on hardware
-    evt->locked = evt->ResumeAllWaitingThreads();
+    evt->signaled = true;
+    evt->ReleaseAllWaitingThreads();
 
     return RESULT_SUCCESS;
 }
 
-/**
- * Clears an event
- * @param handle Handle to event to clear
- * @return Result of operation, 0 on success, otherwise error code
- */
 ResultCode ClearEvent(Handle handle) {
     Event* evt = g_handle_table.Get<Event>(handle).get();
-    if (evt == nullptr) return InvalidHandle(ErrorModule::Kernel);
+    if (evt == nullptr)
+        return InvalidHandle(ErrorModule::Kernel);
 
-    evt->locked = true;
+    evt->signaled = false;
 
     return RESULT_SUCCESS;
 }
@@ -102,19 +72,13 @@ Event* CreateEvent(Handle& handle, const ResetType reset_type, const std::string
     // TOOD(yuriks): Fix error reporting
     handle = Kernel::g_handle_table.Create(evt).ValueOr(INVALID_HANDLE);
 
-    evt->locked = true;
+    evt->signaled = false;
     evt->reset_type = evt->intitial_reset_type = reset_type;
     evt->name = name;
 
     return evt;
 }
 
-/**
- * Creates an event
- * @param reset_type ResetType describing how to create event
- * @param name Optional name of event
- * @return Handle to newly created Event object
- */
 Handle CreateEvent(const ResetType reset_type, const std::string& name) {
     Handle handle;
     Event* evt = CreateEvent(handle, reset_type, name);
diff --git a/src/core/hle/kernel/event.h b/src/core/hle/kernel/event.h
index b1b9d4b7b..c08b12ee1 100644
--- a/src/core/hle/kernel/event.h
+++ b/src/core/hle/kernel/event.h
@@ -12,21 +12,16 @@
 namespace Kernel {
 
 /**
- * Changes whether an event is locked or not
- * @param handle Handle to event to change
- * @param locked Boolean locked value to set event
- */
-ResultCode SetEventLocked(const Handle handle, const bool locked);
-
-/**
  * Signals an event
  * @param handle Handle to event to signal
+ * @return Result of operation, 0 on success, otherwise error code
  */
 ResultCode SignalEvent(const Handle handle);
 
 /**
  * Clears an event
  * @param handle Handle to event to clear
+ * @return Result of operation, 0 on success, otherwise error code
  */
 ResultCode ClearEvent(Handle handle);
 
diff --git a/src/core/hle/service/apt_u.cpp b/src/core/hle/service/apt_u.cpp
index 69a7bcf92..d318de3d2 100644
--- a/src/core/hle/service/apt_u.cpp
+++ b/src/core/hle/service/apt_u.cpp
@@ -50,8 +50,8 @@ void Initialize(Service::Interface* self) {
     cmd_buff[3] = notification_event_handle;
     cmd_buff[4] = pause_event_handle;
 
-    Kernel::SetEventLocked(notification_event_handle, true);
-    Kernel::SetEventLocked(pause_event_handle, false); // Fire start event
+    Kernel::ClearEvent(notification_event_handle);
+    Kernel::SignalEvent(pause_event_handle); // Fire start event
 
     _assert_msg_(KERNEL, (0 != lock_handle), "Cannot initialize without lock");
     Kernel::ReleaseMutex(lock_handle);
diff --git a/src/core/hle/service/srv.cpp b/src/core/hle/service/srv.cpp
index ac5f30a28..082834cfe 100644
--- a/src/core/hle/service/srv.cpp
+++ b/src/core/hle/service/srv.cpp
@@ -24,7 +24,7 @@ static void GetProcSemaphore(Service::Interface* self) {
 
     // TODO(bunnei): Change to a semaphore once these have been implemented
     g_event_handle = Kernel::CreateEvent(RESETTYPE_ONESHOT, "SRV:Event");
-    Kernel::SetEventLocked(g_event_handle, false);
+    Kernel::ClearEvent(g_event_handle);
 
     cmd_buff[1] = 0; // No error
     cmd_buff[3] = g_event_handle;