[netwatch.git] / lib / console.c

/* console.c 
 * A console driver.
 *
 * Copyright (c) 2008 Joshua Wise.  All rights reserved.
 * This program is free software; you can redistribute and/or modify it under
 * the terms found in the file LICENSE in the root of this source tree.
 *
 */

#include <console.h>
#include "console-ext.h"
#include <minilib.h>
#include <io.h>

#define POS_IS_VALID(row, col) ((row) >= 0 && (row) < CONSOLE_HEIGHT && (col) >= 0 && (col) < CONSOLE_WIDTH)

/** @brief A structure describing a console that is backed by memory.
 * 
 *  In the mode of designing for extensibility, all of the console driver's
 *  state is encapsulated in a 'struct console', which would ostensibly make
 *  it easier to create virtual consoles later.  All of the console driver's
 *  workings touch this struct; ideally, there are no references to
 *  CONSOLE_MEM_BASE or other hardware outside of this.  In practice, this
 *  isn't quite the case (see update_cursor()).... but we're close.
 */
struct console {
	int row;		/**< The current row. */
	int col;		/**< The current column. */
	unsigned char attr;	/**< The current color/attribute. */
	unsigned char *base;	/**< The current base to write data to.
				 *   Might not be equal to physbase if we're
				 *   in a different virtual console right
				 *   now or we have requested a backbuffer!
				 */
	unsigned char *physbase;	/**< The physical memory base for
					 *   this console.
					 */
	int showcursor;		/**< Whether the cursor should be shown
				 *   by update_cursor().
				 */
	int initialized;	/**< Whether the console has been
				 *   initialized. Functions should check
				 *   this and call clear_console() before
				 *   running if this is zero.
				 */
	int backbuffer;		/**< Whether we're currently writing to a
				 *   backbuffer instead of the physical
				 *   video memory.
				 */
};

/** @brief The structure describing the one console on the system. Should
 *         not be touched by anyone but the initializer for curcons!
 */
static struct console cons = {
	.row = 0,
	.col = 0,
	.attr = FGND_LGRAY,
	.base = (unsigned char *)CONSOLE_MEM_BASE,
	.physbase = (unsigned char *)CONSOLE_MEM_BASE,
	.showcursor = 1,
	.initialized = 0,
	.backbuffer = 0,
};

/** @brief The current console that all console.c operations work on. */
static struct console *curcons = &cons;

/** @brief Makes sure that the VGA cursor matches with the console.c's idea
 *         of where the cursor should be.
 *
 *  update_cursor would be trivial, but for a few important checks.  In
 *  particular, it won't touch the cursor at all if we're backbuffered
 *  (since that would make the cursor fly around a screen that isn't
 *  actually being updated), and if the cursor is hidden, it sets it to an
 *  out-of-bounds segment to make sure that it's actually hidden.
 */
static void update_cursor()
{
	if (curcons->backbuffer)
		return;
	if (curcons->showcursor)
	{
		unsigned short addr = (curcons->row * CONSOLE_WIDTH + curcons->col);
		outb(CRTC_IDX_REG, CRTC_CURSOR_MSB_IDX);
		outb(CRTC_DATA_REG, (addr >> 8));
		outb(CRTC_IDX_REG, CRTC_CURSOR_LSB_IDX);
		outb(CRTC_DATA_REG, addr & 0xFF);
	} else {
		outb(CRTC_IDX_REG, CRTC_CURSOR_MSB_IDX);
		outb(CRTC_DATA_REG, 255	/* invalid */);
		outb(CRTC_IDX_REG, CRTC_CURSOR_LSB_IDX);
		outb(CRTC_DATA_REG, 255	/* invalid */);
	}
}

/** @brief Redirects console writes to a backbuffer.
 *
 *  Verifies that the console is not already backbuffered.  If it's not, it
 *  allocates a backbuffer, copies the current console into the backbuffer,
 *  and sets the backbuffered flag.
 *
 *  This isn't just theoretical, by the way.  The game screen's timer causes
 *  it to repaint every frame (for lack of a better way to do it), which is
 *  fine in qemu (which is fast), but causes severe flicker in simics.  This
 *  backbuffering logic seems to have alleviated the flicker.
 *
 *  @see cons_debackbuffer
 */
/*void cons_backbuffer()
{
	if (!curcons->initialized)
		clear_console();
	if (curcons->backbuffer)
		return;
	curcons->base = malloc(CONSOLE_WIDTH * CONSOLE_HEIGHT * 2);
	memcpy(curcons->base, curcons->physbase, CONSOLE_WIDTH * CONSOLE_HEIGHT * 2);
	curcons->backbuffer = 1;
}*/

