kernel: events: Remove ResetType::Automatic.

- This does not actually seem to exist in the real kernel - games reset these automatically.

# Conflicts:
#	src/core/hle/service/am/applets/applets.cpp
#	src/core/hle/service/filesystem/fsp_srv.cpp

src/core/hle/kernel/hle_ipc.cpp

@@ -58,8 +58,7 @@ SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
     auto& kernel = Core::System::GetInstance().Kernel();
     if (!writable_event) {
         // Create event if not provided
-        const auto pair = WritableEvent::CreateEventPair(kernel, ResetType::Automatic,
+        const auto pair = WritableEvent::CreateEventPair(kernel, "HLE Pause Event: " + reason);
-                                                         "HLE Pause Event: " + reason);
         writable_event = pair.writable;
     }
 

src/core/hle/kernel/object.h

@@ -32,11 +32,6 @@ enum class HandleType : u32 {
     ServerSession,
 };
 
-enum class ResetType {
-    Automatic, ///< Reset automatically on object acquisition
-    Manual,    ///< Never reset automatically
-};
-
 class Object : NonCopyable {
 public:
     explicit Object(KernelCore& kernel);

src/core/hle/kernel/readable_event.cpp

@@ -20,10 +20,6 @@ bool ReadableEvent::ShouldWait(const Thread* thread) const {
 
 void ReadableEvent::Acquire(Thread* thread) {
     ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
-
-    if (reset_type == ResetType::Automatic) {
-        signaled = false;
-    }
 }
 
 void ReadableEvent::Signal() {

src/core/hle/kernel/readable_event.h

@@ -27,10 +27,6 @@ public:
         return name;
     }
 
-    ResetType GetResetType() const {
-        return reset_type;
-    }
-
     static constexpr HandleType HANDLE_TYPE = HandleType::ReadableEvent;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
@@ -55,7 +51,6 @@ private:
 
     void Signal();
 
-    ResetType reset_type;
     bool signaled{};
 
     std::string name; ///< Name of event (optional)

src/core/hle/kernel/svc.cpp

@@ -2099,7 +2099,7 @@ static ResultCode CreateEvent(Core::System& system, Handle* write_handle, Handle
 
     auto& kernel = system.Kernel();
     const auto [readable_event, writable_event] =
-        WritableEvent::CreateEventPair(kernel, ResetType::Manual, "CreateEvent");
+        WritableEvent::CreateEventPair(kernel, "CreateEvent");
 
     HandleTable& handle_table = kernel.CurrentProcess()->GetHandleTable();
 

src/core/hle/kernel/writable_event.cpp

@@ -15,8 +15,7 @@ namespace Kernel {
 WritableEvent::WritableEvent(KernelCore& kernel) : Object{kernel} {}
 WritableEvent::~WritableEvent() = default;
 
-EventPair WritableEvent::CreateEventPair(KernelCore& kernel, ResetType reset_type,
+EventPair WritableEvent::CreateEventPair(KernelCore& kernel, std::string name) {
-                                         std::string name) {
     SharedPtr<WritableEvent> writable_event(new WritableEvent(kernel));
     SharedPtr<ReadableEvent> readable_event(new ReadableEvent(kernel));
 
@@ -24,7 +23,6 @@ EventPair WritableEvent::CreateEventPair(KernelCore& kernel, ResetType reset_typ
     writable_event->readable = readable_event;
     readable_event->name = name + ":Readable";
     readable_event->signaled = false;
-    readable_event->reset_type = reset_type;
 
     return {std::move(readable_event), std::move(writable_event)};
 }
@@ -33,10 +31,6 @@ SharedPtr<ReadableEvent> WritableEvent::GetReadableEvent() const {
     return readable;
 }
 
-ResetType WritableEvent::GetResetType() const {
-    return readable->reset_type;
-}
-
 void WritableEvent::Signal() {
     readable->Signal();
 }

src/core/hle/kernel/writable_event.h

@@ -24,11 +24,9 @@ public:
     /**
      * Creates an event
      * @param kernel The kernel instance to create this event under.
-     * @param reset_type ResetType describing how to create event
      * @param name Optional name of event
      */
-    static EventPair CreateEventPair(KernelCore& kernel, ResetType reset_type,
+    static EventPair CreateEventPair(KernelCore& kernel, std::string name = "Unknown");
-                                     std::string name = "Unknown");
 
     std::string GetTypeName() const override {
         return "WritableEvent";
@@ -44,8 +42,6 @@ public:
 
     SharedPtr<ReadableEvent> GetReadableEvent() const;
 
-    ResetType GetResetType() const;
-
     void Signal();
     void Clear();
     bool IsSignaled() const;

src/core/hle/service/am/am.cpp

@@ -289,8 +289,8 @@ ISelfController::ISelfController(Core::System& system,
     RegisterHandlers(functions);
 
     auto& kernel = system.Kernel();
-    launchable_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
+    launchable_event =
-                                                              "ISelfController:LaunchableEvent");
+        Kernel::WritableEvent::CreateEventPair(kernel, "ISelfController:LaunchableEvent");
 
     // This event is created by AM on the first time GetAccumulatedSuspendedTickChangedEvent() is
     // called. Yuzu can just create it unconditionally, since it doesn't need to support multiple
@@ -298,7 +298,7 @@ ISelfController::ISelfController(Core::System& system,
     // suspended if the event has previously been created by a call to
     // GetAccumulatedSuspendedTickChangedEvent.
     accumulated_suspended_tick_changed_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::Manual, "ISelfController:AccumulatedSuspendedTickChangedEvent");
+        kernel, "ISelfController:AccumulatedSuspendedTickChangedEvent");
     accumulated_suspended_tick_changed_event.writable->Signal();
 }
 
@@ -523,10 +523,10 @@ void ISelfController::GetAccumulatedSuspendedTickChangedEvent(Kernel::HLERequest
 }
 
 AppletMessageQueue::AppletMessageQueue(Kernel::KernelCore& kernel) {
-    on_new_message = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
+    on_new_message =
-                                                            "AMMessageQueue:OnMessageRecieved");
+        Kernel::WritableEvent::CreateEventPair(kernel, "AMMessageQueue:OnMessageRecieved");
-    on_operation_mode_changed = Kernel::WritableEvent::CreateEventPair(
+    on_operation_mode_changed =
-        kernel, Kernel::ResetType::Automatic, "AMMessageQueue:OperationModeChanged");
+        Kernel::WritableEvent::CreateEventPair(kernel, "AMMessageQueue:OperationModeChanged");
 }
 
 AppletMessageQueue::~AppletMessageQueue() = default;
@@ -1091,7 +1091,7 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
 
     auto& kernel = system.Kernel();
     gpu_error_detected_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::Manual, "IApplicationFunctions:GpuErrorDetectedSystemEvent");
+        kernel, "IApplicationFunctions:GpuErrorDetectedSystemEvent");
 }
 
 IApplicationFunctions::~IApplicationFunctions() = default;

src/core/hle/service/am/applets/applets.cpp

@@ -24,12 +24,12 @@
 namespace Service::AM::Applets {
 
 AppletDataBroker::AppletDataBroker(Kernel::KernelCore& kernel) {
-    state_changed_event = Kernel::WritableEvent::CreateEventPair(
+    state_changed_event =
-        kernel, Kernel::ResetType::Manual, "ILibraryAppletAccessor:StateChangedEvent");
+        Kernel::WritableEvent::CreateEventPair(kernel, "ILibraryAppletAccessor:StateChangedEvent");
-    pop_out_data_event = Kernel::WritableEvent::CreateEventPair(
+    pop_out_data_event =
-        kernel, Kernel::ResetType::Manual, "ILibraryAppletAccessor:PopDataOutEvent");
+        Kernel::WritableEvent::CreateEventPair(kernel, "ILibraryAppletAccessor:PopDataOutEvent");
     pop_interactive_out_data_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::Manual, "ILibraryAppletAccessor:PopInteractiveDataOutEvent");
+        kernel, "ILibraryAppletAccessor:PopInteractiveDataOutEvent");
 }
 
 AppletDataBroker::~AppletDataBroker() = default;

