4 files changed, 27 insertions, 44 deletions

diff --git a/src/core/hle/kernel/k_scheduler.cpp b/src/core/hle/kernel/k_scheduler.cpp
index 0f7a541c8..edc5df733 100644
--- a/src/core/hle/kernel/k_scheduler.cpp
+++ b/src/core/hle/kernel/k_scheduler.cpp
@@ -627,11 +627,11 @@ void KScheduler::OnThreadStart() {
 void KScheduler::Unload(KThread* thread) {
     if (thread) {
         thread->SetIsRunning(false);
-        if (thread->IsContinuousOnSVC() && !thread->IsHLEThread()) {
+        if (thread->IsContinuousOnSVC()) {
             system.ArmInterface(core_id).ExceptionalExit();
             thread->SetContinuousOnSVC(false);
         }
-        if (!thread->IsHLEThread() && !thread->HasExited()) {
+        if (!thread->HasExited()) {
             Core::ARM_Interface& cpu_core = system.ArmInterface(core_id);
             cpu_core.SaveContext(thread->GetContext32());
             cpu_core.SaveContext(thread->GetContext64());
@@ -655,14 +655,13 @@ void KScheduler::Reload(KThread* thread) {
         if (thread_owner_process != nullptr) {
             system.Kernel().MakeCurrentProcess(thread_owner_process);
         }
-        if (!thread->IsHLEThread()) {
-            Core::ARM_Interface& cpu_core = system.ArmInterface(core_id);
-            cpu_core.LoadContext(thread->GetContext32());
-            cpu_core.LoadContext(thread->GetContext64());
-            cpu_core.SetTlsAddress(thread->GetTLSAddress());
-            cpu_core.SetTPIDR_EL0(thread->GetTPIDR_EL0());
-            cpu_core.ClearExclusiveState();
-        }
+
+        Core::ARM_Interface& cpu_core = system.ArmInterface(core_id);
+        cpu_core.LoadContext(thread->GetContext32());
+        cpu_core.LoadContext(thread->GetContext64());
+        cpu_core.SetTlsAddress(thread->GetTLSAddress());
+        cpu_core.SetTPIDR_EL0(thread->GetTPIDR_EL0());
+        cpu_core.ClearExclusiveState();
     }
 }
 
@@ -722,7 +721,7 @@ void KScheduler::SwitchToCurrent() {
             return state.needs_scheduling.load(std::memory_order_relaxed);
         };
         do {
-            if (current_thread != nullptr && !current_thread->IsHLEThread()) {
+            if (current_thread != nullptr) {
                 current_thread->context_guard.lock();
                 if (current_thread->GetRawState() != ThreadState::Runnable) {
                     current_thread->context_guard.unlock();
@@ -764,9 +763,9 @@ void KScheduler::Initialize() {
     std::string name = "Idle Thread Id:" + std::to_string(core_id);
     std::function<void(void*)> init_func = Core::CpuManager::GetIdleThreadStartFunc();
     void* init_func_parameter = system.GetCpuManager().GetStartFuncParamater();
-    ThreadType type = static_cast<ThreadType>(THREADTYPE_KERNEL | THREADTYPE_HLE | THREADTYPE_IDLE);
-    auto thread_res = KThread::Create(system, type, name, 0, 64, 0, static_cast<u32>(core_id), 0,
-                                      nullptr, std::move(init_func), init_func_parameter);
+    auto thread_res = KThread::Create(system, THREADTYPE_KERNEL, name, 0, THREADPRIO_LOWEST, 0,
+                                      static_cast<u32>(core_id), 0, nullptr, std::move(init_func),
+                                      init_func_parameter);
     idle_thread = thread_res.Unwrap().get();
 
     {
diff --git a/src/core/hle/kernel/k_thread.cpp b/src/core/hle/kernel/k_thread.cpp
index 1ec29636c..0f349dad2 100644
--- a/src/core/hle/kernel/k_thread.cpp
+++ b/src/core/hle/kernel/k_thread.cpp
@@ -125,7 +125,7 @@ ResultVal<std::shared_ptr<KThread>> KThread::Create(Core::System& system, Thread
                                                     void* thread_start_parameter) {
     auto& kernel = system.Kernel();
     // Check if priority is in ranged. Lowest priority -> highest priority id.
-    if (priority > THREADPRIO_LOWEST && ((type_flags & THREADTYPE_IDLE) == 0)) {
+    if (priority > THREADPRIO_LOWEST) {
         LOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
         return ERR_INVALID_THREAD_PRIORITY;
     }
@@ -164,10 +164,10 @@ ResultVal<std::shared_ptr<KThread>> KThread::Create(Core::System& system, Thread
     thread->owner_process = owner_process;
     thread->type = type_flags;
     thread->signaled = false;
-    if ((type_flags & THREADTYPE_IDLE) == 0) {
-        auto& scheduler = kernel.GlobalSchedulerContext();
-        scheduler.AddThread(thread);
-    }
+
+    auto& scheduler = kernel.GlobalSchedulerContext();
+    scheduler.AddThread(thread);
+
     if (owner_process) {
         thread->tls_address = thread->owner_process->CreateTLSRegion();
         thread->owner_process->RegisterThread(thread.get());
@@ -175,13 +175,10 @@ ResultVal<std::shared_ptr<KThread>> KThread::Create(Core::System& system, Thread
         thread->tls_address = 0;
     }
 
-    // TODO(peachum): move to ScheduleThread() when scheduler is added so selected core is used
-    // to initialize the context
-    if ((type_flags & THREADTYPE_HLE) == 0) {
-        ResetThreadContext32(thread->context_32, static_cast<u32>(stack_top),
-                             static_cast<u32>(entry_point), static_cast<u32>(arg));
-        ResetThreadContext64(thread->context_64, stack_top, entry_point, arg);
-    }
+    ResetThreadContext32(thread->context_32, static_cast<u32>(stack_top),
+                         static_cast<u32>(entry_point), static_cast<u32>(arg));
+    ResetThreadContext64(thread->context_64, stack_top, entry_point, arg);
+
     thread->host_context =
         std::make_shared<Common::Fiber>(std::move(thread_start_func), thread_start_parameter);
 
diff --git a/src/core/hle/kernel/k_thread.h b/src/core/hle/kernel/k_thread.h
index 75257d2b4..d9fe2e363 100644
--- a/src/core/hle/kernel/k_thread.h
+++ b/src/core/hle/kernel/k_thread.h
@@ -51,9 +51,6 @@ enum ThreadPriority : u32 {
 enum ThreadType : u32 {
     THREADTYPE_USER = 0x1,
     THREADTYPE_KERNEL = 0x2,
-    THREADTYPE_HLE = 0x4,
-    THREADTYPE_IDLE = 0x8,
-    THREADTYPE_SUSPEND = 0x10,
 };
 
 enum ThreadProcessorId : s32 {
@@ -309,16 +306,8 @@ public:
         return context_64;
     }
 
-    bool IsHLEThread() const {
-        return (type & THREADTYPE_HLE) != 0;
-    }
-
-    bool IsSuspendThread() const {
-        return (type & THREADTYPE_SUSPEND) != 0;
-    }
-
-    bool IsIdleThread() const {
-        return (type & THREADTYPE_IDLE) != 0;
+    bool IsKernelThread() const {
+        return (type & THREADTYPE_KERNEL) != 0;
     }
 
     bool WasRunning() const {
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 523dd63a5..6ae0bdeed 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -168,11 +168,9 @@ struct KernelCore::Impl {
             std::string name = "Suspend Thread Id:" + std::to_string(i);
             std::function<void(void*)> init_func = Core::CpuManager::GetSuspendThreadStartFunc();
             void* init_func_parameter = system.GetCpuManager().GetStartFuncParamater();
-            const auto type =
-                static_cast<ThreadType>(THREADTYPE_KERNEL | THREADTYPE_HLE | THREADTYPE_SUSPEND);
-            auto thread_res =
-                KThread::Create(system, type, std::move(name), 0, 0, 0, static_cast<u32>(i), 0,
-                                nullptr, std::move(init_func), init_func_parameter);
+            auto thread_res = KThread::Create(system, THREADTYPE_KERNEL, std::move(name), 0, 0, 0,
+                                              static_cast<u32>(i), 0, nullptr, std::move(init_func),
+                                              init_func_parameter);
 
             suspend_threads[i] = std::move(thread_res).Unwrap();
         }