RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 22:07:35 +00:00
Code Issues Activity Actions

Kernel: Use NonnullRefPtrVector for HardwareTimer and HPETComparator

Browse source
This commit is contained in:
Andreas Kling 2020-05-08 21:22:58 +02:00
parent 03c91fce74
commit c24304dca3
4 changed files with 12 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

17
Kernel/Time/HPET.cpp
View file

@ -161,11 +161,6 @@ bool HPET::check_for_exisiting_periodic_timers()
return false;
}
const FixedArray<RefPtr<HPETComparator>>& HPET::comparators() const
{
return m_comparators;
}
void HPET::global_disable()
{
auto* registers_block = (volatile HPETRegistersBlock*)m_hpet_mmio_region->vaddr().offset(m_physical_acpi_hpet_registers.offset_in_page()).as_ptr();
@ -331,7 +326,6 @@ HPET::HPET(PhysicalAddress acpi_hpet)
size_t timers_count = ((registers_block->raw_capabilites.reg >> 8) & 0x1f) + 1;
klog() << "HPET: Timers count - " << timers_count;
ASSERT(timers_count >= 2);
m_comparators.resize(timers_count);
auto* capabilities_register = (const volatile HPETCapabilityRegister*)&registers_block->raw_capabilites.reg;
global_disable();
@ -345,15 +339,8 @@ HPET::HPET(PhysicalAddress acpi_hpet)
if (registers_block->raw_capabilites.reg & (u32)HPETFlags::Attributes::LegacyReplacementRouteCapable)
registers_block->configuration.reg |= (u32)HPETFlags::Configuration::LegacyReplacementRoute;
for (size_t index = 0; index < m_comparators.size(); index++) {
bool periodic = is_periodic_capable(index);
if (index == 0) {
m_comparators[index] = HPETComparator::create(index, 0, periodic);
}
if (index == 1) {
m_comparators[index] = HPETComparator::create(index, 8, periodic);
}
}
m_comparators.append(HPETComparator::create(0, 0, is_periodic_capable(0)));
m_comparators.append(HPETComparator::create(1, 8, is_periodic_capable(1)));
global_enable();
}

6
Kernel/Time/HPET.h
View file

@ -27,10 +27,10 @@
#pragma once
#include <AK/FixedArray.h>
#include <AK/NonnullRefPtrVector.h>
#include <AK/OwnPtr.h>
#include <AK/Types.h>
#include <AK/Vector.h>
#include <Kernel/Time/HPET.h>
#include <Kernel/VM/Region.h>
#include <LibBareMetal/Memory/PhysicalAddress.h>
@ -47,7 +47,7 @@ public:
u64 main_counter_value() const;
u64 frequency() const;
const FixedArray<RefPtr<HPETComparator>>& comparators() const;
const NonnullRefPtrVector<HPETComparator>& comparators() const { return m_comparators; }
void disable(const HPETComparator&);
void enable(const HPETComparator&);
@ -85,6 +85,6 @@ private:
bool counter_is_64_bit_capable : 1;
bool legacy_replacement_route_capable : 1;
FixedArray<RefPtr<HPETComparator>> m_comparators;
NonnullRefPtrVector<HPETComparator> m_comparators;
};
}

10
Kernel/Time/TimeManagement.cpp
View file

@ -121,10 +121,10 @@ Vector<HardwareTimer*> TimeManagement::scan_and_initialize_periodic_timers()
dbg() << "Time: Scanning for periodic timers";
Vector<HardwareTimer*> timers;
for (auto& hardware_timer : m_hardware_timers) {
if (hardware_timer && hardware_timer->is_periodic_capable()) {
timers.append(hardware_timer);
if (hardware_timer.is_periodic_capable()) {
timers.append(&hardware_timer);
if (should_enable)
hardware_timer->set_periodic();
hardware_timer.set_periodic();
}
}
return timers;
@ -135,8 +135,8 @@ Vector<HardwareTimer*> TimeManagement::scan_for_non_periodic_timers()
dbg() << "Time: Scanning for non-periodic timers";
Vector<HardwareTimer*> timers;
for (auto& hardware_timer : m_hardware_timers) {
if (hardware_timer && !hardware_timer->is_periodic_capable())
timers.append(hardware_timer);
if (!hardware_timer.is_periodic_capable())
timers.append(&hardware_timer);
}
return timers;
}

3
Kernel/Time/TimeManagement.h
View file

@ -27,6 +27,7 @@
#pragma once
#include <AK/FixedArray.h>
#include <AK/NonnullRefPtrVector.h>
#include <AK/RefPtr.h>
#include <AK/Types.h>
#include <Kernel/UnixTypes.h>
@ -65,7 +66,7 @@ private:
bool probe_and_set_non_legacy_hardware_timers();
Vector<HardwareTimer*> scan_and_initialize_periodic_timers();
Vector<HardwareTimer*> scan_for_non_periodic_timers();
Vector<RefPtr<HardwareTimer>> m_hardware_timers;
NonnullRefPtrVector<HardwareTimer> m_hardware_timers;
u32 m_ticks_this_second { 0 };
u32 m_seconds_since_boot { 0 };