blob: e6d57be235dff00fbba2a26dc9ba30b55e69d214 (
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
|
/* -------------------------------------------
Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
------------------------------------------- */
#include <ArchKit/ArchKit.h>
#include <FSKit/NeFS.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);
Detail::hal_enable_pit(kPITTickForScheduler);
hal_load_idt(idt);
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
|
