os-k/kaleid/kernel/ke/pit.c

234 lines
6.2 KiB
C
Raw Normal View History

2019-11-11 23:57:31 +01:00
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
2019-11-16 22:41:46 +01:00
// Desc: PIT Time related functions //
2019-11-11 23:57:31 +01:00
// //
// //
// Copyright © 2018-2020 The OS/K Team //
2019-11-11 23:57:31 +01:00
// //
// This file is part of OS/K. //
// //
// OS/K 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 //
// any later version. //
// //
// OS/K 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 OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
2020-02-19 22:19:58 +01:00
#include <libbuf.h>
2019-11-11 23:57:31 +01:00
#include <ke/time.h>
#include <ke/idt.h>
2020-02-02 14:21:15 +01:00
#include <ke/sched.h>
2019-11-11 23:57:31 +01:00
#define COUNTDONE 1
2019-11-18 00:15:39 +01:00
#define PIT_FREQUENCY 1000 // Hz = 1ms
2019-11-11 23:57:31 +01:00
static Timer_t Timer[20]; //20 concurrent sleep max
static ulong Ticks = 0;
static Time_t CurTime;
static char TimeFmtBuf[22] = { 0 };
2019-11-11 23:57:31 +01:00
2020-02-02 14:21:15 +01:00
extern bool PsInitialized;
2019-11-11 23:57:31 +01:00
//
// ISR handler for the Programmable Interval Timer
//
#pragma GCC push_options
#pragma GCC optimize ("O0")
2019-11-14 00:54:34 +01:00
static void HandlePIT(ISRFrame_t *regs)
2019-11-11 23:57:31 +01:00
{
2019-11-14 10:19:01 +01:00
Ticks++;
2019-11-11 23:57:31 +01:00
for (uchar i = 0; i < 20; i++) {
2019-11-14 00:54:34 +01:00
2019-11-15 00:09:20 +01:00
if (Timer[i].countDown > 0) {
Timer[i].countDown--;
2019-11-11 23:57:31 +01:00
2019-11-15 00:09:20 +01:00
if (Timer[i].countDown == 0)
Timer[i].sema = 1;
2019-11-11 23:57:31 +01:00
}
2019-11-14 00:54:34 +01:00
KeSendEOItoPIC(0x28);
2020-02-02 14:21:15 +01:00
if (PsInitialized && !(Ticks % 100)) {
PsSchedOnTick();
}
2019-11-11 23:57:31 +01:00
}
}
#pragma GCC pop_options
2019-11-11 23:57:31 +01:00
2019-11-15 00:09:20 +01:00
static Timer_t* KeFindTimerBlock(void)
2019-11-11 23:57:31 +01:00
{
for(uchar i = 0; i < 20; i++) {
2019-11-15 00:09:20 +01:00
if (Timer[i].countDown == 0)
return &Timer[i];
2019-11-11 23:57:31 +01:00
}
return NULL;
}
#pragma GCC push_options
#pragma GCC optimize ("O0")
2019-11-11 23:57:31 +01:00
void KeSleep(uint delay)
{
2019-11-18 00:15:39 +01:00
Timer_t *timerBlock;
2019-11-11 23:57:31 +01:00
2019-11-15 00:09:20 +01:00
if ((timerBlock = (Timer_t*)KeFindTimerBlock()) == NULL)
2019-11-11 23:57:31 +01:00
return;
2019-11-18 00:15:39 +01:00
timerBlock->countDown = delay * PIT_FREQUENCY / 1000;
2019-11-14 00:54:34 +01:00
2019-11-14 10:19:01 +01:00
while (!timerBlock->sema) {
2019-11-18 00:15:39 +01:00
KeRelaxCPU();
2019-11-14 10:19:01 +01:00
}
timerBlock->sema = 0;
}
#pragma GCC pop_options
2019-11-14 00:54:34 +01:00
#pragma GCC push_options
#pragma GCC optimize ("O0")
Timer_t *KeSetTimer(uint delay)
2019-11-15 00:09:20 +01:00
{
Timer_t *timerBlock;
2019-11-15 00:09:20 +01:00
if ((timerBlock = (Timer_t*)KeFindTimerBlock()) == NULL)
2019-11-15 00:09:20 +01:00
return NULL;
2019-11-18 00:15:39 +01:00
timerBlock->countDown = delay * PIT_FREQUENCY / 1000;
2019-11-15 00:09:20 +01:00
return timerBlock;
}
#pragma GCC pop_options
2019-11-15 00:09:20 +01:00
int KeGetTimer(Timer_t *timerBlock)
2019-11-18 00:15:39 +01:00
{
if (!(timerBlock->sema)) {
return 0;
} else {
timerBlock->sema = 0;
return 1;
}
}
2019-11-14 00:54:34 +01:00
void KeEnablePIT(void)
{
ulong flags = KePauseIRQs();
2019-11-14 10:19:01 +01:00
uint divisor = 1193180 / PIT_FREQUENCY; // PIT base frequency / Needed frequency
2019-11-14 00:54:34 +01:00
KeRegisterISR(HandlePIT, 0x20);
2019-11-18 00:15:39 +01:00
IoWriteByteOnPort(0x43, 0x36); // 0x36 for rate gen
2019-11-14 00:54:34 +01:00
IoWriteByteOnPort(0x40, (char)(divisor & 0xFF )); // low byte of freq
IoWriteByteOnPort(0x40, (char)((divisor >> 8)& 0xFF)); // high byte of freq
2019-11-18 00:15:39 +01:00
// Setting up the IRQ line
2019-11-14 00:54:34 +01:00
KeUnmaskIRQ(0);
2020-02-06 13:18:22 +01:00
DebugLog("PIT activated with period %d ms\n", 1000/PIT_FREQUENCY);
2019-11-14 00:54:34 +01:00
KeRestoreIRQs(flags);
KeEnableNMI();
2019-11-14 00:54:34 +01:00
}
2019-11-14 10:19:01 +01:00
char *KeFormatCurTime(void)
{
Time_t *RtcTime = KeGetCurTime();
snprintf(TimeFmtBuf, sizeof(TimeFmtBuf),
"%02d/%02d/%04d - %02d:%02d:%02d",
RtcTime->day,
RtcTime->month,
RtcTime->year + RtcTime->century*100,
RtcTime->hour,
RtcTime->min,
RtcTime->sec
);
return TimeFmtBuf;
}
static void UpdateCurTime(void)
{
ulong frequency = PIT_FREQUENCY;
uchar minRemain, hourRemain, dayRemain;
CurTime.sec =
2019-11-14 21:20:06 +01:00
(uchar)(((ulong)KeGetOriginTime()->sec * frequency + Ticks) / frequency % 60);
2019-11-14 10:19:01 +01:00
minRemain =
2019-11-14 21:20:06 +01:00
(uchar)(((ulong)KeGetOriginTime()->sec * frequency + Ticks) / (60 * frequency));
2019-11-14 10:19:01 +01:00
CurTime.min =
(uchar)(((ulong)KeGetOriginTime()->min + minRemain) % 60);
hourRemain =
(uchar)(((ulong)KeGetOriginTime()->min + minRemain) / 60);
CurTime.hour =
(uchar)(((ulong)KeGetOriginTime()->hour + hourRemain) % 24);
dayRemain =
(uchar)(((ulong)KeGetOriginTime()->hour + hourRemain) / 24);
CurTime.day =
(uchar)(((ulong)KeGetOriginTime()->day + dayRemain) % 30);
}
Time_t* KeGetCurTime(void)
{
UpdateCurTime();
return &CurTime;
}
void KeSetCurTime(Time_t time)
{
CurTime = time;
}
static uint IsLeapYear(uint year)
{
if (!(year % 4)) {
return 0;
}
return year % 100 == 0
? (year % 400 == 0)
: 1;
}
static uint DaysInMonth(uint month, uint year)
{
return (month == 2)
? (28 + IsLeapYear(year))
: 31 - (month - 1) % 7 % 2;
}
ulong KeGetTimeStamp(void)
{
Time_t *time = KeGetCurTime();
uint dpy = 365 + IsLeapYear(time->year);
uint dim = DaysInMonth(time->month, time->year + time->century * 100);
return time->sec
+ time->min * 60
+ time->hour * 60 * 60
+ time->day * 24 * 60 * 60
+ time->month * dim * 24 * 60 * 60
+ (time->year + time->century * 100)
* dpy * 24 * 60 * 60;
}
2020-01-18 00:48:05 +01:00
ulong KeGetTicks(void)
{
return Ticks;
}