Subversion Repositories s80186

// Copyright Jamie Iles, 2017
//
// This file is part of s80x86.
//
// s80x86 is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// s80x86 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with s80x86.  If not, see <http://www.gnu.org/licenses/>.
 
#include "bios.h"
#include "serial.h"
#include "io.h"
 
static const unsigned frame_buffer_segment = 0xb000;
static const unsigned frame_buffer_offset = 0x8000;
 
union cursor {
    struct {
        unsigned char col;
        unsigned char row;
    } c;
    unsigned short v;
};
 
static void noinline crtc_reg_write(unsigned char reg, unsigned char val)
{
    outb(0x3d4, reg);
    outb(0x3d5, val);
}
 
static unsigned char noinline crtc_reg_read(unsigned char reg)
{
    outb(0x3d4, reg);
 
    return inb(0x3d5);
}
 
static void noinline read_cursor(union cursor *c)
{
    unsigned short pos;
 
    pos = (unsigned short)crtc_reg_read(0xe) << 8;
    pos |= crtc_reg_read(0xf);
 
    c->c.row = pos / 80;
    c->c.col = pos % 80;
}
 
static void noinline write_cursor(union cursor *c)
{
    unsigned short pos = (unsigned short)c->c.row * 80 + c->c.col;
 
    crtc_reg_write(0xe, pos >> 8);
    crtc_reg_write(0xf, pos);
 
    bda_write(cursor_offsets[0], c->v);
}
 
static void noinline clear_row(unsigned char row,
                               unsigned char col_left,
                               unsigned char col_right,
                               unsigned char attr)
{
    unsigned char col;
    const signed short blank = ((signed short)attr << 8) | 0x20;
 
    for (col = col_left; col <= col_right; ++col)
        writew(frame_buffer_segment, frame_buffer_offset + (row * 80 + col) * 2,
               blank);
}
 
static void noinline copy_row(unsigned char dst_row,
                              unsigned char src_row,
                              unsigned char col_left,
                              unsigned char col_right,
                              unsigned char attr)
{
    unsigned char col;
 
    for (col = col_left; col <= col_right; ++col) {
        unsigned short b =
            readw(frame_buffer_segment,
                  frame_buffer_offset + (src_row * 80 + col) * 2);
        writew(frame_buffer_segment,
               frame_buffer_offset + (dst_row * 80 + col) * 2, b);
    }
}
 
void __scroll_up(signed char row_top,
                 signed char row_bottom,
                 signed char col_left,
                 signed char col_right,
                 signed char blank_attr,
                 signed char scroll_count)
{
    signed char row;
 
    for (row = row_top; row <= row_bottom; ++row) {
        if (row + scroll_count > row_bottom)
            clear_row(row, col_left, col_right, blank_attr);
        else
            copy_row(row, row + scroll_count, col_left, col_right, blank_attr);
    }
}
 
void noinline scroll_up(union cursor *cursor, struct callregs *regs)
{
    signed char row_top = regs->cx.h;
    signed char row_bottom = regs->dx.h;
    signed char col_left = regs->cx.l;
    signed char col_right = regs->dx.l;
    signed char blank_attr = regs->bx.h;
    signed char scroll_count = regs->ax.l == 0 ? 25 : regs->ax.l;
 
    __scroll_up(row_top, row_bottom, col_left, col_right, blank_attr,
                scroll_count);
}
 
static void __scroll_down(signed char row_top,
                          signed char row_bottom,
                          signed char col_left,
                          signed char col_right,
                          signed char blank_attr,
                          signed char scroll_count)
{
    signed char row;
 
    for (row = row_bottom; row >= row_top; --row) {
        if (row - scroll_count < 0)
            clear_row(row, col_left, col_right, blank_attr);
        else
            copy_row(row, row - scroll_count, col_left, col_right, blank_attr);
    }
}
 
void noinline scroll_down(union cursor *cursor, struct callregs *regs)
{
    signed char row_top = regs->cx.h;
    signed char row_bottom = regs->dx.h;
    signed char col_left = regs->cx.l;
    signed char col_right = regs->dx.l;
    signed char blank_attr = regs->bx.h;
    signed char scroll_count = regs->ax.l == 0 ? 25 : regs->ax.l;
 
    __scroll_down(row_top, row_bottom, col_left, col_right, blank_attr,
                  scroll_count);
}
 
void noinline scroll_up_one(void)
{
    __scroll_up(0, 24, 0, 79, 0x07, 1);
}
 
static void do_backspace(union cursor *cursor)
{
    int i;
 
    for (i = 0; i < 2 && cursor->c.col > 0; ++i) {
        --cursor->c.col;
        writeb(frame_buffer_segment,
               frame_buffer_offset + (cursor->c.row * 80 + cursor->c.col) * 2,
               ' ');
    }
}
 
