[people/ms/u-boot.git] / board / MAI / AmigaOneG3SE / video.c

/*
 * (C) Copyright 2002
 * Hyperion Entertainment, Hans-JoergF@hyperion-entertainment.com
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

#include <common.h>
#include <stdio_dev.h>
#include "memio.h"
#include <part.h>

DECLARE_GLOBAL_DATA_PTR;

unsigned char *cursor_position;
unsigned int cursor_row;
unsigned int cursor_col;

unsigned char current_attr;

unsigned int video_numrows = 25;
unsigned int video_numcols = 80;
unsigned int video_scrolls = 0;

#define VIDEO_BASE (unsigned char *)0xFD0B8000
#define VIDEO_ROWS video_numrows
#define VIDEO_COLS video_numcols
#define VIDEO_PITCH (2 * video_numcols)
#define VIDEO_SIZE (video_numrows * video_numcols * 2)
#define VIDEO_NAME "vga"

void video_test(void);
void video_putc(char ch);
void video_puts(char *string);
void video_scroll(int rows);
void video_banner(void);
int  video_init(void);
int  video_start(void);
int  video_rows(void);
int  video_cols(void);

char *prompt_string = "=>";
unsigned char video_get_attr(void);

void video_set_color(unsigned char attr)
{
    unsigned char *fb = (unsigned char *)VIDEO_BASE;
    int i;

    current_attr = video_get_attr();

    for (i=0; i<VIDEO_SIZE; i+=2)
    {
	*(fb+i+1) = current_attr;
    }
}

unsigned char video_get_attr(void)
{
    char *s;
    unsigned char attr;

    attr = 0x0f;

    s = getenv("vga_fg_color");
    if (s)
    {
	attr = atoi(s);
    }

    s = getenv("vga_bg_color");
    if (s)
    {
	attr |= atoi(s)<<4;
    }

    return attr;
}

int video_inited = 0;

int drv_video_init(void)
{
    int error, devices = 1 ;
    struct stdio_dev vgadev ;
    if (video_inited) return 1;
    video_inited = 1;
    video_init();
    memset (&vgadev, 0, sizeof(vgadev));

    strcpy(vgadev.name, VIDEO_NAME);
    vgadev.flags =  DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM;
    vgadev.putc = video_putc;
    vgadev.puts = video_puts;
    vgadev.getc = NULL;
    vgadev.tstc = NULL;
    vgadev.start = video_start;

    error = stdio_register (&vgadev);

    if (error == 0)
    {
	char *s = getenv("stdout");
	if (s && strcmp(s, VIDEO_NAME)==0)
	{
	    if (overwrite_console()) return 1;
	    error = console_assign(stdout, VIDEO_NAME);
	    if (error == 0) return 1;
	    else return error;
	}
	return 1;
    }

    return error;
}

int video_init(void)
{
    cursor_position = VIDEO_BASE; /* Color text display base */
    cursor_row = 0;
    cursor_col = 0;
    current_attr = video_get_attr(); /* Currently selected value for attribute. */
/*    video_test(); */
    video_set_color(current_attr);

    return 0;
}

void video_set_cursor(int line, int column)
{
    unsigned short offset = line*video_numcols + column;
    cursor_position = VIDEO_BASE +  line*VIDEO_PITCH + column*2;
    out_byte(0x3D4, 0x0E);
    out_byte(0x3D5, offset/256);
    out_byte(0x3D4, 0x0F);
    out_byte(0x3D5, offset%256);
}

void video_write_char(int character)
{
    *cursor_position = character;
    *(cursor_position+1) = current_attr;
}

void video_test(void)
{

}

void video_putc(char ch)
{
    switch(ch)
    {
    case '\n':
	cursor_col = 0;
	cursor_row += 1;
	break;
    case '\r':
	cursor_col = 0;
	break;
    case '\b':
	if (cursor_col) cursor_col--;
	else return;
	break;
    case '\t':
	cursor_col = (cursor_col/8+1)*8;
	break;
    default:
	video_write_char(ch);
	cursor_col++;
	if (cursor_col > VIDEO_COLS-1)
	{
	    cursor_row++;
	    cursor_col=0;
	}
    }

    if (cursor_row > VIDEO_ROWS-1)
	video_scroll(1);
    video_set_cursor(cursor_row, cursor_col);
}

