123 lines
3.4 KiB
C++
123 lines
3.4 KiB
C++
// Copyright 2023 Citra Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#include "common/archives.h"
|
|
#include "common/assert.h"
|
|
#include "common/logging/log.h"
|
|
#include "core/core.h"
|
|
#include "core/hle/kernel/k_event.h"
|
|
#include "core/hle/kernel/k_process.h"
|
|
#include "core/hle/kernel/k_resource_limit.h"
|
|
#include "core/hle/kernel/k_timer.h"
|
|
|
|
SERIALIZE_EXPORT_IMPL(Kernel::KTimer)
|
|
|
|
namespace Kernel {
|
|
|
|
KTimer::KTimer(KernelSystem& kernel)
|
|
: KAutoObjectWithSlabHeapAndContainer(kernel), m_timer_manager(kernel.GetTimerManager()) {}
|
|
|
|
KTimer::~KTimer() = default;
|
|
|
|
void KTimer::Initialize(Process* owner, ResetType reset_type) {
|
|
// Open a reference to the owner process.
|
|
owner->Open();
|
|
|
|
// Set member variables.
|
|
m_owner = owner;
|
|
m_reset_type = reset_type;
|
|
|
|
// Register to TimerManager
|
|
m_callback_id = m_timer_manager.GetNextCallbackId();
|
|
m_timer_manager.Register(m_callback_id, this);
|
|
}
|
|
|
|
void KTimer::Finalize() {
|
|
this->Cancel();
|
|
m_timer_manager.Unregister(m_callback_id);
|
|
}
|
|
|
|
void KTimer::PostDestroy(uintptr_t arg) {
|
|
// Release the session count resource the owner process holds.
|
|
Process* owner = reinterpret_cast<Process*>(arg);
|
|
owner->ReleaseResource(ResourceLimitType::Timer, 1);
|
|
owner->Close();
|
|
}
|
|
|
|
bool KTimer::ShouldWait(const KThread* thread) const {
|
|
return !m_signaled;
|
|
}
|
|
|
|
void KTimer::Acquire(KThread* thread) {
|
|
ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
|
|
if (m_reset_type == ResetType::OneShot) {
|
|
m_signaled = false;
|
|
}
|
|
}
|
|
|
|
void KTimer::Set(s64 initial, s64 interval) {
|
|
// Ensure we get rid of any previous scheduled event
|
|
this->Cancel();
|
|
|
|
// Set member variables
|
|
m_initial_delay = initial;
|
|
m_interval_delay = interval;
|
|
|
|
if (initial == 0) {
|
|
// Immediately invoke the callback
|
|
this->Signal(0);
|
|
} else {
|
|
auto& timing = m_kernel.timing;
|
|
timing.ScheduleEvent(nsToCycles(initial), m_timer_manager.GetEventType(), m_callback_id);
|
|
}
|
|
}
|
|
|
|
void KTimer::Cancel() {
|
|
auto& timing = m_kernel.timing;
|
|
timing.UnscheduleEvent(m_timer_manager.GetEventType(), m_callback_id);
|
|
}
|
|
|
|
void KTimer::Clear() {
|
|
m_signaled = false;
|
|
}
|
|
|
|
void KTimer::WakeupAllWaitingThreads() {
|
|
KSynchronizationObject::WakeupAllWaitingThreads();
|
|
if (m_reset_type == ResetType::Pulse) {
|
|
m_signaled = false;
|
|
}
|
|
}
|
|
|
|
void KTimer::Signal(s64 cycles_late) {
|
|
LOG_TRACE(Kernel, "Timer {} fired", GetObjectId());
|
|
m_signaled = true;
|
|
|
|
// Resume all waiting threads
|
|
this->WakeupAllWaitingThreads();
|
|
|
|
// Reschedule the timer with the interval delay
|
|
if (m_interval_delay != 0) {
|
|
auto& timing = m_kernel.timing;
|
|
const s64 cycles_into_future = nsToCycles(m_interval_delay) - cycles_late;
|
|
timing.ScheduleEvent(cycles_into_future, m_timer_manager.GetEventType(), m_callback_id);
|
|
}
|
|
}
|
|
|
|
void TimerManager::TimerCallback(u64 callback_id, s64 cycles_late) {
|
|
KTimer* timer = m_timer_callback_table.at(callback_id);
|
|
ASSERT_MSG(timer, "Callback fired for invalid timer {:016x}", callback_id);
|
|
timer->Signal(cycles_late);
|
|
}
|
|
|
|
TimerManager::TimerManager(Core::Timing& timing) : m_timing(timing) {
|
|
m_timer_callback_event_type =
|
|
timing.RegisterEvent("TimerCallback", [this](u64 thread_id, s64 cycle_late) {
|
|
this->TimerCallback(thread_id, cycle_late);
|
|
});
|
|
}
|
|
|
|
TimerManager::~TimerManager() = default;
|
|
|
|
} // namespace Kernel
|