IgrOS-Kernel 0.1.34.545
Simple C++20 Kernel for i386/x86_64
Loading...
Searching...
No Matches
serial.cpp
Go to the documentation of this file.
1
11
12
13// C++
14#include <array>
15// IgrOS-Kernel arch
16#include <arch/io.hpp>
17#include <arch/irq.hpp>
18// IgrOS-Kernel drivers
20// IgrOS-Kernel library
21#include <klib/kFlags.hpp>
22#include <klib/kPrint.hpp>
23#include <klib/kString.hpp>
24
25
26// Arch-dependent code zone
27namespace igros::arch {
28
29
31 namespace {
32
34 enum class SERIAL_REG : igros_word_t {
35 DATA = 0x00_u16,
36 IER = 0x01_u16,
37 IIR = 0x02_u16,
38 LCR = 0x03_u16,
39 MCR = 0x04_u16,
40 LSR = 0x05_u16,
41 MSR = 0x06_u16,
42 SCRATCH = 0x07_u16,
43 };
44
46 enum class SERIAL_LSR : igros_byte_t {
47 DATA_READY = 0x01_u8,
48 THR_EMPTY = 0x20_u8,
49 TX_IDLE = 0x40_u8,
50 };
51
53 enum class SERIAL_IER : igros_byte_t {
54 RX_READY = 0x01_u8,
55 };
56
58 enum class SERIAL_MCR : igros_byte_t {
59 DTR = 0x01_u8,
60 RTS = 0x02_u8,
61 OUT1 = 0x04_u8,
62 OUT2 = 0x08_u8,
63 LOOPBACK = 0x10_u8,
64 };
65
66 } // namespace
67
68
73 [[nodiscard]]
74 constexpr static auto serialRegister(const SERIAL_PORT port, const SERIAL_REG reg) noexcept -> port_t {
75 return static_cast<port_t>(static_cast<igros_word_t>(port) + static_cast<igros_word_t>(reg));
76 }
77
82 static void serialRegWrite(const SERIAL_PORT port, const SERIAL_REG reg, const igros_byte_t value) noexcept {
83 io::writePort8(serialRegister(port, reg), value);
84 }
85
90 [[nodiscard]]
91 static auto serialRegRead(const SERIAL_PORT port, const SERIAL_REG reg) noexcept -> igros_byte_t {
92 return io::readPort8(serialRegister(port, reg));
93 }
94
98 [[nodiscard]]
99 static auto serialStatus(const SERIAL_PORT port) noexcept -> klib::kFlags<SERIAL_LSR> {
100 return klib::kFlags<SERIAL_LSR>::from(serialRegRead(port, SERIAL_REG::LSR));
101 }
102
107 [[nodiscard]]
108 static auto serialWaitStatus(const SERIAL_PORT port, const SERIAL_LSR status) noexcept -> bool {
109 for (auto spin {0_usize}; spin < 100000_usize; ++spin) {
110 if (serialStatus(port).isSet(status)) [[likely]] {
111 return true;
112 }
113 }
114 return false;
115 }
116
117
118 // Initialize serial port
119 [[nodiscard]]
120 auto serialInit(const SERIAL_PORT port, const BAUD_RATE baudRate, const DATA_SIZE dataSize, const STOP_BITS stopBits, const PARITY parity) noexcept -> bool {
121
122 // Calculate BAUD rate divisor
123 const auto rate {static_cast<igros_word_t>(115200_u32 / static_cast<igros_dword_t>(baudRate))};
124 // LCR value
125 const auto lcr = static_cast<igros_byte_t>(
126 (static_cast<igros_dword_t>(dataSize) & 0x03_u32) |
127 ((static_cast<igros_dword_t>(stopBits) & 0x01_u32) << 2) |
128 ((static_cast<igros_dword_t>(parity) & 0x03_u32) << 3)
129 );
130
131 // Let previous output finish (reprogramming would clobber byte being sent)
132 if (!serialWaitStatus(port, SERIAL_LSR::TX_IDLE)) [[unlikely]] {
133 return false;
134 }
135
136 // Disable SERIAL interrupts
137 serialRegWrite(port, SERIAL_REG::IER, 0x00_u8);
138 // Set DLAB to access BAUD rate divisor
139 serialRegWrite(port, SERIAL_REG::LCR, 0x80_u8);
140 // Write BAUD rate divisor low byte
141 serialRegWrite(port, SERIAL_REG::DATA, static_cast<igros_byte_t>(rate & 0x00FF_u16));
142 // Write BAUD rate divisor high byte
143 serialRegWrite(port, SERIAL_REG::IER, static_cast<igros_byte_t>((static_cast<igros_dword_t>(rate) >> 8) & 0x00FF_u32));
144 // Write LCR params (also clears DLAB)
145 serialRegWrite(port, SERIAL_REG::LCR, lcr);
146 // Enable FIFO, clear them with 14-byte threshold
147 serialRegWrite(port, SERIAL_REG::IIR, 0xC7_u8);
148 // IRQs enabled, DTR/RTS set
149 serialRegWrite(port, SERIAL_REG::MCR, klib::make_kflags<SERIAL_MCR>(SERIAL_MCR::DTR, SERIAL_MCR::RTS, SERIAL_MCR::OUT2).value());
150 // Set loopback mode, test the serial chip
151 serialRegWrite(port, SERIAL_REG::MCR, klib::make_kflags<SERIAL_MCR>(SERIAL_MCR::RTS, SERIAL_MCR::OUT1, SERIAL_MCR::OUT2, SERIAL_MCR::LOOPBACK).value());
152 // Test port with 0xA5 byte
153 serialRegWrite(port, SERIAL_REG::DATA, 0xA5_u8);
154
155 // Check loopback (byte comes back once shifted out: one character time)
156 if (!serialWaitStatus(port, SERIAL_LSR::DATA_READY) || (0xA5_u8 != serialRegRead(port, SERIAL_REG::DATA))) {
157 // Could not setup serial port
158 return false;
159 }
160
161 // Set normal mode (not-loopback with IRQs enabled and OUT#1 and OUT#2 bits enabled)
162 serialRegWrite(port, SERIAL_REG::MCR, klib::make_kflags<SERIAL_MCR>(SERIAL_MCR::DTR, SERIAL_MCR::RTS, SERIAL_MCR::OUT1, SERIAL_MCR::OUT2).value());
163
164 // Debug
166 "Serial port 0x%x:\t%d %d%c%d",
167 static_cast<igros_dword_t>(port),
168 static_cast<igros_dword_t>(baudRate),
169 static_cast<igros_dword_t>(dataSize) + 5_u32,
170 (parity == PARITY::NONE) ? 'N' : '?',
171 (static_cast<igros_dword_t>(stopBits) & 0x01_u32) + 1_u32
172 );
173
174 // Success
175 return true;
176 }
177
178
179 // Is write ready? (LSR bit 5 - transmitter holding register empty)
180 [[nodiscard]]
181 auto serialReadyWrite(const SERIAL_PORT port) noexcept -> bool {
182 return serialStatus(port).isSet(SERIAL_LSR::THR_EMPTY);
183 }
184
185 // Is read ready? (LSR bit 0 - data ready)
186 [[nodiscard]]
187 auto serialReadyRead(const SERIAL_PORT port) noexcept -> bool {
188 return serialStatus(port).isSet(SERIAL_LSR::DATA_READY);
189 }
190
194 [[nodiscard]]
195 static auto serialWaitWrite(const SERIAL_PORT port) noexcept -> bool {
196 return serialWaitStatus(port, SERIAL_LSR::THR_EMPTY);
197 }
198
199
204 [[nodiscard]]
205 static auto serialPut(const SERIAL_PORT port, const igros_byte_t value) noexcept -> bool {
206 if (!serialWaitWrite(port)) [[unlikely]] {
207 return false;
208 }
209 serialRegWrite(port, SERIAL_REG::DATA, value);
210 return true;
211 }
212
213
218 [[nodiscard]]
219 static auto serialPutSymbol(const SERIAL_PORT port, const char symbol) noexcept -> bool {
220 if (('\n' == symbol) && !serialPut(port, '\r')) [[unlikely]] {
221 return false;
222 }
223 return serialPut(port, static_cast<igros_byte_t>(symbol));
224 }
225
230 [[nodiscard]]
231 static auto serialGetSymbol(const SERIAL_PORT port, char &symbol) noexcept -> bool {
232 if (!serialReadyRead(port)) {
233 return false;
234 }
235 symbol = static_cast<char>(serialRegRead(port, SERIAL_REG::DATA));
236 return true;
237 }
238
239
240 // Serial write
241 [[maybe_unused]]
242 auto serialWrite(const SERIAL_PORT port, const std::string_view text) noexcept -> igros_usize_t {
243 // Write data one-by-one until transmitter fails
244 auto written {0_usize};
245 while ((written < text.size()) && serialPutSymbol(port, text[written])) {
246 ++written;
247 }
248 // Return written size
249 return written;
250 }
251
252 // Serial read
253 [[maybe_unused]]
254 auto serialRead(const SERIAL_PORT port, const std::span<char> buffer) noexcept -> igros_usize_t {
255 // Read data one-by-one while available (never past buffer size)
256 auto read {0_usize};
257 while ((read < buffer.size()) && serialGetSymbol(port, buffer[read])) {
258 ++read;
259 }
260 // Return read size
261 return read;
262 }
263
264
265 // Serial write to COM1 (kernel console)
266 [[maybe_unused]]
267 auto serialWrite(const std::string_view text) noexcept -> igros_usize_t {
268 return serialWrite(SERIAL_PORT::COM1, text);
269 }
270
271 // Serial write to COM1 (kernel console)
272 [[maybe_unused]]
273 auto serialWrite(const char* const src) noexcept -> igros_usize_t {
274 return serialWrite(SERIAL_PORT::COM1, klib::kstrview(src));
275 }
276
277
280 static void serialInterruptHandler1([[maybe_unused]] const register_t* const regs) noexcept {
281 // Zero-initialized
282 auto data {std::array<char, 128_usize> {}};
283 // Read from COM1 (keep space for null terminator, reading also acknowledges interrupt)
284 const auto read {serialRead(SERIAL_PORT::COM1, std::span {data}.first(data.size() - 1_usize))};
285 // Debug data
287 "IRQ #%u\t[UART1]\n"
288 "Read:\t%05zu bytes = %s\n",
289 static_cast<igros_dword_t>(irq_t::UART1),
290 read,
291 data.data()
292 );
293 }
294
295
296 // Setup COM1 (115200 8N1) with receive interrupt
297 [[nodiscard]]
298 auto serialSetup() noexcept -> bool {
299
300 // Init serial port
301 if (!serialInit(SERIAL_PORT::COM1, BAUD_RATE::BAUD_115200, DATA_SIZE::CHAR_8, STOP_BITS::STOP_1, PARITY::NONE)) {
302 // Fail
303 return false;
304 }
305
306 // Install UART1 interrupt handler
308 // Enable receive interrupt
309 serialRegWrite(SERIAL_PORT::COM1, SERIAL_REG::IER, klib::make_kflags<SERIAL_IER>(SERIAL_IER::RX_READY).value());
310 // Unmask UART1 interrupts
311 irq::unmask(irq_t::UART1);
312
313 // Success
314 return true;
315 }
316
317
318} // namespace igros::arch
319
static auto readPort8(const port_t addr) noexcept -> igros_byte_t
Read byte from port.
Definition io.hpp:160
static void writePort8(const port_t addr, const igros_byte_t value) noexcept
Write byte to port.
Definition io.hpp:178
static void install() noexcept
Install IRQ handler.
Definition irq.hpp:199
static void unmask(const irq_t number) noexcept
Unmask interrupt.
Definition irq.cpp:85
Bit flags of enum type.
Definition kFlags.hpp:29
static constexpr auto from(const U value) noexcept -> kFlags
From raw value (hardware register, table entry).
Definition kFlags.hpp:55
std::uint16_t igros_word_t
16-bit unsigned integer
Definition types.hpp:42
std::size_t igros_usize_t
Unsigned size.
Definition types.hpp:51
std::uint8_t igros_byte_t
8-bit unsigned integer
Definition types.hpp:41
std::uint32_t igros_dword_t
32-bit unsigned integer
Definition types.hpp:43
I/O operations.
Architecture interrupts type deduction.
Bit flags template datatype.
Kernel text print functions.
Kernel string functions.
SERIAL_IER
Interrupt enable register bits.
Definition serial.cpp:53
SERIAL_LSR
Line status register bits.
Definition serial.cpp:46
@ TX_IDLE
Holding and shift registers empty.
Definition serial.cpp:49
@ THR_EMPTY
Transmitter holding register empty.
Definition serial.cpp:48
SERIAL_MCR
Modem control register bits.
Definition serial.cpp:58
@ OUT2
Auxiliary output 2 (IRQ line enable on PC).
Definition serial.cpp:62
SERIAL_REG
Serial port registers (offsets from port base).
Definition serial.cpp:34
@ IIR
Interrupt identification (read) / FIFO control (write).
Definition serial.cpp:37
@ IER
Interrupt enable (DLAB = 0) / divisor high byte (DLAB = 1).
Definition serial.cpp:36
@ DATA
Data (DLAB = 0) / divisor low byte (DLAB = 1).
Definition serial.cpp:35
Architecture-independent interface: drivers and aliases of current architecture types.
auto serialWrite(const SERIAL_PORT port, const std::string_view text) noexcept -> igros_usize_t
Serial write.
Definition serial.cpp:242
static void serialInterruptHandler1(const register_t *const regs) noexcept
Serial #1 | #3 IRQ handler.
Definition serial.cpp:280
auto serialRead(const SERIAL_PORT port, const std::span< char > buffer) noexcept -> igros_usize_t
Serial read.
Definition serial.cpp:254
auto serialReadyWrite(const SERIAL_PORT port) noexcept -> bool
Is write ready?
Definition serial.cpp:181
static auto serialStatus(const SERIAL_PORT port) noexcept -> klib::kFlags< SERIAL_LSR >
Read line status register.
Definition serial.cpp:99
auto serialInit(const SERIAL_PORT port, const BAUD_RATE baudRate, const DATA_SIZE dataSize, const STOP_BITS stopBits, const PARITY parity) noexcept -> bool
Initialize serial port.
Definition serial.cpp:120
auto serialSetup() noexcept -> bool
Setup COM1 (115200 8N1) with receive interrupt.
Definition serial.cpp:298
static auto serialRegRead(const SERIAL_PORT port, const SERIAL_REG reg) noexcept -> igros_byte_t
Read serial port register.
Definition serial.cpp:91
BAUD_RATE
Baud rates.
Definition serial.hpp:37
STOP_BITS
Stop bits.
Definition serial.hpp:61
DATA_SIZE
Data size.
Definition serial.hpp:53
SERIAL_PORT
Serial ports (standard PC I/O bases).
Definition serial.hpp:29
static constexpr auto serialRegister(const SERIAL_PORT port, const SERIAL_REG reg) noexcept -> port_t
Serial port register address.
Definition serial.cpp:74
auto serialReadyRead(const SERIAL_PORT port) noexcept -> bool
Is read ready?
Definition serial.cpp:187
static auto serialGetSymbol(const SERIAL_PORT port, char &symbol) noexcept -> bool
Receive one symbol (only if available).
Definition serial.cpp:231
static auto serialWaitStatus(const SERIAL_PORT port, const SERIAL_LSR status) noexcept -> bool
Wait until line status bit is set (bounded, so missing UART can't hang the kernel).
Definition serial.cpp:108
PARITY
Parity.
Definition serial.hpp:68
static auto serialPutSymbol(const SERIAL_PORT port, const char symbol) noexcept -> bool
Send one symbol (new line is sent as CR LF).
Definition serial.cpp:219
static auto serialWaitWrite(const SERIAL_PORT port) noexcept -> bool
Wait until write ready.
Definition serial.cpp:195
static void serialRegWrite(const SERIAL_PORT port, const SERIAL_REG reg, const igros_byte_t value) noexcept
Write serial port register.
Definition serial.cpp:82
static auto serialPut(const SERIAL_PORT port, const igros_byte_t value) noexcept -> bool
Wait for transmitter and send one byte.
Definition serial.cpp:205
constexpr auto kstrview(const char *const src) noexcept -> std::string_view
View of null-terminated string (null pointer is empty string).
Definition kString.hpp:28
void kprintf(const char *const format,...) noexcept
Kernel printf function (arguments are checked against format at compile time).
Definition kPrint.cpp:358
constexpr auto make_kflags(const Args... flags) noexcept -> kFlags< T >
Flags creation helper function from set flags.
Definition kFlags.hpp:94
igros_word_t port_t
Define port data type which is 16bit word.
Definition io.hpp:25
UART driver.
x86_64 task switch registers save
Definition register.hpp:32