void video_scroll(int rows)
{
    unsigned short clear = ((unsigned short)current_attr) | (' '<<8);
    unsigned short* addr16 = &((unsigned short *)VIDEO_BASE)[(VIDEO_ROWS-rows)*VIDEO_COLS];
    int i;
    char *s;

    s = getenv("vga_askscroll");
    video_scrolls += rows;

    if (video_scrolls >= video_numrows)
    {
	if (s && strcmp(s, "yes"))
	{
	    while (-1 == tstc());
	}

	video_scrolls = 0;
    }


    memcpy(VIDEO_BASE, VIDEO_BASE+rows*(VIDEO_COLS*2), (VIDEO_ROWS-rows)*(VIDEO_COLS*2));
    for (i = 0 ; i < rows * VIDEO_COLS ; i++)
	addr16[i] = clear;
    cursor_row-=rows;
    cursor_col=0;
}

void video_puts(char *string)
{
    while (*string)
    {
	video_putc(*string);
	string++;
    }
}

int video_start(void)
{
    return 0;
}

unsigned char video_single_box[] =
{
    218, 196, 191,
    179,      179,
    192, 196, 217
};

unsigned char video_double_box[] =
{
    201, 205, 187,
    186,      186,
    200, 205, 188
};

unsigned char video_single_title[] =
{
    195, 196, 180, 180, 195
};

unsigned char video_double_title[] =
{
    204, 205, 185, 181, 198
};

#define SINGLE_BOX 0
#define DOUBLE_BOX 1

unsigned char *video_addr(int x, int y)
{
    return VIDEO_BASE + 2*(VIDEO_COLS*y) + 2*x;
}

void video_bios_print_string(char *s, int x, int y, int attr, int count)
{
    int cattr = current_attr;
    if (attr != -1) current_attr = attr;
    video_set_cursor(x,y);
    while (count)
    {
	char c = *s++;
	if (attr == -1) current_attr = *s++;
	video_putc(c);
	count--;
    }
}

void video_draw_box(int style, int attr, char *title, int separate, int x, int y, int w, int h)
{
    unsigned char *fb, *fb2;
    unsigned char *st = (style == SINGLE_BOX)?video_single_box : video_double_box;
    unsigned char *ti = (style == SINGLE_BOX)?video_single_title : video_double_title;
    int i;

    fb = video_addr(x,y);
    *(fb) = st[0];
    *(fb+1) = attr;
    fb += 2;

    fb2 = video_addr(x,y+h-1);
    *(fb2) = st[5];
    *(fb2+1) = attr;
    fb2 += 2;

    for (i=0; i<w-2;i++)
    {
	*fb = st[1];
	fb++;
	*fb = attr;
	fb++;

	*fb2 = st[6];
	fb2++;
	*fb2 = attr;
	fb2++;

    }
    *fb = st[2];
    *(fb+1) = attr;

    *fb2 = st[7];
    *(fb2+1) = attr;

    fb  = video_addr(x, y+1);
    fb2 = video_addr(x+w-1, y+1);
    for (i=0; i<h-2; i++)
    {
	*fb = st[3];
	*(fb+1) = attr; fb += 2*VIDEO_COLS;

	*fb2 = st[4];
	*(fb2+1) = attr; fb2 += 2*VIDEO_COLS;
    }

    /* Draw title */
    if (title)
    {
	if (separate == 0)
	{
	    fb = video_addr(x+1, y);
	    *fb = ti[3];
	    fb += 2;
	    *fb = ' ';
	    fb += 2;
	    while (*title)
	    {
		*fb = *title;
		fb ++;
		*fb = attr;
		fb++; title++;
	    }
	    *fb = ' ';
	    fb += 2;
	    *fb = ti[4];
	}
	else
	{
	    fb = video_addr(x, y+2);
	    *fb = ti[0];
	    fb += 2;
	    for (i=0; i<w-2; i++)
	    {
		*fb = ti[1];
		*(fb+1) = attr;
		fb += 2;
	    }
	    *fb = ti[2];
	    *(fb+1) = attr;
	    fb = video_addr(x+1, y+1);
	    for (i=0; i<w-2; i++)
	    {
		*fb = ' ';
		*(fb+1) = attr;
		fb += 2;
	    }
	    fb = video_addr(x+2, y+1);

	    while (*title)
	    {
		*fb = *title;
		*(fb+1) = attr;
		fb += 2;
		title++;
	    }
	}
    }

}