/** @brief Turns off the backbuffer.
 *
 *  Verifies that we are currently backbuffered.  If so, copies the
 *  backbuffer into video memory, frees the backbuffer, sets the pointer
 *  back to video memory, clears the backbuffered flag, and updates the
 *  hardware cursor.
 *
 *  @see cons_backbuffer
 */
/*void cons_debackbuffer()
{
	if (!curcons->initialized)
		clear_console();
	if (!curcons->backbuffer)
		return;
	memcpy(curcons->physbase, curcons->base, CONSOLE_WIDTH * CONSOLE_HEIGHT * 2);
	free(curcons->base);
	curcons->base = curcons->physbase;
	curcons->backbuffer = 0;
	update_cursor();
}*/

int putbyte(char ch)
{
	if (!curcons->initialized)
		clear_console();
	
	/* Make sure to handle special cases nicely.*/
	switch(ch)
	{
	case '\n':
		curcons->row++;
		if (curcons->row >= CONSOLE_HEIGHT)	/* Moving off the end? Scroll. */
		{
			int c;
			memmove(curcons->base, curcons->base + 2*CONSOLE_WIDTH, 2*CONSOLE_WIDTH*(CONSOLE_HEIGHT-1));
			curcons->row--;
			for (c=0; c<CONSOLE_WIDTH; c++)	/* Clear the newly blank bottom line. */
			{
				curcons->base[(curcons->row * CONSOLE_WIDTH + c) * 2] = ' ';
				curcons->base[(curcons->row * CONSOLE_WIDTH + c) * 2 + 1] = curcons->attr;
			}
		}
		// fall through
	case '\r':
		curcons->col = 0;
		update_cursor();
		break;
	case '\b':
		if (curcons->col)
		{
			curcons->col--;
			curcons->base[(curcons->row*CONSOLE_WIDTH + curcons->col) * 2] = ' ';
		}
		update_cursor();
		break;
	default:
		curcons->base[(curcons->row*CONSOLE_WIDTH + curcons->col) * 2] = ch;
		curcons->base[(curcons->row*CONSOLE_WIDTH + curcons->col) * 2 + 1] = curcons->attr;
		curcons->col++;
		if (curcons->col >= CONSOLE_WIDTH)
			putbyte('\n');
		update_cursor();
	}
	return ch;
}

void putbytes(const char *s, int len)
{
	if (!curcons->initialized)
		clear_console();
	
	while (len--)
		putbyte(*(s++));
}

int set_term_color(int color)
{
	if (!curcons->initialized)
		clear_console();
	
	curcons->attr = (unsigned char)color;
	return 0;
}

void get_term_color(int *color)
{
	if (!curcons->initialized)
		clear_console();
	
	*color = (int)curcons->attr;
}

int set_cursor(int row, int col)
{
	if (!curcons->initialized)
		clear_console();
	if (!POS_IS_VALID(row, col))
		return -1;
	curcons->row = row;
	curcons->col = col;
	update_cursor();
	return 0;
}

void get_cursor(int *row, int *col)
{
	if (!curcons->initialized)
		clear_console();
	*row = curcons->row;
	*col = curcons->col;
}

void hide_cursor()
{
	if (!curcons->initialized)
		clear_console();
	curcons->showcursor = 0;
	update_cursor();
}

void show_cursor()
{
	if (!curcons->initialized)
		clear_console();
	curcons->showcursor = 1;
	update_cursor();
}

void clear_console()
{
	int i;
	curcons->initialized = 1;
	curcons->row = 0;
	curcons->col = 0;
	for (i = 0; i < CONSOLE_WIDTH * CONSOLE_HEIGHT; i++)
	{
		curcons->base[i*2] = ' ';
		curcons->base[i*2+1] = FGND_LGRAY;
	}
	update_cursor();
}

void draw_char(int row, int col, int ch, int color)
{
	if (!POS_IS_VALID(row, col))
		return;
	curcons->base[2 * (CONSOLE_WIDTH * row + col)] = (unsigned char)ch;
	curcons->base[2 * (CONSOLE_WIDTH * row + col)+1] = (unsigned char)color;
}

char get_char(int row, int col)
{
	if (!POS_IS_VALID(row, col))
		return 0;
	return curcons->base[2 * (CONSOLE_WIDTH * row + col)];
}
Commit	Line	Data
3c4e084d JP	1	/* console.c
	2	* A console driver.
	3	*
	4	* Copyright (c) 2008 Joshua Wise. All rights reserved.
	5	* This program is free software; you can redistribute and/or modify it under
	6	* the terms found in the file LICENSE in the root of this source tree.
9b8c947b	7	*
9b8c947b JW	8	*/
	9
	10	#include <console.h>
	11	#include "console-ext.h"
