path: root/kernel/cio.c

/*
** SCCS ID:	@(#)cio.c	2.10	1/22/25
**
** @file	cio.c
**
** @author	Warren R. Carithers
**
** Based on:  c_io.c 1.13 (Ken Reek, Jon Coles, Warren R. Carithers)
**
** Console I/O routines
**
**  This module implements a simple set of input and output routines
**  for the console screen and keyboard on the machines in the DSL.
**  Refer to the header file comments for complete details.
**
** Naming conventions:
**
**  Externally-visible functions have names beginning with the
**  characters "cio_".
**
*/

#include <cio.h>
#include <lib.h>
#include <support.h>
#include <x86/arch.h>
#include <x86/pic.h>
#include <x86/ops.h>

/*
** Bit masks for the lower five and eight bits of a value
*/
#define BMASK5 0x1f
#define BMASK8 0xff

/*
** Video parameters
*/
#define SCREEN_MIN_X 0
#define SCREEN_MIN_Y 0
#define SCREEN_X_SIZE 80
#define SCREEN_Y_SIZE 25
#define SCREEN_MAX_X (SCREEN_X_SIZE - 1)
#define SCREEN_MAX_Y (SCREEN_Y_SIZE - 1)

/*
** Video state
*/
static unsigned int scroll_min_x, scroll_min_y;
static unsigned int scroll_max_x, scroll_max_y;
static unsigned int curr_x, curr_y;
static unsigned int min_x, min_y;
static unsigned int max_x, max_y;

// pointer to input notification function
static void (*notify)(int);

#ifdef SA_DEBUG
#include <stdio.h>
#define cio_putchar putchar
#define cio_puts(x) fputs(x, stdout)
#endif

/*
** VGA definitions.
*/

// calculate the memory address of a specific character position
// within VGA memory
#define VIDEO_ADDR(x, y) \
	(unsigned short *)(VID_BASE_ADDR + 2 * ((y) * SCREEN_X_SIZE + (x)))

// port addresses
#define VGA_CTRL_IX_ADDR 0x3d4
#define VGA_CTRL_CUR_HIGH 0x0e // cursor location, high byte
#define VGA_CTRL_CUR_LOW 0x0f // cursor location, low byte
#define VGA_CTRL_IX_DATA 0x3d5

// attribute bits
#define VGA_ATT_BBI 0x80 // blink, or background intensity
#define VGA_ATT_BGC 0x70 // background color
#define VGA_ATT_FICS 0x80 // foreground intensity or char font select
#define VGA_ATT_FGC 0x70 // foreground color

// color selections
#define VGA_BG_BLACK 0x0000 // background colors
#define VGA_BG_BLUE 0x1000
#define VGA_BG_GREEN 0x2000
#define VGA_BG_CYAN 0x3000
#define VGA_BG_RED 0x4000
#define VGA_BG_MAGENTA 0x5000
#define VGA_BG_BROWN 0x6000
#define VGA_BG_WHITE 0x7000

#define VGA_FG_BLACK 0x0000 // foreground colors
#define VGA_FG_BLUE 0x0100
#define VGA_FG_GREEN 0x0200
#define VGA_FG_CYAN 0x0300
#define VGA_FG_RED 0x0400
#define VGA_FG_MAGENTA 0x0500
#define VGA_FG_BROWN 0x0600
#define VGA_FG_WHITE 0x0700

// color combinations
#define VGA_WHITE_ON_BLACK (VGA_FG_WHITE | VGA_BG_BLACK)
#define VGA_BLACK_ON_WHITE (VGA_FG_BLACK | VGA_BG_WHITE)

/*
** Internal support routines.
*/

/*
** setcursor: set the cursor location (screen coordinates)
*/
static void setcursor(void)
{
	unsigned addr;
	unsigned int y = curr_y;

	if (y > scroll_max_y) {
		y = scroll_max_y;
	}

	addr = (unsigned)(y * SCREEN_X_SIZE + curr_x);

	outb(VGA_CTRL_IX_ADDR, VGA_CTRL_CUR_HIGH);
	outb(VGA_CTRL_IX_DATA, (addr >> 8) & BMASK8);
	outb(VGA_CTRL_IX_ADDR, VGA_CTRL_CUR_LOW);
	outb(VGA_CTRL_IX_DATA, addr & BMASK8);
}