void video_draw_text(int x, int y, int attr, char *text)
{
    unsigned char *fb = video_addr(x,y);
    while (*text)
    {
	*fb++ = *text++;
	*fb++ = attr;
    }
}

void video_save_rect(int x, int y, int w, int h, void *save_area, int clearchar, int clearattr)
{
    unsigned char *save = (unsigned char *)save_area;
    unsigned char *fb = video_addr(x,y);
    int i,j;
    for (i=0; i<h; i++)
    {
	unsigned char *fbb = fb;
	for (j=0; j<w; j++)
	{
	    *save ++ = *fb;
	    if (clearchar > 0) *fb = clearchar;
	    fb ++;
	    *save ++ = *fb;
	    if (clearattr > 0) *fb = clearattr;
	}
	fb = fbb + 2*VIDEO_COLS;
    }
}

void video_restore_rect(int x, int y, int w, int h, void *save_area)
{
    unsigned char *save = (unsigned char *)save_area;
    unsigned char *fb = video_addr(x,y);
    int i,j;
    for (i=0; i<h; i++)
    {
	unsigned char *fbb = fb;
	for (j=0; j<w; j++)
	{
	    *fb ++ = *save ++;
	    *fb ++ = *save ++;
	}
	fb = fbb + 2*VIDEO_COLS;
    }

}

int video_rows(void)
{
    return VIDEO_ROWS;
}

int video_cols(void)
{
    return VIDEO_COLS;
}

void video_size(int cols, int rows)
{
    video_numrows = rows;
    video_numcols = cols;
}

void video_clear(void)
{
    unsigned short *fbb = (unsigned short *)0xFD0B8000;
    int i,j;
    unsigned short val = 0x2000 | current_attr;

    for (i=0; i<video_rows(); i++)
    {
	for (j=0; j<video_cols(); j++)
	{
	    *fbb++ = val;
	}
    }
    video_set_cursor(0,0);
    cursor_row = 0;
    cursor_col = 0;
}

#ifdef EASTEREGG
int video_easteregg_active = 0;

void video_easteregg(void)
{
    video_easteregg_active = 1;
}
#endif

extern block_dev_desc_t * ide_get_dev(int dev);
extern char version_string[];

void video_banner(void)
{
    block_dev_desc_t *ide;
    int i;
    char *s;
    int maxdev;


    if (video_inited == 0) return;
#ifdef EASTEREGG
    if (video_easteregg_active)
    {
	prompt_string="";
	video_clear();
	printf("\n");
	printf("    **** COMMODORE 64 BASIC X2 ****\n\n");
	printf(" 64K RAM SYSTEM  38911 BASIC BYTES FREE\n\n");
	printf("READY\n");
    }
    else
    {
#endif
	s = getenv("ide_maxbus");
	if (s)
	    maxdev = atoi(s) * 2;
	else
	    maxdev = 4;

	s = getenv("stdout");
	if (s && strcmp(s, "serial") == 0)
	    return;

	video_clear();
	printf("%s\n\nCPU: ", version_string);
	checkcpu();
	printf("DRAM: %ld MB\n", gd->bd->bi_memsize/(1024*1024));
	printf("FSB: %ld MHz\n", gd->bd->bi_busfreq/1000000);

	printf("\n---- Disk summary ----\n");
	for (i = 0; i < maxdev; i++)
	{
	    ide = ide_get_dev(i);
	    printf("Device %d: ", i);
	    dev_print(ide);
	}

/*
    video_draw_box(SINGLE_BOX, 0x0F, "Test 1", 0, 0,18, 72, 4);
    video_draw_box(DOUBLE_BOX, 0x0F, "Test 2", 1, 4,10, 50, 6);
    video_draw_box(DOUBLE_BOX, 0x0F, "Test 3", 0, 40, 3, 20, 5);

    video_draw_text(1, 4, 0x2F, "Highlighted options");
    video_draw_text(1, 5, 0x0F, "Non-selected option");
    video_draw_text(1, 6, 0x07, "disabled option");
*/
#ifdef EASTEREGG
    }
#endif
}
Commit	Line	Data
c7de829c WD	1	/*
c7de829c WD	2	* (C) Copyright 2002
8bde7f77	3	* Hyperion Entertainment, Hans-JoergF@hyperion-entertainment.com
c7de829c WD	4	*
	5	* See file CREDITS for list of people who contributed to this
	6	* project.
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as
	10	* published by the Free Software Foundation; either version 2 of
	11	* the License, or (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	21	* MA 02111-1307 USA
	22	*/
	23
	24	#include <common.h>