src/core/hle/service/aoc/aoc_u.cpp

@@ -67,8 +67,8 @@ AOC_U::AOC_U(Core::System& system)
     RegisterHandlers(functions);
 
     auto& kernel = system.Kernel();
-    aoc_change_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
+    aoc_change_event =
-                                                              "GetAddOnContentListChanged:Event");
+        Kernel::WritableEvent::CreateEventPair(kernel, "GetAddOnContentListChanged:Event");
 }
 
 AOC_U::~AOC_U() = default;

src/core/hle/service/audio/audout_u.cpp

@@ -65,8 +65,8 @@ public:
         RegisterHandlers(functions);
 
         // This is the event handle used to check if the audio buffer was released
-        buffer_event = Kernel::WritableEvent::CreateEventPair(
+        buffer_event =
-            system.Kernel(), Kernel::ResetType::Manual, "IAudioOutBufferReleased");
+            Kernel::WritableEvent::CreateEventPair(system.Kernel(), "IAudioOutBufferReleased");
 
         stream = audio_core.OpenStream(system.CoreTiming(), audio_params.sample_rate,
                                        audio_params.channel_count, std::move(unique_name),

src/core/hle/service/audio/audren_u.cpp

@@ -47,8 +47,8 @@ public:
         // clang-format on
         RegisterHandlers(functions);
 
-        system_event = Kernel::WritableEvent::CreateEventPair(
+        system_event =
-            system.Kernel(), Kernel::ResetType::Manual, "IAudioRenderer:SystemEvent");
+            Kernel::WritableEvent::CreateEventPair(system.Kernel(), "IAudioRenderer:SystemEvent");
         renderer = std::make_unique<AudioCore::AudioRenderer>(
             system.CoreTiming(), audren_params, system_event.writable, instance_number);
     }
