blob: 9b73216b0cb103b163f1de4b13fb30aba9f269f6 (
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
|
/*
* ========================================================
*
* HCore
* Copyright Mahrouss Logic, all rights reserved.
*
* ========================================================
*/
#pragma once
#include <NewKit/Array.hpp>
#include <NewKit/Defines.hpp>
#include <NewKit/Utils.hpp>
#define IsActiveLow(flag) (flag & 2)
#define IsLevelTriggered(flag) (flag & 8)
namespace HCore::HAL {
extern "C" UChar in8(UInt16 port);
extern "C" UShort in16(UInt16 port);
extern "C" UInt in32(UInt16 port);
extern "C" void out16(UShort port, UShort byte);
extern "C" void out8(UShort port, UChar byte);
extern "C" void out32(UShort port, UInt byte);
extern "C" void rt_wait_for_io();
extern "C" void rt_halt();
extern "C" void rt_cli();
extern "C" void rt_sti();
extern "C" void rt_cld();
class Register64 {
public:
UIntPtr Base;
UShort Limit;
operator bool() { return Base > Limit; }
};
using RawRegister = UInt64;
using InterruptId = UShort; /* For each element in the IVT */
using interruptTrap = UIntPtr(UIntPtr sp);
typedef UIntPtr Reg;
struct __attribute__((packed)) StackFrame {
Reg Rax;
Reg Rbx;
Reg Rcx;
Reg Rdx;
Reg Rsi;
Reg Rdi;
Reg Rbp;
Reg Rsp;
Reg R8;
Reg R9;
Reg R10;
Reg R11;
Reg R12;
Reg R13;
Reg R14;
Reg R15;
};
typedef StackFrame *StackFramePtr;
class InterruptDescriptor final {
public:
UShort Offset;
UShort Selector;
UChar Ist;
UChar Atrributes;
UShort SecondOffset;
UInt ThirdOffset;
UInt Zero;
operator bool() { return Offset != 0xFFFF; }
};
using InterruptDescriptorArray = Array<InterruptDescriptor, 256>;
class SegmentDescriptor final {
public:
UInt16 Base;
UInt8 BaseMiddle;
UInt8 BaseHigh;
UShort Limit;
UChar Gran;
UChar AccessByte;
};
/***
* @brief Segment Boolean operations
*/
class SegmentDescriptorComparator final {
public:
bool IsValid(SegmentDescriptor &seg) { return seg.Base > seg.Limit; }
bool Equals(SegmentDescriptor &seg, SegmentDescriptor &segRight) {
return seg.Base == segRight.Base && seg.Limit == segRight.Limit;
}
};
using SegmentArray = Array<SegmentDescriptor, 6>;
class GDTLoader final {
public:
static void Load(Register64 &gdt);
static void Load(Ref<Register64> &gdt);
};
class IDTLoader final {
public:
static void Load(Register64 &idt);
static void Load(Ref<Register64> &idt);
};
void system_get_cores(voidPtr rsdPtr);
} // namespace HCore::HAL
extern "C" void idt_handle_system_call(HCore::UIntPtr rsp);
extern "C" void idt_handle_generic(HCore::UIntPtr rsp);
extern "C" void idt_handle_gpf(HCore::UIntPtr rsp);
extern "C" void idt_handle_math(HCore::UIntPtr rsp);
extern "C" void idt_handle_pf(HCore::UIntPtr rsp);
extern "C" void rt_load_idt(HCore::voidPtr ptr);
extern "C" void rt_load_gdt(HCore::voidPtr ptr);
|
