blob: ddfc49b690d1d907368f360c8383171c09dc3403 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/* -------------------------------------------
Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
------------------------------------------- */
#include <FSKit/NeFS.h>
#include <ArchKit/ArchKit.h>
#include <HALKit/AMD64/Processor.h>
#define kPITDefaultTicks (1000U)
namespace Kernel::HAL
{
namespace Detail
{
STATIC ::Kernel::Detail::AMD64::InterruptDescriptorAMD64
kInterruptVectorTable[kKernelIdtSize] = {};
#if 0
STATIC void hal_set_irq_mask(UInt8 irql) [[maybe_unused]]
{
UInt16 port;
UInt8 value;
if (irql < 8)
{
port = kPICData;
}
else
{
port = kPIC2Data;
irql -= 8;
}
value = rt_in8(port) | (1 << irql);
rt_out8(port, value);
}
#endif // make gcc shut up
STATIC void hal_clear_irq_mask(UInt8 irql) [[maybe_unused]]
{
UInt16 port;
UInt8 value;
if (irql < 8)
{
port = kPICData;
}
else
{
port = kPIC2Data;
irql -= 8;
}
value = rt_in8(port) & ~(1 << irql);
rt_out8(port, value);
}
STATIC Void hal_enable_pit(UInt16 ticks) noexcept
{
if (ticks == 0)
ticks = kPITDefaultTicks;
// Configure PIT to receieve scheduler interrupts.
UInt16 kPITCommDivisor = kPITFrequency / ticks; // 100 Hz.
HAL::rt_out8(kPITControlPort, 0x36); // Command to PIT
HAL::rt_out8(kPITChannel0Port, kPITCommDivisor & 0xFF); // Send low byte
HAL::rt_out8(kPITChannel0Port, (kPITCommDivisor >> 8) & 0xFF); // Send high byte
hal_clear_irq_mask(32);
}
} // namespace Detail
/// @brief Loads the provided Global Descriptor Table.
/// @param gdt
/// @return
Void GDTLoader::Load(Register64& gdt)
{
hal_load_gdt(gdt);
}
Void IDTLoader::Load(Register64& idt)
{
rt_cli();
const Int16 kPITTickForScheduler = kPITDefaultTicks;
volatile ::Kernel::UIntPtr** ptr_ivt = (volatile ::Kernel::UIntPtr**)idt.Base;
for (SizeT idt_indx = 0; idt_indx < kKernelIdtSize; ++idt_indx)
{
Detail::kInterruptVectorTable[idt_indx].Selector = kIDTSelector;
Detail::kInterruptVectorTable[idt_indx].Ist = 0;
Detail::kInterruptVectorTable[idt_indx].TypeAttributes = kInterruptGate;
Detail::kInterruptVectorTable[idt_indx].OffsetLow = ((UIntPtr)ptr_ivt[idt_indx] & 0xFFFF);
Detail::kInterruptVectorTable[idt_indx].OffsetMid = (((UIntPtr)ptr_ivt[idt_indx] >> 16) & 0xFFFF);
Detail::kInterruptVectorTable[idt_indx].OffsetHigh =
(((UIntPtr)ptr_ivt[idt_indx] >> 32) & 0xFFFFFFFF);
Detail::kInterruptVectorTable[idt_indx].Zero = 0;
}
idt.Base = (UIntPtr)&Detail::kInterruptVectorTable[0];
idt.Limit = sizeof(::Kernel::Detail::AMD64::InterruptDescriptorAMD64) *
(kKernelIdtSize);
hal_load_idt(idt);
NeFS::fs_init_nefs();
Detail::hal_enable_pit(kPITTickForScheduler);
rt_sti();
}
/// @brief Loads the Global Descriptor Table into the CPU.
/// @param gdt GDT register wrapped in a ref.
void GDTLoader::Load(Ref<Register64>& gdt)
{
if (!gdt)
return;
GDTLoader::Load(gdt.Leak());
}
/// @brief Loads the IDT, for interupts.
/// @param idt IDT register wrapped in a ref.
void IDTLoader::Load(Ref<Register64>& idt)
{
if (!idt)
return;
IDTLoader::Load(idt.Leak());
}
} // namespace Kernel::HAL
|
