../14-checkpoint/Makefile

*Concepts you may want to Google beforehand: VGA character cells, screen offset*

**Goal: Write strings on the screen**

Finally, we are going to be able to output text on the screen. This lesson contains

a bit more code than usual, so let's go step by step.

Open `drivers/screen.h` and you'll see that we have defined some constants for the VGA

card driver and three public functions, one to clear the screen and another couple

to write strings, the famously named `kprint` for "kernel print"

Now open `drivers/screen.c`. It starts with the declaration of private helper functions

that we will use to aid our `kprint` kernel API.

There are the two I/O port access routines that we learned in the previous lesson,

`get` and `set_cursor_offset()`.

Then there is the routine that directly manipulates the video memory, `print_char()`

Finally, there are three small helper functions to transform rows and columns into offsets

and vice versa.

kprint_at

`kprint_at` may be called with a `-1` value for `col` and `row`, which indicates that

we will print the string at the current cursor position.

It first sets three variables for the col/row and the offset. Then it iterates through

the `char*` and calls `print_char()` with the current coordinates.

Note that `print_char` itself returns the offset of the next cursor position, and we reuse

it for the next loop.

`kprint` is basically a wrapper for `kprint_at`

print_char

Like `kprint_at`, `print_char` allows cols/rows to be `-1`. In that case it retrieves

the cursor position from the hardware, using the `ports.c` routines.

`print_char` also handles newlines. In that case, we will position the cursor offset

to column 0 of the next row.

Remember that the VGA cells take two bytes, one for the character itself and another one

for the attribute.

kernel.c

Our new kernel is finally able to print strings.

It tests correct character positioning, spanning through multiple lines, line breaks,

and finally it tries to write outside of the screen bounds. What happens then?

In the next lesson we will learn how to scroll the screen.

../14-checkpoint/boot

unsigned char port_byte_in (unsigned short port) {

unsigned char result;

/* Inline assembler syntax

__asm__("in %%dx, %%al" : "=a" (result) : "d" (port));

return result;

}

void port_byte_out (unsigned short port, unsigned char data) {

/* Notice how here both registers are mapped to C variables and

__asm__("out %%al, %%dx" : : "a" (data), "d" (port));

}

unsigned short port_word_in (unsigned short port) {

unsigned short result;

__asm__("in %%dx, %%ax" : "=a" (result) : "d" (port));

return result;

}

void port_word_out (unsigned short port, unsigned short data) {

__asm__("out %%ax, %%dx" : : "a" (data), "d" (port));

}

unsigned char port_byte_in (unsigned short port);

void port_byte_out (unsigned short port, unsigned char data);

unsigned short port_word_in (unsigned short port);

void port_word_out (unsigned short port, unsigned short data);

#include "screen.h"

#include "ports.h"

int get_cursor_offset();

void set_cursor_offset(int offset);

int print_char(char c, int col, int row, char attr);

int get_offset(int col, int row);

int get_offset_row(int offset);

int get_offset_col(int offset);

void kprint_at(char *message, int col, int row) {

/* Set cursor if col/row are negative */

int offset;

if (col >= 0 && row >= 0)

offset = get_offset(col, row);

else {

offset = get_cursor_offset();

row = get_offset_row(offset);

col = get_offset_col(offset);

}

/* Loop through message and print it */

int i = 0;

while (message[i] != 0) {

offset = print_char(message[i++], col, row, WHITE_ON_BLACK);

/* Compute row/col for next iteration */

row = get_offset_row(offset);

col = get_offset_col(offset);

}

}

void kprint(char *message) {

kprint_at(message, -1, -1);

}

int print_char(char c, int col, int row, char attr) {

unsigned char *vidmem = (unsigned char*) VIDEO_ADDRESS;

if (!attr) attr = WHITE_ON_BLACK;

/* Error control: print a red 'E' if the coords aren't right */

if (col >= MAX_COLS || row >= MAX_ROWS) {

vidmem[2*(MAX_COLS)*(MAX_ROWS)-2] = 'E';

vidmem[2*(MAX_COLS)*(MAX_ROWS)-1] = RED_ON_WHITE;

return get_offset(col, row);

}

int offset;

if (col >= 0 && row >= 0) offset = get_offset(col, row);

else offset = get_cursor_offset();

if (c == '\n') {

row = get_offset_row(offset);

offset = get_offset(0, row+1);

} else {

vidmem[offset] = c;

vidmem[offset+1] = attr;

offset += 2;

}

set_cursor_offset(offset);

return offset;

}

int get_cursor_offset() {

/* Use the VGA ports to get the current cursor position

port_byte_out(REG_SCREEN_CTRL, 14);

int offset = port_byte_in(REG_SCREEN_DATA) << 8; /* High byte: << 8 */

port_byte_out(REG_SCREEN_CTRL, 15);

offset += port_byte_in(REG_SCREEN_DATA);

return offset * 2; /* Position * size of character cell */

}

void set_cursor_offset(int offset) {

/* Similar to get_cursor_offset, but instead of reading we write data */

offset /= 2;

port_byte_out(REG_SCREEN_CTRL, 14);

port_byte_out(REG_SCREEN_DATA, (unsigned char)(offset >> 8));

port_byte_out(REG_SCREEN_CTRL, 15);

port_byte_out(REG_SCREEN_DATA, (unsigned char)(offset & 0xff));

}

void clear_screen() {

int screen_size = MAX_COLS * MAX_ROWS;

int i;

char *screen = VIDEO_ADDRESS;

for (i = 0; i < screen_size; i++) {

screen[i*2] = ' ';

screen[i*2+1] = WHITE_ON_BLACK;

}

set_cursor_offset(get_offset(0, 0));

}

int get_offset(int col, int row) { return 2 * (row * MAX_COLS + col); }

int get_offset_row(int offset) { return offset / (2 * MAX_COLS); }

int get_offset_col(int offset) { return (offset - (get_offset_row(offset)*2*MAX_COLS))/2; }

#define VIDEO_ADDRESS 0xb8000

#define MAX_ROWS 25

#define MAX_COLS 80

#define WHITE_ON_BLACK 0x0f

#define RED_ON_WHITE 0xf4

#define REG_SCREEN_CTRL 0x3d4

#define REG_SCREEN_DATA 0x3d5

void clear_screen();

void kprint_at(char *message, int col, int row);

void kprint(char *message);

#include "../drivers/screen.h"

void main() {

clear_screen();

kprint_at("X", 1, 6);

kprint_at("This text spans multiple lines", 75, 10);

kprint_at("There is a line\nbreak", 0, 20);

kprint("There is a line\nbreak");

kprint_at("What happens when we run out of space?", 45, 24);

}