52cb4d4f	25	#include <stdio_dev.h>
c7de829c WD	26	#include "memio.h"
	27	#include <part.h>
	28
d87080b7 WD	29	DECLARE_GLOBAL_DATA_PTR;
d87080b7 WD	30
c7de829c WD	31	unsigned char *cursor_position;
	32	unsigned int cursor_row;
	33	unsigned int cursor_col;
	34
	35	unsigned char current_attr;
	36
	37	unsigned int video_numrows = 25;
	38	unsigned int video_numcols = 80;
	39	unsigned int video_scrolls = 0;
	40
	41	#define VIDEO_BASE (unsigned char *)0xFD0B8000
	42	#define VIDEO_ROWS video_numrows
	43	#define VIDEO_COLS video_numcols
	44	#define VIDEO_PITCH (2 * video_numcols)
	45	#define VIDEO_SIZE (video_numrows * video_numcols * 2)
	46	#define VIDEO_NAME "vga"
	47
	48	void video_test(void);
	49	void video_putc(char ch);
	50	void video_puts(char *string);
	51	void video_scroll(int rows);
	52	void video_banner(void);
	53	int video_init(void);
	54	int video_start(void);
	55	int video_rows(void);
	56	int video_cols(void);
	57
	58	char *prompt_string = "=>";