/*
** putchar_at: physical output to the video memory
*/
static void putchar_at(unsigned int x, unsigned int y, unsigned int c)
{
	/*
	** If x or y is too big or small, don't do any output.
	*/
	if (x <= max_x && y <= max_y) {
		unsigned short *addr = VIDEO_ADDR(x, y);

		/*
		** The character may have attributes associated with it; if
		** so, use those, otherwise use white on black.
		*/
		c &= 0xffff; // keep only the lower bytes
		if (c > BMASK8) {
			*addr = (unsigned short)c;
		} else {
			*addr = (unsigned short)c | VGA_WHITE_ON_BLACK;
		}
	}
}

/*
** Globally-visible support routines.
*/

/*
** Set the scrolling region
*/
void cio_setscroll(unsigned int s_min_x, unsigned int s_min_y,
				   unsigned int s_max_x, unsigned int s_max_y)
{
	scroll_min_x = bound(min_x, s_min_x, max_x);
	scroll_min_y = bound(min_y, s_min_y, max_y);
	scroll_max_x = bound(scroll_min_x, s_max_x, max_x);
	scroll_max_y = bound(scroll_min_y, s_max_y, max_y);
	curr_x = scroll_min_x;
	curr_y = scroll_min_y;
	setcursor();
}

/*
** Cursor movement in the scroll region
*/
void cio_moveto(unsigned int x, unsigned int y)
{
	curr_x = bound(scroll_min_x, x + scroll_min_x, scroll_max_x);
	curr_y = bound(scroll_min_y, y + scroll_min_y, scroll_max_y);
	setcursor();
}

/*
** The putchar family
*/
void cio_putchar_at(unsigned int x, unsigned int y, unsigned int c)
{
	if ((c & 0x7f) == '\n') {
		unsigned int limit;

		/*
		** If we're in the scroll region, don't let this loop
		** leave it. If we're not in the scroll region, don't
		** let this loop enter it.
		*/
		if (x > scroll_max_x) {
			limit = max_x;
		} else if (x >= scroll_min_x) {
			limit = scroll_max_x;
		} else {
			limit = scroll_min_x - 1;
		}
		while (x <= limit) {
			putchar_at(x, y, ' ');
			x += 1;
		}
	} else {
		putchar_at(x, y, c);
	}
}

#ifndef SA_DEBUG
void cio_putchar(unsigned int c)
{
	/*
	** If we're off the bottom of the screen, scroll the window.
	*/
	if (curr_y > scroll_max_y) {
		cio_scroll(curr_y - scroll_max_y);
		curr_y = scroll_max_y;
	}

	switch (c & BMASK8) {
	case '\n':
		/*
		** Erase to the end of the line, then move to new line
		** (actual scroll is delayed until next output appears).
		*/
		while (curr_x <= scroll_max_x) {
			putchar_at(curr_x, curr_y, ' ');
			curr_x += 1;
		}
		curr_x = scroll_min_x;
		curr_y += 1;
		break;

	case '\r':
		curr_x = scroll_min_x;
		break;

	default:
		putchar_at(curr_x, curr_y, c);
		curr_x += 1;
		if (curr_x > scroll_max_x) {
			curr_x = scroll_min_x;
			curr_y += 1;
		}
		break;
	}
	setcursor();
}
#endif

/*
** The puts family
*/
void cio_puts_at(unsigned int x, unsigned int y, const char *str)
{
	unsigned int ch;

	while ((ch = *str++) != '\0' && x <= max_x) {
		cio_putchar_at(x, y, ch);
		x += 1;
	}
}

#ifndef SA_DEBUG
void cio_puts(const char *str)
{
	unsigned int ch;

	while ((ch = *str++) != '\0') {
		cio_putchar(ch);
	}
}
#endif

/*
** Write a "sized" buffer (like cio_puts(), but no NUL)
*/
void cio_write(const char *buf, int length)
{
	for (int i = 0; i < length; ++i) {
		cio_putchar(buf[i]);
	}
}

void cio_clearscroll(void)
{
	unsigned int nchars = scroll_max_x - scroll_min_x + 1;
	unsigned int l;
	unsigned int c;

	for (l = scroll_min_y; l <= scroll_max_y; l += 1) {
		unsigned short *to = VIDEO_ADDR(scroll_min_x, l);

		for (c = 0; c < nchars; c += 1) {
			*to++ = ' ' | 0x0700;
		}
	}
}

void cio_clearscreen(void)
{
	unsigned short *to = VIDEO_ADDR(min_x, min_y);
	unsigned int nchars = (max_y - min_y + 1) * (max_x - min_x + 1);

	while (nchars > 0) {
		*to++ = ' ' | 0x0700;
		nchars -= 1;
	}
}