static void noinline emit_char(char c)
{
    union cursor cursor;
 
    read_cursor(&cursor);
 
    writeb(frame_buffer_segment,
           frame_buffer_offset + (cursor.c.row * 80 + cursor.c.col) * 2, c);
    ++cursor.c.col;
 
    if (c == '\b')
        do_backspace(&cursor);
 
    if (c == '\r' || c == '\n') {
        unsigned m = 0;
        --cursor.c.col;
        for (m = cursor.c.col; m < 80; ++m)
            writew(frame_buffer_segment,
                   frame_buffer_offset + (cursor.c.row * 80 + m) * 2, 0x0720);
    }
 
    if (cursor.c.col == 80 || c == '\n') {
        cursor.c.col = 0;
        ++cursor.c.row;
    }
 
    if (cursor.c.row >= 25) {
        scroll_up_one();
        cursor.c.row = 24;
    }
    write_cursor(&cursor);
}
 
static void read_char(struct callregs *regs)
{
    union cursor cursor;
 
    read_cursor(&cursor);
    regs->ax.x =
        readw(frame_buffer_segment,
              frame_buffer_offset + (cursor.c.row * 80 + cursor.c.col) * 2);
    write_cursor(&cursor);
}
 
static void write_char_and_attribute(struct callregs *regs)
{
    union cursor cursor;
 
    read_cursor(&cursor);
    unsigned short v = ((unsigned short)regs->bx.l << 8) | regs->ax.l;
    writew(frame_buffer_segment,
           frame_buffer_offset + (cursor.c.row * 80 + cursor.c.col) * 2, v);
}
 
void video_putchar(char c)
{
    if (c == '\r')
        return;
 
    emit_char(c);
}
 
static void write_char(struct callregs *regs)
{
    putchar(regs->ax.l);
}
 
static void set_cursor(struct callregs *regs)
{
    union cursor cursor;
 
    read_cursor(&cursor);
    cursor.c.col = regs->dx.l;
    cursor.c.row = regs->dx.h;
    write_cursor(&cursor);
}
 
static void get_cursor(struct callregs *regs)
{
    union cursor cursor;
 
    read_cursor(&cursor);
    regs->cx.h = bda_read(cursor_start);
    regs->cx.l = bda_read(cursor_end);
    regs->dx.h = cursor.c.row;
    regs->dx.l = cursor.c.col;
    write_cursor(&cursor);
}
 
static void noinline set_cursor_scan_start(unsigned char scan_start)
{
    // Cursor disabled requested
    if (scan_start & 0x20)
        scan_start = 0x10 | (scan_start & 0xf);
    crtc_reg_write(0xa, scan_start);
}
 
static void noinline set_cursor_scan_end(unsigned char scan_end)
{
    crtc_reg_write(0xb, scan_end);
}
 
static void noinline set_cursor_bda(unsigned char scan_start,
                                    unsigned char scan_end)
{
    bda_write(cursor_start, scan_start);
    bda_write(cursor_end, scan_end);
}
 
static void noinline __set_cursor_shape(unsigned char scan_start,
                                        unsigned char scan_end)
{
    set_cursor_scan_end(scan_end);
    set_cursor_scan_start(scan_start);
 
    set_cursor_bda(scan_start, scan_end);
}
 
static void noinline set_cursor_shape(struct callregs *regs)
{
    unsigned char scan_start = regs->cx.h;
    unsigned char scan_end = regs->cx.l;
 
    __set_cursor_shape(scan_start, scan_end);
}
 
static void get_video_mode(struct callregs *regs)
{
    regs->ax.h = 80;
    regs->ax.l = 0x03;
    regs->bx.h = 0;
}
 
static void video_services(struct callregs *regs)
{
    union cursor cursor;
    regs->flags &= ~CF;
 
    switch (regs->ax.h) {
    case 0xe: write_char(regs); break;
    case 0x2: set_cursor(regs); break;
    case 0x3: get_cursor(regs); break;
    case 0x1: set_cursor_shape(regs); break;
    case 0x6:
        read_cursor(&cursor);
        scroll_up(&cursor, regs);
        write_cursor(&cursor);
        break;
    case 0x7:
        read_cursor(&cursor);
        scroll_down(&cursor, regs);
        write_cursor(&cursor);
        break;
    case 0xf: get_video_mode(regs); break;
    case 0x9: write_char_and_attribute(regs); break;
    case 0x8: read_char(regs); break;
    default: regs->flags |= CF;
    }
}
VECTOR(0x10, video_services);
 
void display_init(void)
{
    unsigned r, c;
 
    for (r = 0; r < 25; ++r)
        for (c = 0; c < 80; ++c)
            writew(frame_buffer_segment, frame_buffer_offset + (r * 80 + c) * 2,
                   0x0720);
 
    bda_write(video_mode, 0x03);
    bda_write(num_screen_cols, 80);
    bda_write(last_screen_row, 25 - 1);
    bda_write(crt_controller_base, 0x3d4);
 
    __set_cursor_shape(7, 7);
 
    union cursor cursor;
    cursor.c.col = cursor.c.row = 0;
    write_cursor(&cursor);
}