56183324	59	unsigned char video_get_attr(void);
c7de829c WD	60
	61	void video_set_color(unsigned char attr)
	62	{
	63	unsigned char fb = (unsigned char )VIDEO_BASE;
	64	int i;
	65
	66	current_attr = video_get_attr();
	67
	68	for (i=0; i<VIDEO_SIZE; i+=2)
	69	{
	70	*(fb+i+1) = current_attr;
	71	}
	72	}
	73
	74	unsigned char video_get_attr(void)
	75	{
	76	char *s;
	77	unsigned char attr;
	78
	79	attr = 0x0f;
	80
	81	s = getenv("vga_fg_color");
	82	if (s)
	83	{
	84	attr = atoi(s);
	85	}
	86
	87	s = getenv("vga_bg_color");
	88	if (s)
	89	{
	90	attr \|= atoi(s)<<4;
	91	}
	92
	93	return attr;
	94	}
	95
	96	int video_inited = 0;
	97
	98	int drv_video_init(void)
	99	{
	100	int error, devices = 1 ;
52cb4d4f	101	struct stdio_dev vgadev ;
c7de829c WD	102	if (video_inited) return 1;
	103	video_inited = 1;
	104	video_init();
	105	memset (&vgadev, 0, sizeof(vgadev));
8bde7f77	106
c7de829c WD	107	strcpy(vgadev.name, VIDEO_NAME);
	108	vgadev.flags = DEV_FLAGS_OUTPUT \| DEV_FLAGS_SYSTEM;
	109	vgadev.putc = video_putc;
	110	vgadev.puts = video_puts;
	111	vgadev.getc = NULL;
	112	vgadev.tstc = NULL;
	113	vgadev.start = video_start;
8bde7f77	114
52cb4d4f	115	error = stdio_register (&vgadev);
c7de829c WD	116
	117	if (error == 0)
	118	{
	119	char *s = getenv("stdout");
	120	if (s && strcmp(s, VIDEO_NAME)==0)
	121	{
	122	if (overwrite_console()) return 1;
	123	error = console_assign(stdout, VIDEO_NAME);
	124	if (error == 0) return 1;
	125	else return error;
	126	}
	127	return 1;
	128	}
	129
	130	return error;
	131	}
	132
	133	int video_init(void)
	134	{
8bde7f77	135	cursor_position = VIDEO_BASE; /* Color text display base */
c7de829c WD	136	cursor_row = 0;
c7de829c WD	137	cursor_col = 0;
8bde7f77 WD	138	current_attr = video_get_attr(); /* Currently selected value for attribute. */
8bde7f77 WD	139	/* video_test(); */
c7de829c WD	140	video_set_color(current_attr);
	141
	142	return 0;
	143	}
	144
	145	void video_set_cursor(int line, int column)
	146	{
	147	unsigned short offset = line*video_numcols + column;
	148	cursor_position = VIDEO_BASE + lineVIDEO_PITCH + column2;
	149	out_byte(0x3D4, 0x0E);
	150	out_byte(0x3D5, offset/256);
	151	out_byte(0x3D4, 0x0F);
	152	out_byte(0x3D5, offset%256);
	153	}
	154
	155	void video_write_char(int character)
	156	{
	157	*cursor_position = character;
	158	*(cursor_position+1) = current_attr;
	159	}
	160
	161	void video_test(void)
	162	{
	163
	164	}
	165
	166	void video_putc(char ch)
	167	{
	168	switch(ch)
	169	{
	170	case '\n':
	171	cursor_col = 0;
	172	cursor_row += 1;
	173	break;
	174	case '\r':
	175	cursor_col = 0;
	176	break;
	177	case '\b':
	178	if (cursor_col) cursor_col--;
	179	else return;
	180	break;
	181	case '\t':
	182	cursor_col = (cursor_col/8+1)*8;
	183	break;
	184	default:
	185	video_write_char(ch);
	186	cursor_col++;
	187	if (cursor_col > VIDEO_COLS-1)
	188	{
	189	cursor_row++;
	190	cursor_col=0;
	191	}
	192	}
	193
	194	if (cursor_row > VIDEO_ROWS-1)
	195	video_scroll(1);
	196	video_set_cursor(cursor_row, cursor_col);
	197	}
	198
	199	void video_scroll(int rows)
	200	{
	201	unsigned short clear = ((unsigned short)current_attr) \| (' '<<8);
	202	unsigned short* addr16 = &((unsigned short )VIDEO_BASE)[(VIDEO_ROWS-rows)VIDEO_COLS];
	203	int i;
204	char *s;
205
206	s = getenv("vga_askscroll");
207	video_scrolls += rows;
208
209	if (video_scrolls >= video_numrows)
210	{
211	if (s && strcmp(s, "yes"))
212	{
213	while (-1 == tstc());
214	}
215
216	video_scrolls = 0;
217	}
218
219
220	memcpy(VIDEO_BASE, VIDEO_BASE+rows(VIDEO_COLS2), (VIDEO_ROWS-rows)(VIDEO_COLS2));
221	for (i = 0 ; i < rows * VIDEO_COLS ; i++)
222	addr16[i] = clear;
223	cursor_row-=rows;
224	cursor_col=0;
225	}
226
227	void video_puts(char *string)
228	{
229	while (*string)
230	{
231	video_putc(*string);
232	string++;
233	}
234	}
235
236	int video_start(void)
237	{
238	return 0;
239	}
240
241	unsigned char video_single_box[] =
242	{
243	218, 196, 191,
244	179, 179,
245	192, 196, 217
246	};
247
248	unsigned char video_double_box[] =
249	{
250	201, 205, 187,
251	186, 186,
252	200, 205, 188
253	};
254
255	unsigned char video_single_title[] =
256	{
257	195, 196, 180, 180, 195
258	};
259
260	unsigned char video_double_title[] =
261	{
262	204, 205, 185, 181, 198
263	};
264
265	#define SINGLE_BOX 0
266	#define DOUBLE_BOX 1
267
268	unsigned char *video_addr(int x, int y)
269	{
270	return VIDEO_BASE + 2(VIDEO_COLSy) + 2*x;
271	}
272
273	void video_bios_print_string(char *s, int x, int y, int attr, int count)
274	{
275	int cattr = current_attr;
276	if (attr != -1) current_attr = attr;
277	video_set_cursor(x,y);
278	while (count)
279	{
280	char c = *s++;
281	if (attr == -1) current_attr = *s++;
282	video_putc(c);
283	count--;
284	}
285	}
286
287	void video_draw_box(int style, int attr, char *title, int separate, int x, int y, int w, int h)
288	{
8bde7f77	289	unsigned char fb, fb2;
c7de829c WD	290	unsigned char *st = (style == SINGLE_BOX)?video_single_box : video_double_box;
	291	unsigned char *ti = (style == SINGLE_BOX)?video_single_title : video_double_title;
	292	int i;
	293
	294	fb = video_addr(x,y);
	295	*(fb) = st[0];
	296	*(fb+1) = attr;
	297	fb += 2;
	298
	299	fb2 = video_addr(x,y+h-1);
	300	*(fb2) = st[5];
	301	*(fb2+1) = attr;
	302	fb2 += 2;
	303
	304	for (i=0; i<w-2;i++)
	305	{
	306	*fb = st[1];
	307	fb++;
	308	*fb = attr;
	309	fb++;
	310
	311	*fb2 = st[6];
	312	fb2++;
	313	*fb2 = attr;
	314	fb2++;
	315
	316	}
	317	*fb = st[2];
	318	*(fb+1) = attr;
	319
	320	*fb2 = st[7];
	321	*(fb2+1) = attr;
	322
	323	fb = video_addr(x, y+1);
	324	fb2 = video_addr(x+w-1, y+1);
	325	for (i=0; i<h-2; i++)
	326	{
	327	*fb = st[3];
	328	(fb+1) = attr; fb += 2VIDEO_COLS;
	329
8bde7f77	330	*fb2 = st[4];
c7de829c WD	331	(fb2+1) = attr; fb2 += 2VIDEO_COLS;
c7de829c WD	332	}
8bde7f77 WD	333
8bde7f77 WD	334	/* Draw title */
c7de829c WD	335	if (title)
	336	{
	337	if (separate == 0)
	338	{
	339	fb = video_addr(x+1, y);
	340	*fb = ti[3];
	341	fb += 2;
	342	*fb = ' ';
	343	fb += 2;
	344	while (*title)
	345	{
	346	fb = title;
	347	fb ++;
	348	*fb = attr;
	349	fb++; title++;
	350	}
	351	*fb = ' ';
	352	fb += 2;
	353	*fb = ti[4];
	354	}
	355	else
	356	{
	357	fb = video_addr(x, y+2);
	358	*fb = ti[0];
	359	fb += 2;
	360	for (i=0; i<w-2; i++)
	361	{
	362	*fb = ti[1];
	363	*(fb+1) = attr;
	364	fb += 2;
	365	}
	366	*fb = ti[2];
	367	*(fb+1) = attr;
	368	fb = video_addr(x+1, y+1);
	369	for (i=0; i<w-2; i++)
	370	{
	371	*fb = ' ';
	372	*(fb+1) = attr;
	373	fb += 2;
	374	}
	375	fb = video_addr(x+2, y+1);
8bde7f77	376
c7de829c WD	377	while (*title)
	378	{
	379	fb = title;
	380	*(fb+1) = attr;
	381	fb += 2;
	382	title++;
	383	}
	384	}
	385	}
	386
	387	}
	388
	389	void video_draw_text(int x, int y, int attr, char *text)
	390	{
	391	unsigned char *fb = video_addr(x,y);
	392	while (*text)
	393	{
	394	fb++ = text++;
	395	*fb++ = attr;
	396	}
	397	}
	398
	399	void video_save_rect(int x, int y, int w, int h, void *save_area, int clearchar, int clearattr)
	400	{
	401	unsigned char save = (unsigned char )save_area;
	402	unsigned char *fb = video_addr(x,y);
	403	int i,j;
	404	for (i=0; i<h; i++)
	405	{
	406	unsigned char *fbb = fb;
	407	for (j=0; j<w; j++)
	408	{
	409	save ++ = fb;
	410	if (clearchar > 0) *fb = clearchar;
	411	fb ++;
	412	save ++ = fb;
	413	if (clearattr > 0) *fb = clearattr;
	414	}
	415	fb = fbb + 2*VIDEO_COLS;
	416	}
	417	}
	418
	419	void video_restore_rect(int x, int y, int w, int h, void *save_area)
