[netwatch.git] / lib / console.c

/** @file console.c 
 *  @brief A console driver.
 *
 *  @author Joshua Wise (jwise) <joshua@joshuawise.com>
 *  @bug None known
 */

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