Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-07-11 15:29:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update timing implementation

Browse Source
This commit is contained in:
Alex
2023-04-23 05:30:58 +03:00
parent 7e201e0958
commit 89d747e52c
10 changed files with 308 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Core/Driver/DriverAPI.cpp
View File

@ -144,7 +144,7 @@ void DriverSleep(unsigned long Milliseconds)
if (TaskManager)
TaskManager->Sleep(Milliseconds);
else
TimeManager->Sleep(Milliseconds);
TimeManager->Sleep(Milliseconds, Time::Units::Milliseconds);
}
int Driversprintf(char *Buffer, const char *Format, ...)

2
Core/Lock.cpp
View File

@ -187,7 +187,7 @@ Retry:
if (i >= (DebuggerIsAttached ? 0x100000 : 0x10000000))
{
if (Target.load() == 0)
Target.store(TimeManager->CalculateTarget(Timeout));
Target.store(TimeManager->CalculateTarget(Timeout, Time::Units::Milliseconds));
TimeoutDeadLock(LockData, Target.load());
goto Retry;
}

77
Core/Time/HighPrecisionEventTimer.cpp Normal file
View File

@ -0,0 +1,77 @@
/*
This file is part of Fennix Kernel.
Fennix Kernel is free software: you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
Fennix Kernel is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
*/
#include <time.hpp>
#include <memory.hpp>
#include <debug.h>
#include <io.h>
#if defined(a64)
#include "../../Architecture/amd64/acpi.hpp"
#elif defined(a32)
#elif defined(aa64)
#endif
#include "../../kernel.h"
namespace Time
{
bool HighPrecisionEventTimer::Sleep(uint64_t Duration, Units Unit)
{
#if defined(a86)
uint64_t Target = mminq(&((HPET *)hpet)->MainCounterValue) + (Duration * ConvertUnit(Unit)) / clk;
while (mminq(&((HPET *)hpet)->MainCounterValue) < Target)
CPU::Pause();
return true;
#endif
}
uint64_t HighPrecisionEventTimer::GetCounter()
{
#if defined(a86)
return mminq(&((HPET *)hpet)->MainCounterValue);
#endif
}
uint64_t HighPrecisionEventTimer::CalculateTarget(uint64_t Target, Units Unit)
{
#if defined(a86)
return mminq(&((HPET *)hpet)->MainCounterValue) + (Target * ConvertUnit(Unit)) / clk;
#endif
}
HighPrecisionEventTimer::HighPrecisionEventTimer(void *hpet)
{
#if defined(a86)
ACPI::ACPI::HPETHeader *HPET_HDR = (ACPI::ACPI::HPETHeader *)hpet;
Memory::Virtual().Remap((void *)HPET_HDR->Address.Address,
(void *)HPET_HDR->Address.Address,
Memory::PTFlag::RW | Memory::PTFlag::PCD);
this->hpet = (HPET *)HPET_HDR->Address.Address;
trace("%s timer is at address %016p", HPET_HDR->Header.OEMID, (void *)HPET_HDR->Address.Address);
clk = s_cst(uint32_t, this->hpet->GeneralCapabilities >> 32);
mmoutq(&this->hpet->GeneralConfiguration, 0);
mmoutq(&this->hpet->MainCounterValue, 0);
mmoutq(&this->hpet->GeneralConfiguration, 1);
#endif
}
HighPrecisionEventTimer::~HighPrecisionEventTimer()
{
}
}

0
Core/Time.cpp → Core/Time/Time.cpp
View File

148
Core/Time/Timer.cpp Normal file
View File