8bde7f77	420	{
c7de829c WD	421	unsigned char save = (unsigned char )save_area;
	422	unsigned char *fb = video_addr(x,y);
	423	int i,j;
	424	for (i=0; i<h; i++)
	425	{
	426	unsigned char *fbb = fb;
	427	for (j=0; j<w; j++)
	428	{
	429	fb ++ = save ++;
	430	fb ++ = save ++;
	431	}
	432	fb = fbb + 2*VIDEO_COLS;
	433	}
	434
	435	}
	436
	437	int video_rows(void)
	438	{
	439	return VIDEO_ROWS;
	440	}
	441
	442	int video_cols(void)
	443	{
	444	return VIDEO_COLS;
	445	}
	446
	447	void video_size(int cols, int rows)
	448	{
	449	video_numrows = rows;
	450	video_numcols = cols;
	451	}
	452
	453	void video_clear(void)
	454	{
	455	unsigned short fbb = (unsigned short )0xFD0B8000;
	456	int i,j;
	457	unsigned short val = 0x2000 \| current_attr;
	458
	459	for (i=0; i<video_rows(); i++)
	460	{
	461	for (j=0; j<video_cols(); j++)
	462	{
	463	*fbb++ = val;
	464	}
	465	}
	466	video_set_cursor(0,0);
	467	cursor_row = 0;
	468	cursor_col = 0;
	469	}
	470
	471	#ifdef EASTEREGG
	472	int video_easteregg_active = 0;
	473
	474	void video_easteregg(void)
	475	{
	476	video_easteregg_active = 1;
	477	}
	478	#endif
	479