36ce375d	12	#include <minilib.h>
9b8c947b JW	13	#include <io.h>
	14
	15	#define POS_IS_VALID(row, col) ((row) >= 0 && (row) < CONSOLE_HEIGHT && (col) >= 0 && (col) < CONSOLE_WIDTH)
	16
	17	/** @brief A structure describing a console that is backed by memory.
	18	*
	19	* In the mode of designing for extensibility, all of the console driver's
	20	* state is encapsulated in a 'struct console', which would ostensibly make
	21	* it easier to create virtual consoles later. All of the console driver's
	22	* workings touch this struct; ideally, there are no references to
	23	* CONSOLE_MEM_BASE or other hardware outside of this. In practice, this
	24	* isn't quite the case (see update_cursor()).... but we're close.
	25	*/
	26	struct console {
	27	int row; /*< The current row. /
	28	int col; /*< The current column. /
	29	unsigned char attr; /*< The current color/attribute. /
	30	unsigned char base; /*< The current base to write data to.
	31	* Might not be equal to physbase if we're
	32	* in a different virtual console right
	33	* now or we have requested a backbuffer!
	34	*/
	35	unsigned char physbase; /*< The physical memory base for
	36	* this console.
	37	*/
	38	int showcursor; /**< Whether the cursor should be shown
	39	* by update_cursor().
	40	*/
	41	int initialized; /**< Whether the console has been
	42	* initialized. Functions should check
	43	* this and call clear_console() before
	44	* running if this is zero.
	45	*/
	46	int backbuffer; /**< Whether we're currently writing to a
	47	* backbuffer instead of the physical
	48	* video memory.
	49	*/
	50	};
	51
	52	/** @brief The structure describing the one console on the system. Should
	53	* not be touched by anyone but the initializer for curcons!
	54	*/
	55	static struct console cons = {
	56	.row = 0,
	57	.col = 0,
	58	.attr = FGND_LGRAY,
	59	.base = (unsigned char *)CONSOLE_MEM_BASE,
	60	.physbase = (unsigned char *)CONSOLE_MEM_BASE,
	61	.showcursor = 1,
	62	.initialized = 0,
	63	.backbuffer = 0,
	64	};
	65
	66	/** @brief The current console that all console.c operations work on. */
	67	static struct console *curcons = &cons;
	68
	69	/** @brief Makes sure that the VGA cursor matches with the console.c's idea
	70	* of where the cursor should be.
	71	*
	72	* update_cursor would be trivial, but for a few important checks. In
	73	* particular, it won't touch the cursor at all if we're backbuffered
	74	* (since that would make the cursor fly around a screen that isn't
	75	* actually being updated), and if the cursor is hidden, it sets it to an
	76	* out-of-bounds segment to make sure that it's actually hidden.
77	*/
78	static void update_cursor()
79	{
80	if (curcons->backbuffer)
81	return;
82	if (curcons->showcursor)
83	{
84	unsigned short addr = (curcons->row * CONSOLE_WIDTH + curcons->col);
85	outb(CRTC_IDX_REG, CRTC_CURSOR_MSB_IDX);
86	outb(CRTC_DATA_REG, (addr >> 8));
87	outb(CRTC_IDX_REG, CRTC_CURSOR_LSB_IDX);
88	outb(CRTC_DATA_REG, addr & 0xFF);
89	} else {
90	outb(CRTC_IDX_REG, CRTC_CURSOR_MSB_IDX);
91	outb(CRTC_DATA_REG, 255 /* invalid */);
92	outb(CRTC_IDX_REG, CRTC_CURSOR_LSB_IDX);
93	outb(CRTC_DATA_REG, 255 /* invalid */);
94	}
95	}
96
97	/** @brief Redirects console writes to a backbuffer.
98	*
99	* Verifies that the console is not already backbuffered. If it's not, it
100	* allocates a backbuffer, copies the current console into the backbuffer,
101	* and sets the backbuffered flag.
102	*
103	* This isn't just theoretical, by the way. The game screen's timer causes
104	* it to repaint every frame (for lack of a better way to do it), which is
105	* fine in qemu (which is fast), but causes severe flicker in simics. This
106	* backbuffering logic seems to have alleviated the flicker.
107	*
108	* @see cons_debackbuffer
109	*/
110	/*void cons_backbuffer()
111	{
112	if (!curcons->initialized)
113	clear_console();
114	if (curcons->backbuffer)
115	return;
116	curcons->base = malloc(CONSOLE_WIDTH * CONSOLE_HEIGHT * 2);
117	memcpy(curcons->base, curcons->physbase, CONSOLE_WIDTH * CONSOLE_HEIGHT * 2);
118	curcons->backbuffer = 1;
119	}*/
120
121	/** @brief Turns off the backbuffer.
122	*
123	* Verifies that we are currently backbuffered. If so, copies the
124	* backbuffer into video memory, frees the backbuffer, sets the pointer
125	* back to video memory, clears the backbuffered flag, and updates the
126	* hardware cursor.
127	*
128	* @see cons_backbuffer
129	*/
130	/*void cons_debackbuffer()
131	{
132	if (!curcons->initialized)
133	clear_console();
134	if (!curcons->backbuffer)
135	return;
136	memcpy(curcons->physbase, curcons->base, CONSOLE_WIDTH * CONSOLE_HEIGHT * 2);
137	free(curcons->base);
138	curcons->base = curcons->physbase;
139	curcons->backbuffer = 0;
140	update_cursor();
141	}*/
142
143	int putbyte(char ch)
144	{
145	if (!curcons->initialized)
146	clear_console();
147
148	/* Make sure to handle special cases nicely.*/
149	switch(ch)
150	{
151	case '\n':
152	curcons->row++;
153	if (curcons->row >= CONSOLE_HEIGHT) /* Moving off the end? Scroll. */
154	{
155	int c;
156	memmove(curcons->base, curcons->base + 2CONSOLE_WIDTH, 2CONSOLE_WIDTH*(CONSOLE_HEIGHT-1));
157	curcons->row--;
158	for (c=0; c<CONSOLE_WIDTH; c++) /* Clear the newly blank bottom line. */
159	{
160	curcons->base[(curcons->row * CONSOLE_WIDTH + c) * 2] = ' ';
161	curcons->base[(curcons->row * CONSOLE_WIDTH + c) * 2 + 1] = curcons->attr;
162	}
163	}
164	// fall through
165	case '\r':
166	curcons->col = 0;
167	update_cursor();
168	break;
169	case '\b':
170	if (curcons->col)
171	{
172	curcons->col--;
173	curcons->base[(curcons->rowCONSOLE_WIDTH + curcons->col) 2] = ' ';
174	}
175	update_cursor();
176	break;
177	default:
178	curcons->base[(curcons->rowCONSOLE_WIDTH + curcons->col) 2] = ch;
179	curcons->base[(curcons->rowCONSOLE_WIDTH + curcons->col) 2 + 1] = curcons->attr;
180	curcons->col++;
181	if (curcons->col >= CONSOLE_WIDTH)
182	putbyte('\n');
183	update_cursor();
184	}
185	return ch;
186	}
187
188	void putbytes(const char *s, int len)
189	{
190	if (!curcons->initialized)
191	clear_console();
192
193	while (len--)
194	putbyte(*(s++));
195	}
196
197	int set_term_color(int color)
198	{
199	if (!curcons->initialized)
200	clear_console();
201
202	curcons->attr = (unsigned char)color;
203	return 0;
204	}
205
206	void get_term_color(int *color)
207	{
208	if (!curcons->initialized)
209	clear_console();
210
211	*color = (int)curcons->attr;
212	}
213
214	int set_cursor(int row, int col)
215	{
216	if (!curcons->initialized)
217	clear_console();
218	if (!POS_IS_VALID(row, col))
219	return -1;
220	curcons->row = row;
221	curcons->col = col;
222	update_cursor();
223	return 0;
224	}
225
226	void get_cursor(int row, int col)
227	{
228	if (!curcons->initialized)
229	clear_console();
230	*row = curcons->row;
231	*col = curcons->col;
232	}
233
234	void hide_cursor()
235	{
236	if (!curcons->initialized)
237	clear_console();
238	curcons->showcursor = 0;
239	update_cursor();
240	}
241
242	void show_cursor()
243	{
244	if (!curcons->initialized)
245	clear_console();
246	curcons->showcursor = 1;
247	update_cursor();
248	}
249
250	void clear_console()
251	{
252	int i;
253	curcons->initialized = 1;
254	curcons->row = 0;
255	curcons->col = 0;
256	for (i = 0; i < CONSOLE_WIDTH * CONSOLE_HEIGHT; i++)
257	{
258	curcons->base[i*2] = ' ';
259	curcons->base[i*2+1] = FGND_LGRAY;
260	}
261	update_cursor();
262	}
263
264	void draw_char(int row, int col, int ch, int color)
265	{
266	if (!POS_IS_VALID(row, col))
267	return;
268	curcons->base[2 * (CONSOLE_WIDTH * row + col)] = (unsigned char)ch;
269	curcons->base[2 * (CONSOLE_WIDTH * row + col)+1] = (unsigned char)color;
270	}
271
272	char get_char(int row, int col)
273	{
274	if (!POS_IS_VALID(row, col))
275	return 0;
276	return curcons->base[2 * (CONSOLE_WIDTH * row + col)];
277	}