@@ -180,17 +180,17 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = system.Kernel();
-        buffer_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
+        buffer_event =
-                                                              "IAudioOutBufferReleasedEvent");
+            Kernel::WritableEvent::CreateEventPair(kernel, "IAudioOutBufferReleasedEvent");
 
         // Should be similar to audio_output_device_switch_event
         audio_input_device_switch_event = Kernel::WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::Automatic, "IAudioDevice:AudioInputDeviceSwitchedEvent");
+            kernel, "IAudioDevice:AudioInputDeviceSwitchedEvent");
 
         // Should only be signalled when an audio output device has been changed, example: speaker
         // to headset
         audio_output_device_switch_event = Kernel::WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::Automatic, "IAudioDevice:AudioOutputDeviceSwitchedEvent");
+            kernel, "IAudioDevice:AudioOutputDeviceSwitchedEvent");
     }
 
 private:

src/core/hle/service/bcat/backend/backend.cpp

@@ -13,8 +13,7 @@ namespace Service::BCAT {
 ProgressServiceBackend::ProgressServiceBackend(Kernel::KernelCore& kernel,
                                                std::string_view event_name) {
     event = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::Automatic,
+        kernel, std::string("ProgressServiceBackend:UpdateEvent:").append(event_name));
-        std::string("ProgressServiceBackend:UpdateEvent:").append(event_name));
 }
 
 Kernel::SharedPtr<Kernel::ReadableEvent> ProgressServiceBackend::GetEvent() const {

src/core/hle/service/btdrv/btdrv.cpp

@@ -34,8 +34,7 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = system.Kernel();
-        register_event = Kernel::WritableEvent::CreateEventPair(
+        register_event = Kernel::WritableEvent::CreateEventPair(kernel, "BT:RegisterEvent");
-            kernel, Kernel::ResetType::Automatic, "BT:RegisterEvent");
     }
 
 private:

src/core/hle/service/btm/btm.cpp