void cio_scroll(unsigned int lines)
{
	unsigned short *from;
	unsigned short *to;
	int nchars = scroll_max_x - scroll_min_x + 1;
	int line, c;

	/*
	** If # of lines is the whole scrolling region or more, just clear.
	*/
	if (lines > scroll_max_y - scroll_min_y) {
		cio_clearscroll();
		curr_x = scroll_min_x;
		curr_y = scroll_min_y;
		setcursor();
		return;
	}

	/*
	** Must copy it line by line.
	*/
	for (line = scroll_min_y; line <= scroll_max_y - lines; line += 1) {
		from = VIDEO_ADDR(scroll_min_x, line + lines);
		to = VIDEO_ADDR(scroll_min_x, line);
		for (c = 0; c < nchars; c += 1) {
			*to++ = *from++;
		}
	}

	for (; line <= scroll_max_y; line += 1) {
		to = VIDEO_ADDR(scroll_min_x, line);
		for (c = 0; c < nchars; c += 1) {
			*to++ = ' ' | 0x0700;
		}
	}
}

static int mypad(int x, int y, int extra, int padchar)
{
	while (extra > 0) {
		if (x != -1 || y != -1) {
			cio_putchar_at(x, y, padchar);
			x += 1;
		} else {
			cio_putchar(padchar);
		}
		extra -= 1;
	}
	return x;
}

static int mypadstr(int x, int y, char *str, int len, int width, int leftadjust,
					int padchar)
{
	int extra;

	if (len < 0) {
		len = strlen(str);
	}
	extra = width - len;
	if (extra > 0 && !leftadjust) {
		x = mypad(x, y, extra, padchar);
	}
	if (x != -1 || y != -1) {
		cio_puts_at(x, y, str);
		x += len;
	} else {
		cio_puts(str);
	}
	if (extra > 0 && leftadjust) {
		x = mypad(x, y, extra, padchar);
	}
	return x;
}

static void do_printf(int x, int y, char **f)
{
	char *fmt = *f;
	int *ap;
	char buf[12];
	char ch;
	char *str;
	int leftadjust;
	int width;
	int len;
	int padchar;

	/*
	** Get characters from the format string and process them
	*/

	ap = (int *)(f + 1);

	while ((ch = *fmt++) != '\0') {
		/*
		** Is it the start of a format code?
		*/

		if (ch == '%') {
			/*
			** Yes, get the padding and width options (if there).
			** Alignment must come at the beginning, then fill,
			** then width.
			*/

			leftadjust = 0;
			padchar = ' ';
			width = 0;

			ch = *fmt++;

			if (ch == '-') {
				leftadjust = 1;
				ch = *fmt++;
			}

			if (ch == '0') {
				padchar = '0';
				ch = *fmt++;
			}

			while (ch >= '0' && ch <= '9') {
				width *= 10;
				width += ch - '0';
				ch = *fmt++;
			}

			/*
			** What data type do we have?
			*/
			switch (ch) {
			case 'c':
				// ch = *( (int *)ap )++;
				ch = *ap++;
				buf[0] = ch;
				buf[1] = '\0';
				x = mypadstr(x, y, buf, 1, width, leftadjust, padchar);
				break;

			case 'd':
				// len = cvtdec( buf, *( (int *)ap )++ );
				len = cvtdec(buf, *ap++);
				x = mypadstr(x, y, buf, len, width, leftadjust, padchar);
				break;

			case 's':
				// str = *( (char **)ap )++;
				str = (char *)(*ap++);
				x = mypadstr(x, y, str, -1, width, leftadjust, padchar);
				break;

			case 'x':
				// len = cvthex( buf, *( (int *)ap )++ );
				len = cvthex(buf, *ap++);
				x = mypadstr(x, y, buf, len, width, leftadjust, padchar);
				break;

			case 'o':
				// len = cvtoct( buf, *( (int *)ap )++ );
				len = cvtoct(buf, *ap++);
				x = mypadstr(x, y, buf, len, width, leftadjust, padchar);
				break;

			case 'u':
				len = cvtuns(buf, *ap++);
				x = mypadstr(x, y, buf, len, width, leftadjust, padchar);
				break;
			}
		} else {
			/*
			** No - just print it normally.
			*/

			if (x != -1 || y != -1) {
				cio_putchar_at(x, y, ch);
				switch (ch) {
				case '\n':
					y += 1;
					/* FALL THRU */

				case '\r':
					x = scroll_min_x;
					break;

				default:
					x += 1;
				}
			} else {
				cio_putchar(ch);
			}
		}
	}
}

void cio_printf_at(unsigned int x, unsigned int y, char *fmt, ...)
{
	do_printf(x, y, &fmt);
}

