*Concepts you may want to Google beforehand: 32-bit protected mode, VGA, video

memory*

**Goal: Print on the screen when on 32-bit protected mode**

32-bit mode allows us to use 32 bit registers and memory addressing

, protected memory, virtual memory and other advangades, but we will lose

BIOS interrupts and we'll need to code the GDT (more on this later)

In this lesson we will write a print string routine by directly manipulating

the VGA video memory instead of calling `int 0x10`. The VGA memory starts

at address `0xb8000` and it has a text mode which is useful to avoid

manipulating direct pixels.

The formula for accessing a specific character on the 80x25 grid is:

That is, every character uses 2 bytes (one for the ASCII, another for

color and such), and we see that the structure of the memory concatenates

rows.

Open `32bit-print.asm` to see the code. It will always print the string

on the top left of the screen, but soon we'll write higher level routines

to replace it.

Unfortunately we cannot yet call this routine from the bootloader, because

we still don't know how to write the GDT and enter protected mode. Once

you have understood the code, jump to the next lesson.

*Concepts you may want to Google beforehand: GDT*

**Goals: program the GDT**

Remember segmentation from lesson 6? The offset was left shifted

to address an extra level of indirection.

In 32-bit mode, segmentation works differently. Now, the offset becomes an

index to a segment descriptor (SD) in the GDT. This descriptor defines

the base address (32 bits), the size (20 bits) and some flags, like

readonly, permissions, etc. To add confusion, the data structures are split,

so open the os-dev.pdf file and check out the figure on page 34 or the

Wikipedia page for the GDT.

The easiest way to program the GDT is to define two segments, one for code

and another for data. These can overlap which means there is no memory protection,

but it's good enough to boot, we'll fix this later with a higher language.

As a curiosity, the first GDT entry must be `0x00` to make sure that the

programmer didn't make any mistakes managing addresses.

Furthermore, since the CPU needs to know how long the GDT is, we'll use

a meta structure called the "GDT descriptor" with the size (16b) and address

(32b) of our actual GDT.

Let's directly jump to the GDT code in assembly. Again, to understand

all the segment flags, refer to the os-dev.pdf document. The theory for

this lesson is quite complex.

In the next lesson we will make the switch to 32-bit protected mode

and test our code from these lessons.

%include "../05-bootsector-functions-strings/boot_sect_print.asm"

%include "../09-32bit-gdt/32bit-gdt.asm"

%include "../08-32bit-print/32bit-print.asm"

%include "32bit-switch.asm"

*Concepts you may want to Google beforehand: interrupts, pipelining*

**Goal: Enter 32-bit protected mode and test our code from previous lessons**

To jump into 32-bit mode:

1. Disable interrupts

2. Load our GDT

3. Set a bit on the CPU control register `cr0`

4. Flush the CPU pipeline by issuing a carefully crafted far jump

5. Update all the segment registers

6. Update the stack

7. Call to a well-known label which contains the first useful code in 32 bits

We will encapsulate this process on the file `32bit-switch.asm`. Open it

and take a look at the code.

After entering 32-bit mode, we will call `BEGIN_PM` which is the entry point

for our actual useful code (e.g. kernel code, etc). You can read the code

at `32bit-main.asm`. Compile and run this last file and you will see the two

messages on the screen.

Congratulations! Our next step will be to write a simple kernel