path: root/main/common/fbi.c

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 * 
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************
 *
 * fbi.c:
 *
 * Frame Buffer Interface...
 * This file started out as a simple means to transfer a .bmp formatted
 * file onto a framebuffer.  It has since expanded into what I think is a
 * pretty complete set of frame-buffer utilities to run in both pixel mode
 * (for images) and console mode (for text).
 * As of this writing, pixel mode allows the user to display raw frame-buffer
 * images or 24-bit RGB .bmp formatted images.  In console mode, the font
 * rendering supports variable size fonts (using one font file) and console
 * scrolling using a dual-buffer algorithm.
 * 
 *****
 *
 * Configuration:
 * If you're hardware has a frame buffer interface (typically, this will be
 * an LCD, but doesn't have to be), then do the following:
 * 
 *	- provide the basic initialization code for the framebuffer
 *	  device: void fbdev_init(void), which will be called by uMon
 *	  startup code automatically.
 *
 *	- establish these three macros as per your device's specifications...
 *	  PIXELS_PER_COL	(height of framebuffer device)
 *	  PIXELS_PER_ROW	(height of framebuffer device)
 *	  FRAME_BUFFER_BASE_ADDR	(starting point of the frame-buffer memory)
 *
 *  - establish one (and only one) of the following to be 1, with all
 *	  others being 0:
 *	  PIXFMT_IS_RGB565
 *	  PIXFMT_IS_RGB555
 *
 *	  (as of this writing only 16-bit color depth RGB565/RGB555 has been
 *	   tested).
 *
 *	- set INCLUDE_FBI to 1 in the config.h file;
 *	- add font.c and fbi.c to the common files list in your makefile;
 *  - to support more efficient consolemode screen scrolling, optionally
 *	  set FBDEV_SETSTART to the name of a function in the driver that
 *	  when called, will re-establish the base address of the frame
 *	  buffer memory using the 'addr' value provided.
 *  - the console mode feature includes a blinking cursor.  To build without
 *    the cursor, add...
 *       #define FBI_NO_CURSOR
 *    to your config.h file.
 *
 *****
 *
 * Startup:
 * At startup, the target can come up in console mode or pixel mode
 * based on the presence of a splash image.  The function fbi_splash()
 * is called and it will look for a few different filenames (see function
 * below).  If a splash image is found, it is dumped to the frame buffer
 * and the system will start up in pixel mode.  If a splash image is not
 * found, then the system will come up in console mode, meaning that all
 * characters typed at the serial port will be printed out the frame buffer
 * device.
 *
 *****
 *
 * Acknowledgements:
 * I got the majority of my information regarding the format of the BMP
 * file from Wikipedia (http://en.wikipedia.org/wiki/BMP_file_format).
 * I got the basic idea for the scrolling algorithm out of code from
 * one of Cogent's LCD drivers.  Also, the file font.c has one font that
 * I tediously created by hand (kinda ugly), and one that I got from Cogent.
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */

#include "config.h"
#if INCLUDE_FBI
#include "cpuio.h"
#include "genlib.h"
#include "cli.h"
#include "tfs.h"
#include "tfsprivate.h"
#include "warmstart.h"
#include "font.h"
#include "fbi.h"
#include "timer.h"

/* FBI_DEBUG:
 * Primarily used for debugging the fb_scroll() algorithm...
 */
//#define FBI_DEBUG

#ifdef FBDEV_SETSTART
extern void FBDEV_SETSTART(long addr);
#endif

/* PIXELS_PER_ROW, PIXELS_PER_COL and LCD_BUF_ADD are assumed to be
 * defined in cpuio.h...
 */
#define SCREEN_WIDTH	PIXELS_PER_ROW
#define SCREEN_HEIGHT	PIXELS_PER_COL
#define FB_BASE		((unsigned long)FRAME_BUFFER_BASE_ADDR)

#define RED(val) 	(char)((val & 0x00ff0000) >> 16)
#define GREEN(val) 	(char)((val & 0x0000ff00) >> 8)
#define BLUE(val) 	(char)((val & 0x000000ff))

#define FILLTYPE_BOX	1
#define FILLTYPE_COLOR	2

#define BOX_XSIZE 10
#define BOX_YSIZE 10

#define DEFAULT_FG_COLOR 0x00f0f0f0
#define DEFAULT_BG_COLOR 0x00101010

#if PIXFMT_IS_RGB565
#define fbtype		unsigned short
#define FB_GRAY		0x632c
#define FB_WHITE	0xffff
#define FB_BLACK	0x0821
#elif PIXFMT_IS_RGB555
# warning: pixel format RGB555 not yet tested
#define fbtype		unsigned short
#define FB_GRAY		0x318c
#define FB_WHITE	0xffff
#define FB_BLACK	0x0421
#else
# error: unknown pixel format
#endif

#define FB_SIZE		(SCREEN_WIDTH * SCREEN_HEIGHT * sizeof(fbtype))
#define FB_END		(FB_BASE + FB_SIZE)

struct bmpstuff {
	unsigned long	size;
	unsigned long	offset;
	unsigned long	hdrsz;
	unsigned long	width;
	unsigned long	height;
	unsigned short	planes;
	unsigned short	bpp;
	unsigned long	cprs;
	unsigned long	rawsize;
	unsigned long	hrez;
	unsigned long	vrez;
	unsigned long	palettesiz;
	unsigned long	impcol;
};

/* Whenever color is represented where it will be stored in the frame buffer
 * but also queriable by the user, we store the RGB value and the FBTYPE
 * value because once converted to the FBTYPE, it doesn't necessarily 
 * convert directly back to the original RGB value it was derived from.
 */
struct fbicolor {
	fbtype	fbval;
	long	rgbval;
};

void fbi_cursor_clear(void);
void fbi_consolemode_enable(int enable, int fbinit);

static	struct bmpstuff bmpinfo;
static	struct fbicolor font_fgcolor, font_bgcolor;
static	int font_totalcharheight, font_totalcharwidth, font_linemodulo;
static	int font_rowsperscreen, font_colsperscreen, font_scrolltot;
static	int font_style, font_xscale, font_yscale, font_xpos, font_ypos;
static	fbtype *fbi_cursorpos;
static	char fbi_linewrap, fbi_cursorstate;
static	char fbi_consolemode_enabled, font_initialized, font_is_opaque;

/* ecl() & ecs:
 * The .bmp file is inherently Windows/Intel-ish.  As a result, all integers
 * in that file are little endian.  These functions automatically convert
 * as needed...
 *
 * If this host is little endian, just return the value; else do the
 * endian swap and return.
 */
unsigned long
ecl(unsigned long val)
{
	short tval = 1;
	char *tp;

	tp = (char *)&tval;
	if (*tp == 1) {
		return(val);
	}
	else {
		return((( val & 0x000000ff) << 24) |
				((val & 0x0000ff00) << 8) |
				((val & 0x00ff0000) >> 8) |
				((val & 0xff000000) >> 24));
	}
}

unsigned short
ecs(unsigned short val)
{
	short tval = 1;
	char *tp;

	tp = (char *)&tval;
	if (*tp == 1) {
		return(val);
	}
	else {
		return(((val & 0x00ff) << 8) | ((val & 0xff00) >> 8));
	}
}

/* rgb_to_fb() / fb_to_rgb():
 * Convert 24-bit RGB to (or from) whatever the frame buffer type is...
 */

#if PIXFMT_IS_RGB565
/* Assume incoming RGB values 8-bits each (24-bit RGB).
 * Convert that to 16-bit RGB565 format (5-bit red, 6-bit grn, 5-bit blue).
 */
fbtype
rgb_to_fb(long rgb)
{
	char red, grn, blue;

	red = RED(rgb);
	grn = GREEN(rgb);
	blue = BLUE(rgb);

	return(((short)(red >> 3) << 11) |
		   ((short)(grn >> 2) << 5) | (short)(blue >> 3)); 
}

#elif PIXFMT_IS_RGB555

/* Assume incoming RGB values 8-bits each (24-bit RGB).
 * Convert that to 16-bit RGB555 format (5-bit red, 5-bit grn, 5-bit blue).
 * (NOT READY YET)
 */
fbtype
rgb_to_fb(long rgb)
{
	unsigned long red, green, blue;

	red =   ((fbval & 0xf800) >> 11);
	green = ((fbval & 0x07e0) >> 5);
	blue =   (fbval & 0x001f);

	return(((short)(red >> 3) << 10) |
		   ((short)(grn >> 5) << 5) | (short)(blue >> 3)); 
}

#endif

/* fb_memset():
 * A version of memset that is written to efficiently populate the frame
 * buffer with a value of type fbtype.  The incoming total is assumed to
 * be in fbtype units.
 */
void
fb_memset(fbtype *dest, fbtype val, int tot)
{
	/* If the size of a framebuffer element is half the size of a long,
	 * then we can double up the memory fill by populating one long value
	 * with two framebuffer fill values (one being shifted left 16)...
	 */
	if (sizeof(fbtype) == sizeof(unsigned long)/2) {
		unsigned long l_val, *l_fp, *l_end;

		l_val = (unsigned long)val;
		l_val <<= 16;
		l_val |= (unsigned long)val;
		l_fp = (unsigned long *)dest;
		l_end = (unsigned long *)(dest+tot);
		while(l_fp < l_end)
			*l_fp++ = l_val;
		
	}
	/* Otherwise, we just do an fbtype-oriented memset...
	 */
	else {
		fbtype *end = dest+tot;

		while(dest < end)
			*dest++ = val;
	}
}

void
fb_memcpy(fbtype *dest, fbtype *src, int tot)
{
	/* If the size of a framebuffer element is half the size of a long,
	 * then we can double up the memory fill by populating one long value
	 * with two framebuffer fill values (one being shifted left 16)...
	 */
	if (sizeof(fbtype) == sizeof(unsigned long)/2) {
		unsigned long *l_dest, *l_src, *l_end;

		l_dest = (unsigned long *)dest;
		l_src = (unsigned long *)src;
		l_end = (unsigned long *)(dest+tot);
		while(l_dest < l_end)
			*l_dest++ = *l_src++;
		
	}
	/* Otherwise, we just do an fbtype-oriented memcpy...
	 */
	else {
		fbtype *end = dest+tot;

		while(dest < end)
			*dest++ = *src++;
	}
}

void
font_defaults(void)
{
	struct font *fontp;

	if (font_initialized)
		return;

	font_xpos = 0;
	font_ypos = 0;
	font_style = 1;
	font_xscale = 1;
	font_yscale = 1;
	font_scrolltot = 0;
	font_fgcolor.rgbval = DEFAULT_FG_COLOR;
	font_fgcolor.fbval = rgb_to_fb(font_fgcolor.rgbval);
	font_bgcolor.rgbval = DEFAULT_BG_COLOR;
	font_bgcolor.fbval = rgb_to_fb(font_bgcolor.rgbval);
	font_is_opaque = 1;
	fbi_linewrap = 0;
	fbi_cursorstate = 0;
	fbi_cursorpos = 0;

	fontp = &font_styles[font_style];
	font_totalcharheight = ((fontp->height + fontp->above + fontp->below) *
		font_yscale);
	font_totalcharwidth = ((fontp->width + fontp->between) * font_xscale);
	font_rowsperscreen = SCREEN_HEIGHT / font_totalcharheight;
	font_colsperscreen = SCREEN_WIDTH / font_totalcharwidth;
	font_linemodulo = SCREEN_HEIGHT % font_totalcharheight;
	font_initialized = 1;
}


/* fb_scroll():
 * This could be done with a simple memory-to-memory transfer which copies
 * row 2 to row 1, row 3 to row 2, etc... all the way down the screen.
 * However, this would be *really* slow, so an alternative solution is
 * used that takes advantage of the fact that we can adjust which portion
 * of memory is looked at by the DMA engine connected to the device that is
 * actually displaying the pixels (typically this will be an LCD).
 *
 * Consider the double buffer here, with the start of the second buffer
 * being adjacent to the end of the first buffer...
 *
 *             --------------------------- 
 *             |                        -|        *
 *             |                         |        *
 *             |                         |        *
 *             |                         |        *
 *          ___|                        -|___     *
 *             |                         |
 *             |                         |
 *             |                         |
 *             |                         |
 *             |                         |
 *             ---------------------------
 *
 * For the sake of this discussion, assume each buffer deals with five
 * lines of text.  Also, initially the visible portion of the frame 
 * buffer aligns with the top buffer (note the asterisks to the right).
 * As text is typed, each character is put into both buffers...
 * 
 *             --------------------------- 
 *             | text for line 1        -|        *
 *             | another line here       |        *
 *             | another line is here    |        *
 *             | this is the fourth line |        *
 *          ___| and this is line five  -|___     *
 *             | text for line 1         |
 *             | another line here       |
 *             | another line is here    |
 *             | this is the fourth line |
 *             | and this is line five   |
 *             ---------------------------
 *
 * Up to this point, the viewing window has not changed. 
 * The next line of text is simply placed at the top of both of the
 * buffers, just like a circular queue...
 * 
 *             --------------------------- 
 *             | this is now line #6     |      
 *             | another line here      -|        *
 *             | another line is here    |        *
 *             | this is the fourth line |        *
 *          ___| and this is line five   |___     *
 *             | this is now line #6    -|        *
 *             | another line here       |
 *             | another line is here    |
 *             | this is the fourth line |
 *             | and this is line five   |
 *             ---------------------------
 *
 * The only added trick now is that the viewing window is shifted down
 * one row; thus, giving the appearance of a single line scroll, but without
 * the memcpy overhead.
 * Then, continuing with this, when the viewing window gets to the bottom
 * of the second buffer as shown below...
 * 
 *             --------------------------- 
 *             | this is now line #6     |      
 *             | line seven              |
 *             | this would be line 8    |
 *             | and nine...             |
 *          ___| this is line ten        |___
 *             | this is now line #6    -|        *
 *             | line seven              |        *
 *             | this would be line 8    |        *
 *             | and nine...             |        *
 *             | this is line ten       -|        *
 *             ---------------------------
 *
 * the next "scroll" would simply put to one line from the top...
 * 
 *             --------------------------- 
 *             | eleventh line now       |
 *             | line seven             -|       *
 *             | this would be line 8    |       *
 *             | and nine...             |       *
 *          ___| this is line ten        |___    *
 *             | eleventh line now      -|       *
 *             | line seven              |
 *             | this would be line 8    |
 *             | and nine...             |
 *             | this is line ten        |
 *             ---------------------------
 *
 * One 'gotcha' that I discovered (and fixed) with this algorithm is that
 * it only works perfectly if the character height of the font divides
 * evenly into the height of the visible frame.  If this is not the case,
 * then as the lines are scrolling, there will be a larger gap between
 * one line and the next as each 'N' lines scroll by (where 'N' is the nuber
 * of lines that can fit on the screen.
 * To get around this problem, when the font is first established I determine
 * what the modulo is between the character height and the screen height.
 * Then for each character-oriented line generated I insert one extra pixel
 * oriented line until the modulo reaches zero.  This simply distributes the
 * extra space across each of the lines and only one pixel (at most) of 
 * difference is visible.
 * In short, the font_linemodulo value is the number of character-lines that
 * need to have one additional pixel added to their height so that the final
 * character-line is at the very bottom of the screen.
 */

void
fb_erase_line(int lno)
{
	int linesize, linesize1;
	fbtype	*dest, *end, *dest1;
#ifdef FBI_DEBUG
	int erasetype;
#endif

	linesize = SCREEN_WIDTH * font_totalcharheight;

	if (font_linemodulo == 0) {
		dest = (fbtype *)(FB_BASE + (lno * linesize * sizeof(fbtype)));
		end = dest + linesize;
#ifdef FBI_DEBUG
		erasetype = 0;
#endif
	}
	else {
		linesize1 = linesize + SCREEN_WIDTH;

		if (lno < font_linemodulo) {
			dest = (fbtype *)(FB_BASE + (lno * linesize1 * sizeof(fbtype)));
			end = dest + linesize1;
#ifdef FBI_DEBUG
			erasetype = 1;
#endif
		}
		else if (lno == font_linemodulo) {
			dest = (fbtype *)(FB_BASE + (lno * linesize1 * sizeof(fbtype)));
			end = dest + linesize1;
			end = dest + linesize;
#ifdef FBI_DEBUG
			erasetype = 2;
#endif
		}
		else {
			dest = (fbtype *)(FB_BASE + (font_linemodulo * linesize1 * sizeof(fbtype)));
			dest += ((lno-font_linemodulo) * linesize);
			end = dest + linesize;
#ifdef FBI_DEBUG
			erasetype = 3;
#endif
		}
	}

	dest1 = dest + FB_SIZE/sizeof(fbtype);
	fb_memset(dest,font_bgcolor.fbval,end-dest);
#ifdef FBDEV_SETSTART
	fb_memset(dest1,font_bgcolor.fbval,end-dest);
#endif

#ifdef FBI_DEBUG
	if (!fbi_consolemode_enabled)	/* don't print if console is enabled */
		printf("fb_erase_line_%d(%d)\n",erasetype,lno);
#endif

}

#ifdef FBDEV_SETSTART

/* fb_scroll() 
 * Called each time a 'newline' character is put to the screen.
 */
void
fb_scroll(void)
{
	int 	adjust, next_ypos;
	unsigned long fbstart;

	font_scrolltot++;

	if (font_ypos >= (font_rowsperscreen-1))
		next_ypos = 0;
	else
		next_ypos = font_ypos+1;

	if (font_scrolltot >= (font_rowsperscreen*2)) {
		fb_erase_line(next_ypos);

		fbstart = (FB_BASE +
			(SCREEN_WIDTH*font_totalcharheight * sizeof(fbtype)));

		if (font_linemodulo)
			fbstart += SCREEN_WIDTH * sizeof(fbtype);

		FBDEV_SETSTART(fbstart);

#ifdef FBI_DEBUG
		if (!fbi_consolemode_enabled) {	/* don't print if console is enabled */
			printf("fb_scroll_1: %d %d %d (fbstart=0x%lx)\n",
				font_ypos,font_scrolltot,font_rowsperscreen,fbstart);
		}
#endif
		font_scrolltot = font_rowsperscreen;
	}
	else if (font_scrolltot >= font_rowsperscreen) {
		int ldiff = font_scrolltot - font_rowsperscreen;

		fb_erase_line(ldiff);

		adjust =
			(SCREEN_WIDTH * font_totalcharheight * sizeof(fbtype));

		fbstart = (FB_BASE + ((ldiff+1) * adjust));

		if (font_linemodulo) {
			if (ldiff <= font_linemodulo)
				fbstart += ldiff * (SCREEN_WIDTH * sizeof(fbtype));
			else
				fbstart += font_linemodulo * (SCREEN_WIDTH * sizeof(fbtype));
		}

		FBDEV_SETSTART(fbstart);

#ifdef FBI_DEBUG
		if (!fbi_consolemode_enabled) {	/* don't print if console is enabled */
			printf("fb_scroll_2: %d %d %d %d (fbstart=0x%lx)\n",
				font_ypos,font_scrolltot,font_rowsperscreen,adjust,fbstart);
		}
#endif
	}

	font_ypos = next_ypos;
}

#else

void
fb_scroll(void)
{
	int i, tot;
	struct font *fp;
	fbtype *dest, *src;

	if (font_ypos >= (font_rowsperscreen-1)) {
		/* Starting at the point in the frame buffer where the second line
		 * starts, copy that to the top of the frame buffer.  Effectively 
		 * moving every line below the first line up by one.
		 * Then clear the newly created bottom line.
		 *
		 * NOTE: this is the *slow* way.  Ideally, the hardware has the ability
		 * to support the fbdev_setstart() functionality so the double-buffer
		 * algorithm (described above) can be used.
		 */
		fp = &font_styles[font_style];
		dest = (fbtype *)FB_BASE;
		src = (fbtype *)FB_BASE + (SCREEN_WIDTH * font_totalcharheight);
	
		tot = ((FB_END - FB_BASE)/2) - (src - dest);
	
		for(i=0;i<tot;i++)
			*dest++ = *src++;

		/* Clear the new bottom line...
		 */
		while(dest < (fbtype *)FB_END)
			*dest++ = font_bgcolor.fbval;
	}
	else
		font_ypos++;
}

#endif

/* fb_putchar():
 * Using the current font settings and frame buffer position, set the
 * pixels that correspond to the incoming character 'inchar'.
 * This function supports the double-buffer line scroll technique discussed
 * above; hence, the use of fp1 & fp2 below.
 */
static void
fb_putchar(char inchar)
{
	struct font *fp;
	int		i, j, k;
	char	*bmppos;
	unsigned char mask, endmask, fontchar;
	fbtype *fp1, *fp2, *position, *start, *end;

	if (!font_initialized)
		font_defaults();

	fp = &font_styles[font_style];

#ifndef FBI_NO_CURSOR
	fbi_cursor_clear();
#endif

	if (inchar == '\r') {
		font_xpos = 0;
		return;
	}
	else if (inchar == '\n') {
		fb_scroll();
		return;
	}
	else if (inchar == '\b') {
		if (font_xpos > 0) {
			font_xpos--;
			fb_putchar(' ');
			font_xpos--;
		}
		return;
	}

	/* Chop at end of screen...
	 */
	if (font_xpos >= font_colsperscreen) {
		if (fbi_linewrap) {
			font_xpos = 0;
			fb_scroll();
		}
		else
			return;
	}

	position = start = (fbtype *)FB_BASE +
		(font_ypos * font_totalcharheight * SCREEN_WIDTH) +
		(font_xpos * font_totalcharwidth);

	if (font_ypos < font_linemodulo) {
		position += font_ypos*SCREEN_WIDTH;
	}
	else {
		position += font_linemodulo*SCREEN_WIDTH;
	}

	bmppos = fp->bitmap + ((inchar - 0x20) * fp->height);
	for(i=0;i<fp->above * font_yscale;i++) {
		fp1 = (fbtype *)position;
		fp2 = fp1 + FB_SIZE/2;
		end = fp1 + (fp->width * font_xscale) + (fp->between * font_xscale);
		while(fp1 < end) {
			if (font_is_opaque) {
				*fp1++ = font_bgcolor.fbval;
				*fp2++ = font_bgcolor.fbval;
			}
			else {
				fp1++;
				fp2++;
			}
		}
		position += SCREEN_WIDTH;
	}

	/* Some fonts will only use the left-most 7 columns of pixels, so
	 * we support that here...
	 */
	if (fp->width == 7)
		endmask = 1;
	else
		endmask = 0;

	for(i=0;i<fp->height;i++) {
		fontchar = *bmppos++;

		for(k=0;k<font_yscale;k++) {
			fp1 = (fbtype *)position;
			fp2 = fp1 + FB_SIZE/2;
			for(mask = 0x80; mask != endmask; mask >>= 1) {
				if (fontchar & mask) {
					for(j=0;j<font_xscale;j++) {
						*fp1++ = font_fgcolor.fbval;
						*fp2++ = font_fgcolor.fbval;
					}
				}
				else if (font_is_opaque) {
					for(j=0;j<font_xscale;j++) {
						*fp1++ = font_bgcolor.fbval;
						*fp2++ = font_bgcolor.fbval;
					}
				}
				else {
					for(j=0;j<font_xscale;j++) {
						fp1++;
						fp2++;
					}
				}
			}
	
			end = fp1 + (fp->between * font_xscale);
			while(fp1 < end) {
				if (font_is_opaque) {
					*fp1++ = font_bgcolor.fbval;
					*fp2++ = font_bgcolor.fbval;
				}
				else {
					fp1++;
					fp2++;
				}
			}
			position += SCREEN_WIDTH;
		}
	}

	for(i=0;i<fp->below*font_yscale;i++) {
		fp1 = position;
		fp2 = fp1 + FB_SIZE/2;
		end = fp1 + (fp->width * font_xscale) + (fp->between * font_xscale);
		while(fp1 < end) {
			if (font_is_opaque) {
				*fp1++ = font_bgcolor.fbval;
				*fp2++ = font_bgcolor.fbval;
			}
			else {
				fp1++;
				fp2++;
			}
		}
		position += SCREEN_WIDTH;
	}

	font_xpos++;
}

static int
fbi_puts(char *str)
{
	int tot, slash;
	char nextchar;

	tot = slash = 0;
	while(*str) {
		if (slash) {
			switch(*str) {
				case 'n':
					nextchar = '\n';
					break;
				case 'r':
					nextchar = '\r';
					break;
				case 'b':
					nextchar = '\b';
					break;
				default:
					tot++;
					fb_putchar('\\');
					nextchar = *str;
					break;
			}
			str++;
		}
		else {
			if (*str  == '\\') {
				slash = 1;
				str++;
				continue;
			}
			nextchar = *str++;
		}
		tot++;
		fb_putchar(nextchar);
		slash = 0;
	}

	return(tot);
}

/* get_bmphdr_long():
 * Given an offset, copy 4 bytes of data to a temporary long
 * value, then endian-swap if necessary.
 */
unsigned long
get_bmphdr_long(char *offset, char *msg, int verbose)
{
	unsigned long tmp1, tmp2;

	memcpy((char *)&tmp1,(char *)offset,4);
	tmp2 = ecl(tmp1);

	if (verbose)
		printf(" %-20s: %ld\n",msg,tmp2);

	return(tmp2);
}

/* get_bmphdr_short():
 * Given an offset, copy 2 bytes of data to a temporary short
 * value, then endian-swap if necessary.
 */
unsigned short
get_bmphdr_short(char *offset, char *msg, int verbose)
{
	unsigned short tmp1, tmp2;

	memcpy((char *)&tmp1,(char *)offset,2);
	tmp2 = ecs(tmp1);

	if (verbose)
		printf(" %-20s: %d\n",msg,tmp2);

	return(tmp2);
}

/* get_bmpinfo():
 * Using the incoming base address as the pointer to the incoming data,
 * return 1 if the data is not BMP formatted
 * return 0 if the data is BMP formatted
 * return -1 if the data is BMP formatted but something is not compatible
 *		with this tool
 */
int
get_bmpinfo(char *base, int verbose)
{
	if ((base[0] != 'B') || (base[1] != 'M')) {
		return(1);
	}

	/* Retrieve the .bmp file's header info...
	 */
	bmpinfo.size = get_bmphdr_long(base+2,"Size",verbose);
	bmpinfo.offset = get_bmphdr_long(base+10,"Offset",verbose);
	bmpinfo.hdrsz = get_bmphdr_long(base+14,"Hdrsize",verbose);
	bmpinfo.width = get_bmphdr_long(base+18,"Width",verbose);
	bmpinfo.height = get_bmphdr_long(base+22,"Height",verbose);
	bmpinfo.planes = get_bmphdr_short(base+26,"Planes",verbose);
	bmpinfo.bpp = get_bmphdr_short(base+28,"Bpp",verbose);
	bmpinfo.cprs = get_bmphdr_long(base+30,"Cprs",verbose);
	bmpinfo.rawsize = get_bmphdr_long(base+34,"RawSize",verbose);
	bmpinfo.hrez = get_bmphdr_long(base+38,"Hrez",verbose);
	bmpinfo.vrez = get_bmphdr_long(base+42,"Vrez",verbose);
	bmpinfo.palettesiz = get_bmphdr_long(base+46,"Palettesiz",verbose);
	bmpinfo.impcol = get_bmphdr_long(base+50,"Important colors",verbose);

	if (bmpinfo.cprs != 0) {
		printf("Can't deal with non-zero compression method.\n");
		return(-1);
	}
	if (bmpinfo.bpp != 24) {
		printf("BMP file pixel format is not 24 bits per pixel.\n");
		return(-1);
	}
	return(0);
}

void
fbi_consolemode_enable(int enable, int fbinit)
{
	font_scrolltot = 0;
	font_ypos = font_xpos = 0;

	if (enable) {
		if (!font_initialized)
			font_defaults();
	}

	if (fbinit) {
		/* Regardless of whether we are enabling or disableing console
		 * mode we need to init the frame buffer.  We fill it with with the
		 * same color that is used by the font's background.
		 *
		 * If FBDEV_SETSTART is defined, then we assume that we're
		 * using the double-buffer technique (described above) for
		 * scrolling; hence, we need to initialize twice the space...
		 */
#ifdef FBDEV_SETSTART
		fb_memset((fbtype *)FB_BASE,font_bgcolor.fbval,
			((FB_END-FB_BASE)/sizeof(fbtype))*2);

		FBDEV_SETSTART(FB_BASE);
#else
		fb_memset((fbtype *)FB_BASE,font_bgcolor.fbval,
			(FB_END-FB_BASE)/sizeof(fbtype));
#endif
	}

	fbi_consolemode_enabled = (char)enable;
}

int
is_fbi_consolemode_enabled(void)
{
	if (fbi_consolemode_enabled)
		return(1);
	return(0);
}

void
fillbox(int x_offset,int y_offset,int type,fbtype *dest_base,fbtype *src_base)
{
	int x, y, offset;
	fbtype *src, *dest;

	offset = (y_offset * BOX_YSIZE * SCREEN_WIDTH) + (x_offset * BOX_XSIZE);
	dest = dest_base + offset;

	if (type & FILLTYPE_COLOR) {
		for(y=0;y<BOX_YSIZE;y++) {
			for(x=0;x<BOX_XSIZE;x++)
				dest[x] = *src_base;
	
			dest += SCREEN_WIDTH;
		}
	}
	else {
		src = src_base + offset;

		for(y=0;y<BOX_YSIZE;y++) {
			for(x=0;x<BOX_XSIZE;x++)
				dest[x] = src[x];
	
			dest += SCREEN_WIDTH;
			src += SCREEN_WIDTH;
		}
	}
}

/* copypixel():
 * Copy the frame buffer data that corresponds to the specified x/y
 * coordinate from one frame buffer block to another...
 * Note, if filltype is FILLTYPE_COLOR, then we assume that 'frm'
 * is pointing to a fixed color.
 */
void
copypixel(fbtype *to, fbtype *frm, int filltype, int x, int y)
{
	fbtype *dst, *src;

	dst = to + ((y * PIXELS_PER_ROW) + x);

	if (filltype & FILLTYPE_COLOR)
		src = frm;
	else
		src = frm + ((y * PIXELS_PER_ROW) + x);

	*dst = *src;
}

/* fillscreen():
 * Fill the screen from top to bottom in four scans, skipping around between
 * each scan just to improve the effect.  If 'box' is set, then the fill
 * area is a 10x10 box; otherwise its a pixel.
 */
void
fillscreen(fbtype *to,fbtype *frm,int filltype, int delay)
{
	int x, y;
	int xInit, yInit, xEnd, yEnd;

	yInit = xInit = 0;
	xEnd = SCREEN_WIDTH;
	yEnd = SCREEN_HEIGHT;
	if (filltype & FILLTYPE_BOX) {
		xEnd = xEnd/BOX_XSIZE;
		yEnd = yEnd/BOX_YSIZE;
	}

repeat:
	for(y=yInit;y<yEnd;y+=2) {
		for(x=xInit;x<xEnd;x+=2) {
			if (filltype & FILLTYPE_BOX) {
				fillbox(x,y,filltype,to,frm);
				if (delay)
					monDelay(delay);
			}
			else if (filltype & FILLTYPE_COLOR) {
				*(to + (y*SCREEN_WIDTH)+x) = *frm;
			}
			else {
				*(to + (y*SCREEN_WIDTH)+x) = *(frm + (y*SCREEN_WIDTH)+x);
			}
		}
		if (!(filltype & FILLTYPE_BOX)) {
			if (delay)
				monDelay(delay);
		}
	}
	if ((xInit == 0) && (yInit == 0)) {
		xInit = 1; yInit = 1;
		goto repeat;
	}
	if ((xInit == 1) && (yInit == 1)) {
		xInit = 0; yInit = 1;
		goto repeat;
	}
	if ((xInit == 0) && (yInit == 1)) {
		xInit = 1; yInit = 0;
		goto repeat;
	}
	/* If FILTYPE_BOX is set and the boxsize is not evenly
	 * divided into the actual screen size, then we need to
	 * fill in the edges (right & bottom).
	 */
	if (filltype & FILLTYPE_BOX) {
		int xmod, ymod;

		xmod = SCREEN_WIDTH % BOX_XSIZE;
		ymod = SCREEN_HEIGHT % BOX_YSIZE;
		if (xmod) {
			for(y=0;y<SCREEN_HEIGHT;y++) {
				for(x=SCREEN_WIDTH-xmod;x<SCREEN_WIDTH;x++)
					copypixel(to,frm,filltype,x,y);
			}
		}
		if (ymod) {
			for(y=SCREEN_HEIGHT-ymod;y<SCREEN_HEIGHT;y++) {
				for(x=0;x<SCREEN_WIDTH;x++)
					copypixel(to,frm,filltype,x,y);
			}
		}
	}
}

void
fill_centerout(fbtype *to,fbtype *frm,int filltype, int delay)
{
	int i, j, x, y, row, col, maxcol, maxrow;

	x = SCREEN_WIDTH/2;
	y = SCREEN_HEIGHT/2;
	copypixel(to,frm,filltype,x,y);
	for(i=0;x>=0 && y>=0;x--,y--,i+=2) {
		for(j=0,row=y,col=x;j<i;j++,col++)
			copypixel(to,frm,filltype,col,row);
		maxcol = col;
		maxrow = row;
		for(j=0,row=y;j<i;j++,row++)
			copypixel(to,frm,filltype,col,row);
		for(j=0;j<i;j++,col--)
			copypixel(to,frm,filltype,col,row);
		for(j=0;j<i;j++,row--)
			copypixel(to,frm,filltype,col,row);
	}
	if (x == -1) {
		while(y >= 0) {
			for(x=0;x<SCREEN_WIDTH;x++) {
				copypixel(to,frm,filltype,x,y);
				copypixel(to,frm,filltype,x,maxrow);
			}
			y--; maxrow++;
		}
	}
	else if (y == -1) {
		while(x >= 0) {
			for(y=0;y<SCREEN_HEIGHT;y++) {
				copypixel(to,frm,filltype,x,y);
				copypixel(to,frm,filltype,maxcol,y);
			}
			x--; maxcol++;
		}
	}
}

/* fb_setcolor():
 * Fill the frame buffer with the incoming RGB-24 formatted
 * color value...
 */
void
fb_setcolor(long rgb, int transition_type)
{
	fbtype fillval, *to, *from;
	
	to = (fbtype *)FB_BASE;
	from = &fillval;
	fillval = rgb_to_fb(rgb);

	switch(transition_type) {
		case 1:		/* Pixel fill */
			fillscreen(to,from,FILLTYPE_COLOR,0);
			break;
		case 2:		/* Box fill */
			fillscreen(to,from,FILLTYPE_BOX | FILLTYPE_COLOR,0);
			break;
		case 3:		/* Center-out fill */
			fill_centerout(to,from,FILLTYPE_COLOR,0);
			break;
		default:	/* Standard top-to-bottom fill */
			fb_memset(to,fillval,(FB_END-FB_BASE)/sizeof(fbtype));
			break;
	}
}

char *FbiHelp[] = {
	"Frame buffer interface",
	"-[d:f:o:t:v] {cmd} [args...]",
#if INCLUDE_VERBOSEHELP
	"Options:",
	" -d ##        delay the transition speed",
	" -f RGB       enable (and set) frame-buffer fill value",
	" -o X,Y       offset into frame buffer",
	" -t ##        apply transition when updating screen",
	"              (doesn't work with .bmp formated source data)",
	" -v           additive verbosity",
	"",
	"Commands:",
	" color {rgb-value}              # fill screen with specified color",
	" consolemode {on|wrap|off}      # enable/disable console mode",
	" fb2file {filename}             # copy frame-buffer to TFS file",
	" fill {filename | hex_address}  # fill screen with file or data",
	" font {style} {xscale} {yscale} {fgcolor} {bgcolor}",
	" print {text}                   # print to screen",
	" setpixel {x} {y} {size} {color}",
#ifdef FBDEV_SETSTART
	" setstart {hex address}         # establish base address of frame buffer",
#endif
#endif
	0,
};

int
FbiCmd(int argc,char *argv[])
{
	TFILE	*tfp;
	unsigned char *bmp;
	unsigned long fill_rgb;
	fbtype	*fp, fill_fbvalue;
	char	*cmd, *arg1, fill_is_set, *base, *comma;
	int		x, y, widthadjust, transition_type;
	int		data_is_raw, transition_delay, rowsize, verbose, opt;

	if (!font_initialized)
		font_defaults();

	verbose = 0;
	fill_rgb = 0;
	fill_fbvalue = 0;
	transition_delay = transition_type = fill_is_set = 0;
	while((opt=getopt(argc,argv,"d:f:o:t:v")) != -1) {
		switch(opt) {
		case 'd':
			transition_delay = (int)strtol(optarg,0,0);
			break;
		case 'f':
			fill_is_set = 1;
			fill_rgb = strtoul(optarg,0,0);
			break;
		case 'o':
			comma = strchr(optarg,',');
			if (!comma)
				return(CMD_PARAM_ERROR);
			font_xpos = strtol(optarg,0,0);
			font_ypos = strtol(comma+1,0,0);
			if ((font_xpos > SCREEN_WIDTH) || (font_ypos > SCREEN_HEIGHT)) {
				printf("Offset out of range\n");
				return(CMD_FAILURE);
			}
			break;
		case 't':
			transition_type = atoi(optarg);
			break;
		case 'v':
			verbose++;
			break;
		default:
			return(CMD_PARAM_ERROR);
		}
	}

	if (argc == optind) {
		printf("Frame buffer info...\n");
		printf("  Base addr:  0x%lx\n",FB_BASE);
		printf("  LCD width x height (pixels):  %dx%d\n",
			SCREEN_WIDTH,SCREEN_HEIGHT);
#if PIXFMT_IS_RGB565
		printf("  Pixel fmt:  RGB565 (16 bits-per-pixel)\n");
#elif PIXFMT_IS_RGB555
		printf("  Pixel fmt:  RGB555 (16 bits-per-pixel)\n");
#endif
		printf("Font (style=%d)...\n",font_style);
		printf(" Scale: x=%d, y=%d\n", font_xscale,font_yscale);
		printf(" Color: fg=0x%06x, bg=0x%06x\n",
			font_fgcolor.rgbval, font_bgcolor.rgbval);
		printf(" Total per-char font height: %d, width: %d\n",
			font_totalcharheight,font_totalcharwidth);
		printf(" Total rows: %d (mod %d), cols: %d\n",
			font_rowsperscreen, font_linemodulo, font_colsperscreen);
		printf(" Current position: x=%d, y=%d\n",font_xpos,font_ypos);

		shell_sprintf("FBIBASE","0x%x",FB_BASE);
		shell_sprintf("FBIROWS","%d",font_rowsperscreen);
		shell_sprintf("FBICOLS","%d",font_colsperscreen);
		return(CMD_SUCCESS);
	}
	if (argc < optind + 1)
		return(CMD_FAILURE);

	cmd = argv[optind];
	arg1 = argv[optind+1];

	if (strcmp(cmd,"fill") == 0) {
		if (argc != (optind+2))
			return(CMD_PARAM_ERROR);

		if ((arg1[0] == '0') && (arg1[1] == 'x')) {
			base = (char *)strtoul(arg1,0,0);
		}
		else {
			if ((tfp = tfsstat(arg1)) == (TFILE *)0) {
				printf("File '%s' not found\n",arg1);
				return(1);
			}
			base = TFS_BASE(tfp);
		}

		if ((data_is_raw = get_bmpinfo(base,verbose)) == -1)
			return(CMD_FAILURE);

		if (fill_is_set) {
			fill_fbvalue = rgb_to_fb(fill_rgb);
		}

		/* If the input data is raw, then just copy it directly to the frame
		 * buffer memory space and be done.
		 * Note, the transition_type set up with the -t option only works when
		 * we're pushing in raw data...
		 */
		if (data_is_raw) {
			fbtype *to = (fbtype *)FB_BASE;
			fbtype *from = (fbtype *)base;

			switch(transition_type) {
				case 1:		/* Pixel fill */
					fillscreen(to,from,0,transition_delay);
					break;
				case 2:		/* Box fill */
					fillscreen(to,from,FILLTYPE_BOX,transition_delay);
					break;
				case 3:		/* Center-out fill */
					fill_centerout(to,from,0,transition_delay);
					break;
				default:	/* Standard top-to-bottom fill */
					if (transition_delay) {
						while(to < (fbtype *)FB_END) {
							*to++ = *from++;
							if (((int)to & 0x1ff) == 0x1ff)
								monDelay(transition_delay);
						}
					}
					else {
						fb_memcpy(to,from,(fbtype *)FB_END-to);
					}
			}
			return(CMD_SUCCESS);
		}

		fp = (fbtype *)FB_BASE;

		/* Adust the starting point based on x & y offsets (if any)...
		 */
		fp += (font_ypos * SCREEN_WIDTH) + font_xpos;

		/* Each row of pixels is extended to a 4-byte boundary, filling
		 * with an unspecified value so that the next row will start on
		 * a multiple-of-four byte location in memory or in the file.
		 * This equation establishes a row size variable that is compliant
		 * with that rule.  The equation is taken directly out of the
		 * wikipedia page mentioned at the top of this file.
		 * 
		 *                      (n * width) + 31
		 *      rowsize = 4 * ( ---------------- )
		 *                             32
		 *
		 * (where 'n' is the number of bits per pixel).
		 */
		rowsize = ((((24*bmpinfo.width) + 31)/32) * 4);
		if (verbose > 1)
			printf("rowsize: %d\n",rowsize);
	
		widthadjust = 0;
		while ((bmpinfo.width * 3) % 4) {
			widthadjust++;
			bmpinfo.width++;
		}

		if ((verbose > 1) && widthadjust) {
			printf("%d-byte width adjustment: %ld -> %ld\n",
				widthadjust, bmpinfo.width-widthadjust, bmpinfo.width);
		}
	
		if (bmpinfo.rawsize == 0) {
			bmpinfo.rawsize = (bmpinfo.height * bmpinfo.width) * 3;
		}
		else {
			if ((verbose > 1) &&
				(bmpinfo.rawsize != (bmpinfo.height * bmpinfo.width) * 3)) {
				printf("size off: %d %d\n",
					bmpinfo.rawsize,(bmpinfo.height * bmpinfo.width) * 3);
			}
		}
	
		bmp = (unsigned char *)base + bmpinfo.offset + bmpinfo.rawsize;
	
		/* Below there are 4 distinct cases regarding the size of the .bmp
		 * image vs the size of the LCD screen...
		 * If the bitmap is larger than the LCD, then just fit the upper
		 * left corner of the bitmap into the LCD.
		 * If the LCD is larger than the bitmap, just put the bitmap in 
		 * the upper left corner of the LCD and allow portions to be cut off.
		 *
		 * - Pixels are stored "upside-down" with respect to normal image raster
		 *   scan order, starting in the lower left corner, going from left to
		 *   right, and then row by row from the bottom to the top of the image.
		 *   As a result, this code has to also deal with that.
		 */

		if (bmpinfo.width > SCREEN_WIDTH) {
			if (bmpinfo.height > SCREEN_HEIGHT) {
				if (verbose > 2)
					printf("case 1\n");
				for(y=0;y<SCREEN_HEIGHT;y++) {
					volatile unsigned char *bp;
	
					bmp -= rowsize;
					bp = bmp;
					for(x=0;x<SCREEN_WIDTH;x++,fp++) {
						*fp = ((short)(*bp++ & 0xf8) >> 3);		// Blue
						*fp |= ((short)(*bp++ & 0xfc) << 3);	// Green
						*fp |= ((short)(*bp++ & 0xf8) << 8);	// Red
					}
					if (transition_delay) monDelay(transition_delay);
				}
			}
			else {
				if (verbose > 2)
					printf("case 2\n");
				for(y=0;y<bmpinfo.height;y++) {
					volatile unsigned char *bp;
	
					bmp -= rowsize;
					bp = bmp;
					for(x=0;x<SCREEN_WIDTH;x++,fp++) {
						*fp = ((short)(*bp++ & 0xf8) >> 3);		// Blue
						*fp |= ((short)(*bp++ & 0xfc) << 3);	// Green
						*fp |= ((short)(*bp++ & 0xf8) << 8);	// Red
					}
					if (transition_delay) monDelay(transition_delay);
				}
				if (fill_is_set) {
					while(fp < (unsigned short *)FB_END)
						*fp++ = fill_fbvalue;
				}
			}
		}
		else {
			if (bmpinfo.height > SCREEN_HEIGHT) {
				if (verbose > 2)
					printf("case 3\n");
				for(y=0;y<SCREEN_HEIGHT;y++) {
					volatile unsigned char *bp;
	
					bmp -= rowsize;
					bp = bmp;
					for(x=0;x<bmpinfo.width;x++,fp++) {
						*fp = ((short)(*bp++ & 0xf8) >> 3);		// Blue
						*fp |= ((short)(*bp++ & 0xfc) << 3);	// Green
						*fp |= ((short)(*bp++ & 0xf8) << 8);	// Red
					}
					if (fill_is_set) {
						while(x++ < SCREEN_WIDTH) 
							*fp++ = fill_fbvalue;
					}
					else {
						fp += (SCREEN_WIDTH - x);
					}
					if (transition_delay) monDelay(transition_delay);
				}
			}
			else {
				if (verbose > 2)
					printf("case 4\n");
				for(y=0;y<bmpinfo.height;y++) {
					volatile unsigned char *bp;
	
					bmp -= rowsize;
					bp = bmp;
					for(x=0;x<bmpinfo.width;x++,fp++) {
						*fp = ((short)(*bp++ & 0xf8) >> 3);		// Blue
						*fp |= ((short)(*bp++ & 0xfc) << 3);	// Green
						*fp |= ((short)(*bp++ & 0xf8) << 8);	// Red
					}
					if (fill_is_set) { 
						while(x++ < SCREEN_WIDTH)
							*fp++ = fill_fbvalue;
					}
					else {
						fp += (SCREEN_WIDTH - x);
					}
					if (transition_delay) monDelay(transition_delay);
				}
				if (fill_is_set) {
					while(fp < (unsigned short *)FB_END)
						*fp++ = fill_fbvalue;
				}
			}
		}
	}
#ifdef FBDEV_SETSTART
	else if (strcmp(cmd,"setstart") == 0) {
		if (argc != (optind+2))
			return(CMD_PARAM_ERROR);

		FBDEV_SETSTART(strtol(arg1,0,0));
		return(CMD_SUCCESS);
	}
#endif
	else if (strcmp(cmd,"color") == 0) {
		if (argc != (optind+2))
			return(CMD_PARAM_ERROR);

		fb_setcolor(strtoul(arg1,0,0),transition_type);
		return(CMD_SUCCESS);
	}
	else if (strcmp(cmd,"consolemode") == 0) {
		if (argc == (optind+1)) {
			printf("Consolemode currently %sabled\n",
				fbi_consolemode_enabled ? "en" : "dis");
			return(CMD_SUCCESS);
		}

		if (argc != (optind+2))
			return(CMD_PARAM_ERROR);

		if (strcmp(arg1,"on") == 0) {
			fbi_consolemode_enable(1,1);
			fbi_linewrap = 0;
		}
		else if (strcmp(arg1,"wrap") == 0) {
			fbi_consolemode_enable(1,1);
			fbi_linewrap = 1;
		}
		else if (strcmp(arg1,"off") == 0) {
			fbi_consolemode_enable(0,1);
		}
		else {
			return(CMD_PARAM_ERROR);
		}

		return(CMD_SUCCESS);
	}
	else if (strcmp(cmd,"font") == 0) {
		int newstyle;
		struct font *fontp;

		if (argc != (optind+6))
			return(CMD_PARAM_ERROR);
		
		newstyle = atoi(argv[optind+1]);
		if ((newstyle < 0) || (newstyle >= font_style_total())) {
			printf("Invalid font style\n");
			return(CMD_FAILURE);
		}

		font_style = newstyle;
		font_xscale = atoi(argv[optind+2]);
		font_yscale = atoi(argv[optind+3]);
		if (strcmp(argv[optind+4],"--")) {
			font_fgcolor.rgbval = strtol(argv[optind+4],0,0);
			font_fgcolor.fbval = rgb_to_fb(font_fgcolor.rgbval);
		}
		

		if (strcmp(argv[optind+5],"transparent") == 0) {
			font_is_opaque = 0;
		}
		else if (strcmp(argv[optind+5],"--")) {
			font_is_opaque = 1;
			font_bgcolor.rgbval = strtol(argv[optind+5],0,0);
			font_bgcolor.fbval = rgb_to_fb(font_bgcolor.rgbval);
		}

		
		fontp = &font_styles[font_style];
		font_totalcharheight = ((fontp->height + fontp->above + fontp->below) *
			font_yscale);
		font_totalcharwidth = ((fontp->width + fontp->between) * font_xscale);

		font_rowsperscreen = SCREEN_HEIGHT / font_totalcharheight;
		font_colsperscreen = SCREEN_WIDTH / font_totalcharwidth;
		font_linemodulo = SCREEN_HEIGHT % font_totalcharheight;

		font_initialized = 1;
	}
	else if (strcmp(cmd,"setpixel") == 0) {
		long	color;
		int		x, y, xx, yy, width;

		if (argc != optind+5)
			return(CMD_PARAM_ERROR);

		x = strtol(argv[optind+1],0,0);
		y = strtol(argv[optind+2],0,0);
		width = strtol(argv[optind+3],0,0);
		color = strtol(argv[optind+4],0,0);

		for(xx = x-width;xx <= x+width;xx++) {
			for(yy = y-width;yy <= y+width;yy++)
				fbi_setpixel(xx,yy,color);
		}
	}
	else if (strcmp(cmd,"print") == 0) {
		if (argc != optind+2)
			return(CMD_PARAM_ERROR);

		if (verbose)
			printf("Print: <%s>\n",argv[optind+1]);

		fbi_puts(argv[optind+1]);
		return(CMD_SUCCESS);
	}
	else if (strcmp(cmd,"fb2file") == 0) {
		int err;

		if (argc != optind+2)
			return(CMD_PARAM_ERROR);

		if (verbose)
			printf("Copying frame buffer to '%s'...\n",arg1);

		err = tfsadd(arg1,0,0,(unsigned char *)FB_BASE,FB_SIZE);
		if (err != TFS_OKAY)
			printf("Failed: %s\n",(char *)tfsctrl(TFS_ERRMSG,err,0));
		return(CMD_SUCCESS);
	}
	else {
		return(CMD_PARAM_ERROR);
	}

	return(CMD_SUCCESS);
}

/* fbi_putchar():
 * This is the external putchar available to other parts of the code.
 */
void
fbi_putchar(char c)
{
	if (!fbi_consolemode_enabled)
		return;

	fb_putchar(c);
}

#ifndef FBI_NO_CURSOR
void
fbi_cursor(void)
{
	static char beenhere;
    static struct elapsed_tmr tmr;

	if (!fbi_consolemode_enabled)
		return;

	if (!beenhere) {
    	startElapsedTimer(&tmr,500);
		beenhere = 1;
		return;
	}

   	if(msecElapsed(&tmr)) {
		fbi_cursorpos = (fbtype *)FB_BASE +
			(font_ypos * font_totalcharheight * SCREEN_WIDTH) +
			(font_xpos * font_totalcharwidth);

		if (font_ypos < font_linemodulo) {
			fbi_cursorpos += font_ypos*SCREEN_WIDTH;
		}
		else {
			fbi_cursorpos += font_linemodulo*SCREEN_WIDTH;
		}
		fbi_cursorpos += (font_totalcharheight-3) * SCREEN_WIDTH;
		if (fbi_cursorstate) {
			fb_memset(fbi_cursorpos,font_bgcolor.fbval,font_totalcharwidth);
#ifdef FBDEV_SETSTART
			fb_memset(fbi_cursorpos + FB_SIZE/sizeof(fbtype),
				font_bgcolor.fbval,font_totalcharwidth);
#endif
			fbi_cursorstate = 0;
		}
		else {
			fb_memset(fbi_cursorpos,font_fgcolor.fbval,font_totalcharwidth);
#ifdef FBDEV_SETSTART
			fb_memset(fbi_cursorpos + FB_SIZE/sizeof(fbtype),
				font_fgcolor.fbval,font_totalcharwidth);
#endif
			fbi_cursorstate = 1;
		}
    	startElapsedTimer(&tmr,500);
	}
}

void
fbi_cursor_clear(void)
{
	if (fbi_cursorstate == 1) {
		fb_memset(fbi_cursorpos,font_bgcolor.fbval,font_totalcharwidth);
#ifdef FBDEV_SETSTART
		fb_memset(fbi_cursorpos + FB_SIZE/sizeof(fbtype),
			font_bgcolor.fbval,font_totalcharwidth);
#endif
		fbi_cursorstate = 0;
	}
}
#endif

/* fbi_splash():
 * This function should be called at system startup to push out a
 * "splash screen" if the appropriate file is installed in TFS.
 * The presence of this file also establishes the initial state of
 * the console...
 * If the file is present, then consolemode is disabled and the splash
 * screen is displayed.  If the file is not present, then just set
 * up the system with consolemode enabled.
 */
void
fbi_splash(void)
{
	TFILE *tfp;
	fbtype *fp;

#if INCLUDE_UNZIP
	tfp = tfsstat("splash.gz");
	if (tfp) {
		decompress((char *)TFS_BASE(tfp),(int)TFS_SIZE(tfp),(char *)FB_BASE);
		return;
	}
#endif

	tfp = tfsstat("splash.bin");
	fp = (fbtype *)FB_BASE;

	if (tfp) {
		fbtype *splash;

		splash = (fbtype *)TFS_BASE(tfp);
		fb_memcpy(fp,splash,(fbtype *)FB_END-fp);
		fbi_consolemode_enable(0,0);
	}
	else {
		fbi_consolemode_enable(1,1);
	}
}

void
fbi_setpixel(int x, int y, long rgbcolor)
{
	fbtype *fbp;
	
	if (x > PIXELS_PER_ROW)
		x = PIXELS_PER_ROW;
	else if (x < 0)
		x = 0;
	if (y > PIXELS_PER_COL)
		y = PIXELS_PER_COL;
	else if (y < 0)
		y = 0;

	fbp = (fbtype *)FB_BASE + ((y * PIXELS_PER_ROW) + x);
	*fbp = rgb_to_fb(rgbcolor);
}

#endif