@ -0,0 +1,148 @@
/*
This file is part of Fennix Kernel.
Fennix Kernel is free software: you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
Fennix Kernel is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
*/
#include <time.hpp>
#include <memory.hpp>
#include <debug.h>
#include <io.h>
#if defined(a64)
#include "../../Architecture/amd64/acpi.hpp"
#elif defined(a32)
#elif defined(aa64)
#endif
#include "../../kernel.h"
namespace Time
{
bool time::Sleep(uint64_t Duration, Units Unit)
{
switch (ActiveTimer)
{
case NONE:
error("No timer is active");
return false;
case RTC:
fixme("RTC sleep not implemented");
return false;
case PIT:
fixme("PIT sleep not implemented");
return false;
case HPET:
return hpet->Sleep(Duration, Unit);
case ACPI:
fixme("ACPI sleep not implemented");
return false;
case APIC:
fixme("APIC sleep not implemented");
return false;
case TSC:
fixme("TSC sleep not implemented");
return false;
default:
error("Unknown timer");
return false;
}
}
uint64_t time::GetCounter()
{
switch (ActiveTimer)
{
case NONE:
error("No timer is active");
return false;
case RTC:
fixme("RTC sleep not implemented");
return false;
case PIT:
fixme("PIT sleep not implemented");
return false;
case HPET:
return hpet->GetCounter();
case ACPI:
fixme("ACPI sleep not implemented");
return false;
case APIC:
fixme("APIC sleep not implemented");
return false;
case TSC:
fixme("TSC sleep not implemented");
return false;
default:
error("Unknown timer");
return false;
}
}
uint64_t time::CalculateTarget(uint64_t Target, Units Unit)
{
switch (ActiveTimer)
{
case NONE:
error("No timer is active");
return false;
case RTC:
fixme("RTC sleep not implemented");
return false;
case PIT:
fixme("PIT sleep not implemented");
return false;
case HPET:
return hpet->CalculateTarget(Target, Unit);
case ACPI:
fixme("ACPI sleep not implemented");
return false;
case APIC:
fixme("APIC sleep not implemented");
return false;
case TSC:
fixme("TSC sleep not implemented");
return false;
default:
error("Unknown timer");
return false;
}
}
time::time(void *acpi)
{
/* TODO: RTC check */
/* TODO: PIT check */
if (acpi)
{
if (((ACPI::ACPI *)acpi)->HPET)
{
hpet = new HighPrecisionEventTimer(((ACPI::ACPI *)acpi)->HPET);
ActiveTimer = HPET;
}
/* TODO: ACPI check */
/* TODO: APIC check */
}
/* TODO: TSC check */
}
time::~time()
{
debug("Destructor called");
}
}

106
Core/Timer.cpp
View File

@ -1,106 +0,0 @@
/*
This file is part of Fennix Kernel.
Fennix Kernel is free software: you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
Fennix Kernel is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
*/
#include <time.hpp>
#include <memory.hpp>
#include <debug.h>
#include <io.h>
#if defined(a64)
#include "../Architecture/amd64/acpi.hpp"
#elif defined(a32)
#elif defined(aa64)
#endif
#include "../kernel.h"
namespace Time
{
void time::Sleep(uint64_t Milliseconds)
{
#if defined(a86)
uint64_t Target = mminq(&((HPET *)hpet)->MainCounterValue) + (Milliseconds * 1000000000000) / clk;
#ifdef DEBUG
uint64_t Counter = mminq(&((HPET *)hpet)->MainCounterValue);
while (Counter < Target)
{
Counter = mminq(&((HPET *)hpet)->MainCounterValue);
CPU::Pause();
}
#else
while (mminq(&((HPET *)hpet)->MainCounterValue) < Target)
CPU::Pause();
#endif
#elif defined(aa64)
#endif
}
uint64_t time::GetCounter()
{
#if defined(a86)
return mminq(&((HPET *)hpet)->MainCounterValue);
#elif defined(aa64)
#endif
}
uint64_t time::CalculateTarget(uint64_t Milliseconds)
{
#if defined(a86)
return mminq(&((HPET *)hpet)->MainCounterValue) + (Milliseconds * 1000000000000) / clk;
#elif defined(aa64)
#endif
}
time::time(void *_acpi)
{
if (_acpi)
{
#if defined(a64)
this->acpi = _acpi;
ACPI::ACPI *acpi = (ACPI::ACPI *)this->acpi;
if (acpi->HPET)
{
Memory::Virtual().Remap((void *)acpi->HPET->Address.Address,
(void *)acpi->HPET->Address.Address,
Memory::PTFlag::RW | Memory::PTFlag::PCD);
this->hpet = (void *)acpi->HPET->Address.Address;
HPET *hpet = (HPET *)this->hpet;
trace("%s timer is at address %016p", acpi->HPET->Header.OEMID, (void *)acpi->HPET->Address.Address);
clk = s_cst(uint32_t, hpet->GeneralCapabilities >> 32);
mmoutq(&hpet->GeneralConfiguration, 0);
mmoutq(&hpet->MainCounterValue, 0);
mmoutq(&hpet->GeneralConfiguration, 1);
}
else
{
// For now, we need HPET.
error("HPET not found");
KPrint("\eFF2200HPET not found");
CPU::Stop();
}
#elif defined(a32)
#elif defined(aa64)
#endif
}
}
time::~time()
{
debug("Destructor called");
}
}