void cio_printf(char *fmt, ...)
{
	do_printf(-1, -1, &fmt);
}

/*
** These are the "standard" IBM AT "Set 1" keycodes.
*/

static unsigned char scan_code[2][128] = { { // unshifted characters
											 /* 00-07 */ '\377',
											 '\033',
											 '1',
											 '2',
											 '3',
											 '4',
											 '5',
											 '6',
											 /* 08-0f */ '7',
											 '8',
											 '9',
											 '0',
											 '-',
											 '=',
											 '\b',
											 '\t',
											 /* 10-17 */ 'q',
											 'w',
											 'e',
											 'r',
											 't',
											 'y',
											 'u',
											 'i',
											 /* 18-1f */ 'o',
											 'p',
											 '[',
											 ']',
											 '\n',
											 '\377',
											 'a',
											 's',
											 /* 20-27 */ 'd',
											 'f',
											 'g',
											 'h',
											 'j',
											 'k',
											 'l',
											 ';',
											 /* 28-2f */ '\'',
											 '`',
											 '\377',
											 '\\',
											 'z',
											 'x',
											 'c',
											 'v',
											 /* 30-37 */ 'b',
											 'n',
											 'm',
											 ',',
											 '.',
											 '/',
											 '\377',
											 '*',
											 /* 38-3f */ '\377',
											 ' ',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 40-47 */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '7',
											 /* 48-4f */ '8',
											 '9',
											 '-',
											 '4',
											 '5',
											 '6',
											 '+',
											 '1',
											 /* 50-57 */ '2',
											 '3',
											 '0',
											 '.',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 58-5f */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 60-67 */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 68-6f */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 70-77 */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 78-7f */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377' },

										   { // shifted characters
											 /* 00-07 */ '\377',
											 '\033',
											 '!',
											 '@',
											 '#',
											 '$',
											 '%',
											 '^',
											 /* 08-0f */ '&',
											 '*',
											 '(',
											 ')',
											 '_',
											 '+',
											 '\b',
											 '\t',
											 /* 10-17 */ 'Q',
											 'W',
											 'E',
											 'R',
											 'T',
											 'Y',
											 'U',
											 'I',
											 /* 18-1f */ 'O',
											 'P',
											 '{',
											 '}',
											 '\n',
											 '\377',
											 'A',
											 'S',
											 /* 20-27 */ 'D',
											 'F',
											 'G',
											 'H',
											 'J',
											 'K',
											 'L',
											 ':',
											 /* 28-2f */ '"',
											 '~',
											 '\377',
											 '|',
											 'Z',
											 'X',
											 'C',
											 'V',
											 /* 30-37 */ 'B',
											 'N',
											 'M',
											 '<',
											 '>',
											 '?',
											 '\377',
											 '*',
											 /* 38-3f */ '\377',
											 ' ',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 40-47 */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '7',
											 /* 48-4f */ '8',
											 '9',
											 '-',
											 '4',
											 '5',
											 '6',
											 '+',
											 '1',
											 /* 50-57 */ '2',
											 '3',
											 '0',
											 '.',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 58-5f */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 60-67 */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 68-6f */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 70-77 */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 /* 78-7f */ '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377',
											 '\377' } };

/*
** Scan code masks
*/

// 'release' bit
#define REL_BIT 0x80
#define CODE_BITS 0x7f

#define IS_PRESS(c) (((c) & REL_BIT) == 0)
#define IS_RELEASE(c) (((c) & REL_BIT) != 0)

/*
** Scan codes for some special characters
*/

// escape code - followed by another code byte
#define SCAN_ESC 0xe0

// shift keys:  press, release
#define L_SHIFT_DN 0x2a
#define R_SHIFT_DN 0x36
#define L_SHIFT_UP 0xaa
#define R_SHIFT_UP 0xb6

// control keys
#define L_CTRL_DN 0x1d
#define L_CTRL_UP 0x9d

/*
** I/O communication constants
*/
#define KBD_DATA 0x60
#define KBD_STATUS 0x64
#define READY 0x1

/*
** Circular buffer for input characters.  Characters are inserted at
** next_space, and are removed at next_char.  Buffer is empty if
** these are equal.
*/
#define C_BUFSIZE 200

static char input_buffer[C_BUFSIZE];
static volatile char *next_char = input_buffer;
static volatile char *next_space = input_buffer;

static volatile char *increment(volatile char *pointer)
{
	if (++pointer >= input_buffer + C_BUFSIZE) {
		pointer = input_buffer;
	}
	return pointer;
}

static int input_scan_code(int code)
{
	static int shift = 0;
	static int ctrl_mask = BMASK8;
	int rval = -1;

	/*
	** Do the shift processing
	*/
	code &= BMASK8;
	switch (code) {
	case L_SHIFT_DN:
	case R_SHIFT_DN:
		shift = 1;
		break;

	case L_SHIFT_UP:
	case R_SHIFT_UP:
		shift = 0;
		break;

	case L_CTRL_DN:
		ctrl_mask = BMASK5;
		break;

	case L_CTRL_UP:
		ctrl_mask = BMASK8;
		break;

	default:
		/*
		** Process ordinary characters only on the press (to handle
		** autorepeat).  Ignore undefined scan codes.
		*/
		if (IS_PRESS(code)) {
			code = scan_code[shift][(int)code];
			if (code != '\377') {
				volatile char *next = increment(next_space);

				/*
				** Store character only if there's room
				*/
				rval = code & ctrl_mask;
				if (next != next_char) {
					*next_space = code & ctrl_mask;
					next_space = next;
				}
			}
		}
	}
	return (rval);
}

static void keyboard_isr(int vector, int code)
{
	int data = inb(KBD_DATA);
	int val = input_scan_code(data);

	// if there is a notification function, call it
	if (val != -1 && notify)
		notify(val);

	outb(PIC1_CMD, PIC_EOI);
}

int cio_getchar(void)
{
	char c;
	int interrupts_enabled = r_eflags() & EFL_IF;

	while (next_char == next_space) {
		if (!interrupts_enabled) {
			/*
			** Must read the next keystroke ourselves.
			*/
			while ((inb(KBD_STATUS) & READY) == 0) {
				;
			}
			(void)input_scan_code(inb(KBD_DATA));
		}
	}

	c = *next_char & BMASK8;
	next_char = increment(next_char);
	if (c != EOT) {
		cio_putchar(c);
	}
	return c;
}

int cio_gets(char *buffer, unsigned int size)
{
	char ch;
	int count = 0;

	while (size > 1) {
		ch = cio_getchar();
		if (ch == EOT) {
			break;
		}
		*buffer++ = ch;
		count += 1;
		size -= 1;
		if (ch == '\n') {
			break;
		}
	}
	*buffer = '\0';
	return count;
}

int cio_input_queue(void)
{
	int n_chars = next_space - next_char;

	if (n_chars < 0) {
		n_chars += C_BUFSIZE;
	}
	return n_chars;
}

/*
** Initialization routines
*/
void cio_init(void (*fcn)(int))
{
	/*
	** Screen dimensions
	*/
	min_x = SCREEN_MIN_X;
	min_y = SCREEN_MIN_Y;
	max_x = SCREEN_MAX_X;
	max_y = SCREEN_MAX_Y;

	/*
	** Scrolling region
	*/
	scroll_min_x = SCREEN_MIN_X;
	scroll_min_y = SCREEN_MIN_Y;
	scroll_max_x = SCREEN_MAX_X;
	scroll_max_y = SCREEN_MAX_Y;

	/*
	** Initial cursor location
	*/
	curr_y = min_y;
	curr_x = min_x;
	setcursor();

	/*
	** Notification function (or NULL)
	*/
	notify = fcn;

	/*
	** Set up the interrupt handler for the keyboard
	*/
	install_isr(VEC_KBD, keyboard_isr);
}

#ifdef SA_DEBUG
int main()
{
	cio_printf("%d\n", 123);
	cio_printf("%d\n", -123);
	cio_printf("%d\n", 0x7fffffff);
	cio_printf("%d\n", 0x80000001);
	cio_printf("%d\n", 0x80000000);
	cio_printf("x%14dy\n", 0x80000000);
	cio_printf("x%-14dy\n", 0x80000000);
	cio_printf("x%014dy\n", 0x80000000);
	cio_printf("x%-014dy\n", 0x80000000);
	cio_printf("%s\n", "xyz");
	cio_printf("|%10s|\n", "xyz");
	cio_printf("|%-10s|\n", "xyz");
	cio_printf("%c\n", 'x');
	cio_printf("|%4c|\n", 'y');
	cio_printf("|%-4c|\n", 'y');
	cio_printf("|%04c|\n", 'y');
	cio_printf("|%-04c|\n", 'y');
	cio_printf("|%3d|\n", 5);
	cio_printf("|%3d|\n", 54321);
	cio_printf("%x\n", 0x123abc);
	cio_printf("|%04x|\n", 20);
	cio_printf("|%012x|\n", 0xfedcba98);
	cio_printf("|%-012x|\n", 0x76543210);
}

int curr_x, curr_y, max_x, max_y;
#endif