@@ -57,14 +57,12 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = system.Kernel();
-        scan_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
+        scan_event = Kernel::WritableEvent::CreateEventPair(kernel, "IBtmUserCore:ScanEvent");
-                                                            "IBtmUserCore:ScanEvent");
+        connection_event =
-        connection_event = Kernel::WritableEvent::CreateEventPair(
+            Kernel::WritableEvent::CreateEventPair(kernel, "IBtmUserCore:ConnectionEvent");
-            kernel, Kernel::ResetType::Automatic, "IBtmUserCore:ConnectionEvent");
+        service_discovery =
-        service_discovery = Kernel::WritableEvent::CreateEventPair(
+            Kernel::WritableEvent::CreateEventPair(kernel, "IBtmUserCore:Discovery");
-            kernel, Kernel::ResetType::Automatic, "IBtmUserCore:Discovery");
+        config_event = Kernel::WritableEvent::CreateEventPair(kernel, "IBtmUserCore:ConfigEvent");
-        config_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
-                                                              "IBtmUserCore:ConfigEvent");
     }
 
 private:

src/core/hle/service/friend/friend.cpp

@@ -162,7 +162,7 @@ public:
         RegisterHandlers(functions);
 
         notification_event = Kernel::WritableEvent::CreateEventPair(
-            system.Kernel(), Kernel::ResetType::Manual, "INotificationService:NotifyEvent");
+            system.Kernel(), "INotificationService:NotifyEvent");
     }
 
 private:

src/core/hle/service/hid/controllers/npad.cpp

@@ -174,7 +174,7 @@ void Controller_NPad::OnInit() {
     auto& kernel = system.Kernel();
     for (std::size_t i = 0; i < styleset_changed_events.size(); i++) {
         styleset_changed_events[i] = Kernel::WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::Manual, fmt::format("npad:NpadStyleSetChanged_{}", i));
+            kernel, fmt::format("npad:NpadStyleSetChanged_{}", i));
     }
 
     if (!IsControllerActivated()) {

src/core/hle/service/nfp/nfp.cpp

@@ -26,8 +26,7 @@ constexpr ResultCode ERR_NO_APPLICATION_AREA(ErrorModule::NFP, 152);
 Module::Interface::Interface(std::shared_ptr<Module> module, Core::System& system, const char* name)
     : ServiceFramework(name), module(std::move(module)), system(system) {
     auto& kernel = system.Kernel();
-    nfc_tag_load = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
+    nfc_tag_load = Kernel::WritableEvent::CreateEventPair(kernel, "IUser:NFCTagDetected");
-                                                          "IUser:NFCTagDetected");
 }
 
 Module::Interface::~Interface() = default;
@@ -66,10 +65,9 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = system.Kernel();
-        deactivate_event = Kernel::WritableEvent::CreateEventPair(
+        deactivate_event = Kernel::WritableEvent::CreateEventPair(kernel, "IUser:DeactivateEvent");
-            kernel, Kernel::ResetType::Automatic, "IUser:DeactivateEvent");
+        availability_change_event =
-        availability_change_event = Kernel::WritableEvent::CreateEventPair(
+            Kernel::WritableEvent::CreateEventPair(kernel, "IUser:AvailabilityChangeEvent");
-            kernel, Kernel::ResetType::Automatic, "IUser:AvailabilityChangeEvent");
     }
 
 private:

src/core/hle/service/nifm/nifm.cpp

@@ -69,10 +69,8 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = system.Kernel();
-        event1 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
+        event1 = Kernel::WritableEvent::CreateEventPair(kernel, "IRequest:Event1");
-                                                        "IRequest:Event1");
+        event2 = Kernel::WritableEvent::CreateEventPair(kernel, "IRequest:Event2");
-        event2 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
-                                                        "IRequest:Event2");
     }
 
 private:

src/core/hle/service/nim/nim.cpp

@@ -141,8 +141,7 @@ public:
 
         auto& kernel = system.Kernel();
         finished_event = Kernel::WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::Automatic,
+            kernel, "IEnsureNetworkClockAvailabilityService:FinishEvent");
-            "IEnsureNetworkClockAvailabilityService:FinishEvent");
     }
 
 private:

src/core/hle/service/nvdrv/nvdrv.cpp

@@ -40,8 +40,7 @@ Module::Module(Core::System& system) {
     auto& kernel = system.Kernel();
     for (u32 i = 0; i < MaxNvEvents; i++) {
         std::string event_label = fmt::format("NVDRV::NvEvent_{}", i);
-        events_interface.events[i] =
+        events_interface.events[i] = Kernel::WritableEvent::CreateEventPair(kernel, event_label);
-            Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual, event_label);
         events_interface.status[i] = EventState::Free;
         events_interface.registered[i] = false;
     }

src/core/hle/service/nvflinger/buffer_queue.cpp

@@ -16,8 +16,7 @@ namespace Service::NVFlinger {
 
 BufferQueue::BufferQueue(Kernel::KernelCore& kernel, u32 id, u64 layer_id)
     : id(id), layer_id(layer_id) {
-    buffer_wait_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
+    buffer_wait_event = Kernel::WritableEvent::CreateEventPair(kernel, "BufferQueue NativeHandle");
-                                                               "BufferQueue NativeHandle");
 }
 
 BufferQueue::~BufferQueue() = default;

src/core/hle/service/vi/display/vi_display.cpp

@@ -17,8 +17,8 @@ namespace Service::VI {
 
 Display::Display(u64 id, std::string name, Core::System& system) : id{id}, name{std::move(name)} {
     auto& kernel = system.Kernel();
-    vsync_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
+    vsync_event =
-                                                         fmt::format("Display VSync Event {}", id));
+        Kernel::WritableEvent::CreateEventPair(kernel, fmt::format("Display VSync Event {}", id));
 }
 
 Display::~Display() = default;

src/yuzu/debugger/wait_tree.cpp

@@ -172,17 +172,6 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeWaitObject::GetChildren() con
     return list;
 }
 
-QString WaitTreeWaitObject::GetResetTypeQString(Kernel::ResetType reset_type) {
-    switch (reset_type) {
-    case Kernel::ResetType::Automatic:
-        return tr("automatic reset");
-    case Kernel::ResetType::Manual:
-        return tr("manual reset");
-    }
-    UNREACHABLE();
-    return {};
-}
-
 WaitTreeObjectList::WaitTreeObjectList(
     const std::vector<Kernel::SharedPtr<Kernel::WaitObject>>& list, bool w_all)
     : object_list(list), wait_all(w_all) {}
@@ -336,16 +325,6 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
 WaitTreeEvent::WaitTreeEvent(const Kernel::ReadableEvent& object) : WaitTreeWaitObject(object) {}
 WaitTreeEvent::~WaitTreeEvent() = default;
 
-std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeEvent::GetChildren() const {
-    std::vector<std::unique_ptr<WaitTreeItem>> list(WaitTreeWaitObject::GetChildren());
-
-    list.push_back(std::make_unique<WaitTreeText>(
-        tr("reset type = %1")
-            .arg(GetResetTypeQString(
-                static_cast<const Kernel::ReadableEvent&>(object).GetResetType()))));
-    return list;
-}
-
 WaitTreeThreadList::WaitTreeThreadList(const std::vector<Kernel::SharedPtr<Kernel::Thread>>& list)
     : thread_list(list) {}
 WaitTreeThreadList::~WaitTreeThreadList() = default;

src/yuzu/debugger/wait_tree.h

@@ -111,8 +111,6 @@ public:
 
 protected:
     const Kernel::WaitObject& object;
-
-    static QString GetResetTypeQString(Kernel::ResetType reset_type);
 };
 
 class WaitTreeObjectList : public WaitTreeExpandableItem {
@@ -146,8 +144,6 @@ class WaitTreeEvent : public WaitTreeWaitObject {
 public:
     explicit WaitTreeEvent(const Kernel::ReadableEvent& object);
     ~WaitTreeEvent() override;
-
-    std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
 };
 
 class WaitTreeThreadList : public WaitTreeExpandableItem {