c7de829c WD	480	extern block_dev_desc_t * ide_get_dev(int dev);
	481	extern char version_string[];
	482
	483	void video_banner(void)
	484	{
	485	block_dev_desc_t *ide;
	486	int i;
	487	char *s;
	488	int maxdev;
8bde7f77	489
c7de829c WD	490
	491	if (video_inited == 0) return;
	492	#ifdef EASTEREGG
	493	if (video_easteregg_active)
	494	{
	495	prompt_string="";
	496	video_clear();
	497	printf("\n");
	498	printf(" ** COMMODORE 64 BASIC X2 **\n\n");
	499	printf(" 64K RAM SYSTEM 38911 BASIC BYTES FREE\n\n");
	500	printf("READY\n");
	501	}
	502	else
	503	{
	504	#endif
	505	s = getenv("ide_maxbus");
	506	if (s)
	507	maxdev = atoi(s) * 2;
	508	else
	509	maxdev = 4;
	510
	511	s = getenv("stdout");
	512	if (s && strcmp(s, "serial") == 0)
	513	return;
	514
	515	video_clear();
	516	printf("%s\n\nCPU: ", version_string);
	517	checkcpu();
7c7a23bd WD	518	printf("DRAM: %ld MB\n", gd->bd->bi_memsize/(1024*1024));
7c7a23bd WD	519	printf("FSB: %ld MHz\n", gd->bd->bi_busfreq/1000000);
c7de829c WD	520
	521	printf("\n---- Disk summary ----\n");
	522	for (i = 0; i < maxdev; i++)
	523	{
	524	ide = ide_get_dev(i);
	525	printf("Device %d: ", i);
	526	dev_print(ide);
	527	}
	528
	529	/*
	530	video_draw_box(SINGLE_BOX, 0x0F, "Test 1", 0, 0,18, 72, 4);
	531	video_draw_box(DOUBLE_BOX, 0x0F, "Test 2", 1, 4,10, 50, 6);
	532	video_draw_box(DOUBLE_BOX, 0x0F, "Test 3", 0, 40, 3, 20, 5);
	533
	534	video_draw_text(1, 4, 0x2F, "Highlighted options");
	535	video_draw_text(1, 5, 0x0F, "Non-selected option");
	536	video_draw_text(1, 6, 0x07, "disabled option");
	537	*/
	538	#ifdef EASTEREGG
	539	}
	540	#endif
	541	}