NetBSD/sys/arch/arm32/vidc/console/vidcconsole.c

/* $NetBSD: vidcconsole.c,v 1.14 1997/01/28 04:20:58 mark Exp $ */

/*
 * Copyright (c) 1996 Mark Brinicombe
 * Copyright (c) 1996 Robert Black
 * Copyright (c) 1994-1995 Melvyn Tang-Richardson
 * Copyright (c) 1994-1995 RiscBSD kernel team
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the RiscBSD kernel team
 * 4. The name of the company nor the name of the author may be used to
 *    endorse or promote products derived from this software without specific
 *    prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE RISCBSD TEAM ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 *
 * RiscBSD kernel project
 *
 * vidcconsole.c
 *
 * Console assembly functions
 *
 * Created      : 17/09/94
 * Last updated : 07/02/96
 */

/* woo */

#include <sys/cdefs.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/ioctl.h>
#include <sys/conf.h>
#include <sys/tty.h>
#include <sys/device.h>
#include <sys/map.h>
#include <sys/proc.h>
#include <sys/user.h>
#include <sys/syslog.h>
#include <sys/resourcevar.h>
#include <vm/vm.h>
#include <vm/vm_kern.h>

#include <machine/cpu.h>
#include <machine/param.h>
#include <machine/katelib.h>
#include <machine/cpu.h>
#include <machine/bootconfig.h>
#include <machine/iomd.h>
#include <machine/irqhandler.h>
#include <machine/pmap.h>
#include <machine/vidc.h>
#include <machine/vconsole.h>

#include <arm32/dev/console/fonts/font_normal.h>
#include <arm32/dev/console/fonts/font_bold.h>
#include <arm32/dev/console/fonts/font_italic.h>

#define BCOPY bcopy

#ifndef DEBUGTERM
#define dprintf(x)	;
#endif

/* Options */
#define ACTIVITY_WARNING
#define SCREENBLANKER
#undef INVERSE_CONSOLE

/* Internal defines only */
#define DEVLOPING
#undef SELFTEST
#undef SILLIES

#ifdef SILLIES
#define PRETTYCURSOR
#endif

extern int physcon_major;
extern struct vconsole *vconsole_default;

extern videomemory_t videomemory;

extern font_struct font_terminal_14normal;
extern font_struct font_terminal_14bold;
extern font_struct font_terminal_14italic;

#define font_normal	font_terminal_14normal
#define font_bold	font_terminal_14bold
#define font_italic	font_terminal_14italic

#define VIDC_ENGINE_NAME "VIDC"
#define R_DATA ((struct vidc_info *)vc->r_data)
#define MODE (R_DATA->mode)

static int cold_init = 0;

extern struct vconsole *vconsole_master;
extern struct vconsole *vconsole_current;
static struct vidc_mode vidc_initialmode;
static struct vidc_mode *vidc_currentmode;

unsigned int dispstart;
unsigned int dispsize;
unsigned int dispbase;
unsigned int dispend;
unsigned int ptov;
unsigned int transfersize;
unsigned int vmem_base;
unsigned int phys_base;
int	flash;
int	cursor_flash;
char *cursor_normal;
char *cursor_transparent;
int p_cursor_normal;
int p_cursor_transparent;

/* Local function prototypes */
static void	vidcconsole_cls		__P((struct vconsole *vc));
static int	vidc_cursor_init	__P((struct vconsole *vc));
int		vidcconsole_cursorintr	__P((void *arg));
int		vidcconsole_flashintr	__P((void *arg));
static int	vidcconsole_textpalette	__P((struct vconsole *vc));
static void	vidcconsole_render	__P((struct vconsole *vc, char c));
static void	vidcconsole_mode	__P((struct vconsole *vc, struct vidc_mode *mode));
int		vidcconsole_flash	__P((struct vconsole *vc, int flash));
int		vidcconsole_cursorflash	__P((struct vconsole *vc, int flash));
int		vidcconsole_flash_go	__P((struct vconsole *vc));
int		vidcconsole_blank	__P((struct vconsole *vc, int /*type*/));
void 		vidcconsole_putchar	__P((dev_t dev, char c, struct vconsole *vc));
extern int	vidcconsolemc_cls	__P((unsigned char *, unsigned char *, int));

struct vconsole *vconsole_spawn_re	__P((dev_t dev, struct vconsole *vc));

/*
 * This will be called while still in the mode that we were left
 * in after exiting from riscos
 */

static irqhandler_t cursor_ih;
irqhandler_t flash_ih;

#ifndef HARDCODEDMODES
/* The table of modes is separately compiled */
extern struct vidc_mode vidcmodes[];
#else /* HARDCODEDMODES */
#ifdef RC7500
static struct vidc_mode vidcmodes[] = {
	{31500,/**/48,  84, 30, 640,  30, 0,/**/3, 28, 0, 480, 0, 9,/**/0,/**/3},
	{36000,/**/72,  84, 34, 800,  34, 0,/**/2, 22, 0, 600, 0, 1,/**/0,/**/3},
};
#else /* RC7500 */
/* We have a hard compiled table of modes and a list of definable modes */
static struct vidc_mode vidcmodes[] = {
	{32500,/**/52,  64, 30, 640,  30, 14,/**/3, 28, 0, 480, 0, 9,/**/0,/**/3},
	{65000,/**/128, 36, 60, 1024, 60 ,36,/**/6, 29, 0, 768, 0, 3,/**/0,/**/3},
};
#endif /* RC7500 */
#endif /* HARDCODEDMODES */

#ifdef RC7500
struct vfreq {
	u_int frqcon;
	int freq;
};

static struct vfreq vfreq[] = {
	{ VIDFREQ_25_18, 25175},
	{ VIDFREQ_25_18, 25180},
	{ VIDFREQ_28_32, 28320},
	{ VIDFREQ_31_50, 31500},
	{ VIDFREQ_36_00, 36000},
	{ VIDFREQ_40_00, 40000},
	{ VIDFREQ_44_90, 44900},
	{ VIDFREQ_50_00, 50000},
	{ VIDFREQ_65_00, 65000},
	{ VIDFREQ_72_00, 72000},
	{ VIDFREQ_75_00, 75000},
	{ VIDFREQ_77_00, 77000},
	{ VIDFREQ_80_00, 80000},
	{ VIDFREQ_94_50, 94500},
	{ VIDFREQ_110_0, 110000},
	{ VIDFREQ_120_0, 120000},
	{ VIDFREQ_130_0, 130000}
};

#define NFREQ	(sizeof (vfreq) / sizeof(struct vfreq))
u_int vfreqcon = 0;
#else /* RC7500 */

struct fsyn {
	int r, v, f;
};

static struct fsyn fsyn_pref[] = {
	{ 6,   2,  8000 },
	{ 4,   2, 12000 },
	{ 3,   2, 16000 },
	{ 2,   2, 24000 },
	{ 41, 43, 25171 },
	{ 50, 59, 28320 },
	{ 3,   4, 32000 },
	{ 2,   3, 36000 },
	{ 31, 58, 44903 },
	{ 12, 35, 70000 },
	{ 0,   0, 00000 }
};
#endif /* RC7500 */

/*#define mod(x)	(((x) > 0) ? (x) : (-x))*/

static __inline int
mod(int n)
{
	if (n < 0)
		return(-n);
	else
		return(n);
}

static int
vidcconsole_coldinit(vc)
	struct vconsole *vc;
{
	int found;
	int loop;

	/* Blank out the cursor */

	vidc_write(VIDC_CP1, 0x0);
	vidc_write(VIDC_CP2, 0x0);
	vidc_write(VIDC_CP3, 0x0);

	/* Try to determine the current mode */
	vidc_initialmode.hder = bootconfig.width+1;
	vidc_initialmode.vder = bootconfig.height+1;
	vidc_initialmode.bitsperpixel = 1 << bootconfig.bitsperpixel;

	dispbase = vmem_base = dispstart = videomemory.vidm_vbase;
	phys_base = videomemory.vidm_pbase;

/* Nut - should be using videomemory.vidm_size - mark */

	if (videomemory.vidm_type == VIDEOMEM_TYPE_DRAM) {
		dispsize = videomemory.vidm_size;
		transfersize = 16;
	} else {
		dispsize = bootconfig.vram[0].pages * NBPG;
		transfersize = dispsize >> 10;
	}
    
	ptov = dispbase - phys_base;

	dispend = dispstart+dispsize;
 
	vidc_currentmode = &vidcmodes[0];
	loop = 0;
	found = 0;
  
	while (vidcmodes[loop].pixel_rate != 0) {
  		if (vidcmodes[loop].hder == (bootconfig.width + 1)
  		    && vidcmodes[loop].vder == (bootconfig.height + 1)
		    && vidcmodes[loop].frame_rate == bootconfig.framerate) {
			vidc_currentmode = &vidcmodes[loop];
			found = 1;
		}
		++loop;
	}

	if (!found) {
		vidc_currentmode = &vidcmodes[0];
		loop = 0;
		found = 0;

		while (vidcmodes[loop].pixel_rate != 0) {
			if (vidcmodes[loop].hder == (bootconfig.width + 1)
 			    && vidcmodes[loop].vder == (bootconfig.height + 1)) {
 				vidc_currentmode = &vidcmodes[loop];
 				found = 1;
 			}
 			++loop;
 		}
	}

	/* vidc_currentmode = &vidcmodes[0]; */
	vidc_currentmode->bitsperpixel = 1 << bootconfig.bitsperpixel;

	if (vc)
		R_DATA->flash = R_DATA->cursor_flash = 0;

	dispstart = dispbase;
	dispend = dispstart+dispsize;
    
	WriteWord(IOMD_VIDINIT, dispstart-ptov);
	WriteWord(IOMD_VIDSTART, dispstart-ptov);
	WriteWord(IOMD_VIDEND, (dispend-transfersize)-ptov);
	return 0;
}

struct vidc_mode newmode;

static const int bpp_mask_table[] = {
	0,  /* 1bpp */
	1,  /* 2bpp */
	2,  /* 4bpp */
	3,  /* 8bpp */
	4,  /* 16bpp */
	6   /* 32bpp */
};

void
vidcconsole_mode(vc, mode)
	struct vconsole *vc;
	struct vidc_mode *mode;
{    
	register int acc;
	int bpp_mask;
        int log_bpp;
        int tmp_bpp;
        int ereg;

#ifndef RC7500
	int best_r, best_v, best_match;
#endif

/*
 * Find out what bit mask we need to or with the vidc20 control register
 * in order to generate the desired number of bits per pixel.
 * log_bpp is log base 2 of the number of bits per pixel.
 */

	tmp_bpp = mode->bitsperpixel;
	if (tmp_bpp < 1 || tmp_bpp > 32)
		tmp_bpp = 8; /* Set 8 bpp if we get asked for something silly */

	for (log_bpp = 0; tmp_bpp != 1; tmp_bpp >>= 1)
		log_bpp++;

	bpp_mask = bpp_mask_table[log_bpp];

/*
	printf ( "res = (%d, %d) rate = %d\n", mode->hder, mode->vder, mode->pixel_rate );
*/

	newmode = *mode;
	vidc_currentmode = &newmode;

#ifdef RC7500
	{
		int i;
		int old, new;
		u_int nfreq;

		old = vfreq[0].freq;
		nfreq = vfreq[0].frqcon;
		for (i = 0; i < (NFREQ - 1); i++) {
			new = vfreq[i].freq - mode->pixel_rate;
			if (new < 0)
				new = -new;
			if (new < old) {
				nfreq = vfreq[i].frqcon;
				old = new;
			}
			if (new == 0)
				break;
		}
		nfreq |= (vfreqcon & 0xf0);
		vfreqcon = nfreq;
	}
#else /* RC7500 */
    /* Program the VCO Look up a preferred value before choosing one */
	{
		int least_error = mod(fsyn_pref[0].f - vidc_currentmode->pixel_rate);
		int counter;
		best_r = fsyn_pref[0].r;
		best_match = fsyn_pref[0].f;
		best_v = fsyn_pref[0].v;
        
	/* Look up */
        
		counter=0;
        
		while (fsyn_pref[counter].r != 0) {
			if (least_error > mod(fsyn_pref[counter].f - vidc_currentmode->pixel_rate)) {
				best_match = fsyn_pref[counter].f;
				least_error = mod(fsyn_pref[counter].f - vidc_currentmode->pixel_rate);
				best_r = fsyn_pref[counter].r;
				best_v = fsyn_pref[counter].v;
			}
			counter++;
		}

		if (least_error > 0) { /* Accuracy of 1000Hz */
			int r, v, f;
			for (v = 63; v > 0; v--)
				for (r = 63; r > 0; r--) {
					f = (v * VIDC_FREF/1000) / r;
					if (least_error >= mod(f - vidc_currentmode->pixel_rate)) {
						best_match = f;
						least_error = mod(f - vidc_currentmode->pixel_rate);
						best_r = r;
						best_v = v;
					}
				}
		}
    
		if (best_r > 63) best_r=63;
		if (best_v > 63) best_v=63;
		if (best_r < 1)  best_r= 1;
		if (best_v < 1)  best_v= 1;
    
	}
/*
	printf ( "best_v = %d  best_r = %d best_f = %d\n", best_v, best_r, best_match );
*/
#endif /* RC7500 */

	if (vc==vconsole_current) {
#ifdef RC7500
		outb(FREQCON, vfreqcon);
		/*
		 * Need to program the control register first.
		 */
		if (dispsize>1024*1024) {
			if (vidc_currentmode->hder>=800)
				vidc_write(VIDC_CONREG, 7<<8 | bpp_mask<<5);
			else
				vidc_write(VIDC_CONREG, 6<<8 | bpp_mask<<5);
		} else {
			vidc_write(VIDC_CONREG, 7<<8 | bpp_mask<<5);
		}

		/*
		 * We don't use VIDC_FSYNREG.  Program it low.
		 */
		vidc_write(VIDC_FSYNREG, 0x2020);
#else /* RC7500 */
		vidc_write(VIDC_FSYNREG, (best_v-1)<<8 | (best_r-1)<<0);
#endif /* RC7500 */
		acc=0;
		acc+=vidc_currentmode->hswr;	vidc_write(VIDC_HSWR, (acc - 8 ) & (~1));
		acc+=vidc_currentmode->hbsr;	vidc_write(VIDC_HBSR, (acc - 12) & (~1));
		acc+=vidc_currentmode->hdsr;	vidc_write(VIDC_HDSR, (acc - 18) & (~1));
		acc+=vidc_currentmode->hder;	vidc_write(VIDC_HDER, (acc - 18) & (~1));
		acc+=vidc_currentmode->hber;	vidc_write(VIDC_HBER, (acc - 12) & (~1));
		acc+=vidc_currentmode->hcr;	vidc_write(VIDC_HCR,  (acc - 8 ) & (~3));

		acc=0;
		acc+=vidc_currentmode->vswr;	vidc_write(VIDC_VSWR, (acc - 1));
		acc+=vidc_currentmode->vbsr;	vidc_write(VIDC_VBSR, (acc - 1));
		acc+=vidc_currentmode->vdsr;	vidc_write(VIDC_VDSR, (acc - 1));
		acc+=vidc_currentmode->vder;	vidc_write(VIDC_VDER, (acc - 1));
		acc+=vidc_currentmode->vber;	vidc_write(VIDC_VBER, (acc - 1));
		acc+=vidc_currentmode->vcr;	vidc_write(VIDC_VCR,  (acc - 1));

#ifdef RC7500
		vidc_write(VIDC_DCTL, vidc_currentmode->hder>>2 | 1<<16 | 1<<12);
		if (vidc_currentmode->hder>=800)
			vidc_write(VIDC_EREG, 0x41<<12);
		else
			vidc_write(VIDC_EREG, 0x51<<12);
#else
		WriteWord(IOMD_FSIZE, vidc_currentmode->vcr
		    + vidc_currentmode->vswr
		    + vidc_currentmode->vber
		    + vidc_currentmode->vbsr - 1);

		if (dispsize <= 1024*1024)
			vidc_write(VIDC_DCTL, vidc_currentmode->hder>>2 | 1<<16 | 1<<12);
		else
			vidc_write(VIDC_DCTL, vidc_currentmode->hder>>2 | 3<<16 | 1<<12);

		ereg = 1<<12;
		if (vidc_currentmode->sync_pol & 0x01)
			ereg |= 1<<16;
		if (vidc_currentmode->sync_pol & 0x02)
			ereg |= 1<<18;
		vidc_write(VIDC_EREG, ereg);
		if (dispsize > 1024*1024) {
			if (vidc_currentmode->hder >= 800)
 				vidc_write(VIDC_CONREG, 7<<8 | bpp_mask<<5);
			else
				vidc_write(VIDC_CONREG, 6<<8 | bpp_mask<<5);
		} else {
			vidc_write(VIDC_CONREG, 7<<8 | bpp_mask<<5);
		}
#endif
	}

	R_DATA->mode = *vidc_currentmode;
	R_DATA->screensize = R_DATA->XRES * R_DATA->YRES * R_DATA->BITSPERPIXEL/8;
	R_DATA->pixelsperbyte = 8 / R_DATA->BITSPERPIXEL;
	R_DATA->frontporch = MODE.hswr + MODE.hbsr + MODE.hdsr;
	R_DATA->topporch = MODE.vswr + MODE.vbsr + MODE.vdsr;
	R_DATA->bytes_per_line = R_DATA->XRES *
	    R_DATA->font->y_spacing/R_DATA->pixelsperbyte;
	R_DATA->bytes_per_scroll = (vc->ycur % R_DATA->font->y_spacing)
	    * vc->xcur / R_DATA->pixelsperbyte;
	R_DATA->text_width = R_DATA->XRES / R_DATA->font->x_spacing;
	R_DATA->text_height = R_DATA->YRES / R_DATA->font->y_spacing;
	vc->xchars = R_DATA->text_width;
	vc->ychars = R_DATA->text_height;
}

void
physcon_display_base(base)
	u_int base;
{
	dispstart = dispstart-dispbase + base;
	dispbase = vmem_base = base;
	dispend = base + dispsize;
	ptov = dispbase - phys_base;
}

static struct vidc_info masterinfo;
static int cursor_init = 0;

int
vidcconsole_init(vc)
	struct vconsole *vc;
{
	struct vidc_info *new;
	int loop;

	if (cold_init == 0) {
		vidcconsole_coldinit(vc);
	} else {
		if (cursor_init == 0)
			vidcconsole_flash_go(vc);
	}

	/*
	 * If vc->r_data is initialised then this means that the previous
	 * render engine on this vconsole was not freed properly.  I should
	 * not try to clear it up, since I could panic the kernel.  Instead
	 * I forget about its memory, which could cause a memory leak, but
	 * this would be easily detectable and fixable
	 */
     
#ifdef SELFTEST
	if (vc->r_data != 0) {
		printf( "*********************************************************\n" );
		printf( "You have configured SELFTEST mode in the console driver\n" );
		printf( "vc->rdata non zero.  This could mean a new console\n"      );
		printf( "render engine has not freed up its data structure when\n"  );
		printf( "exiting.\n" 						     );
		printf( "DO NOT COMPILE NON DEVELOPMENT KERNELS WITH SELFTEST\n"    );
		printf( "*********************************************************" );
    	}
#endif

	if (vc == vconsole_master) {
		vc->r_data = (char *)&masterinfo;
	} else {
		MALLOC((vc->r_data), char *, sizeof(struct vidc_info),
		    M_DEVBUF, M_NOWAIT);
	}
    
	if (vc->r_data==0)
		panic("render engine initialisation failed. CLEAN THIS UP!");

	R_DATA->normalfont = &font_normal;
	R_DATA->italicfont = &font_italic;
	R_DATA->boldfont   = &font_bold;
	R_DATA->font = R_DATA->normalfont;

	vidcconsole_mode(vc, vidc_currentmode);
	R_DATA->scrollback_end = dispstart;
    
	new = (struct vidc_info *)vc->r_data;

	R_DATA->text_colours = 1 << R_DATA->BITSPERPIXEL;
	if (R_DATA->text_colours > 8) R_DATA->text_colours = 8;
    
#ifdef INVERSE_CONSOLE
	R_DATA->n_backcolour = R_DATA->text_colours - 1;
	R_DATA->n_forecolour = 0;
#else
	R_DATA->n_backcolour = 0;
	R_DATA->n_forecolour = R_DATA->text_colours - 1;
#endif

	R_DATA->backcolour = R_DATA->n_backcolour;
	R_DATA->forecolour = R_DATA->n_forecolour;

	R_DATA->forefillcolour = 0;
	R_DATA->backfillcolour = 0;

	R_DATA->bold = 0;
	R_DATA->reverse = 0;

	for (loop = 0; loop < R_DATA->pixelsperbyte; ++loop) {
		R_DATA->forefillcolour |= (R_DATA->forecolour <<
		    loop * R_DATA->BITSPERPIXEL);
		R_DATA->backfillcolour |= (R_DATA->backcolour <<
		    loop * R_DATA->BITSPERPIXEL);
	}

	R_DATA->fast_render = R_DATA->forecolour | (R_DATA->backcolour<<8) | (R_DATA->font->pixel_height<<16);
	R_DATA->blanked=0;
	vc->BLANK(vc, BLANK_NONE);
    
	if (vc == vconsole_current)
		vidcconsole_textpalette(vc);


	if (cold_init == 0) {
		vidc_write(VIDC_CP1, 0x0);
		vidc_write(VIDC_CP2, 0x0);
		vidc_write(VIDC_CP3, 0x0);
	} else
		vidc_cursor_init(vc) ;

	cold_init=1;
	return 0;
}

void
vidcconsole_reinit()
{
	vidcconsole_coldinit(vconsole_current);
	vidcconsole_mode(vconsole_current, vidc_currentmode);
}

void
vidcconsole_putchar(dev, c, vc)
	dev_t dev;
	char c;
	struct vconsole *vc;
{
	vc->PUTSTRING(&c, 1, vc);
}

int
vidcconsole_spawn(vc)
	struct vconsole *vc;
{
	vc->xchars = R_DATA->text_width;
	vc->ychars = R_DATA->text_height;
	vc->xcur = 0;
	vc->ycur = 0;
	vc->flags = 0;
	return 0;
}

int
vidcconsole_redraw(vc, x, y, a, b)
	struct vconsole *vc;
	int x, y;
	int a, b;
{
	int xs, ys;
	struct vidc_state vidc;
	font_struct *p_font = R_DATA->font;
	int p_forecol = R_DATA->forecolour;
	int p_backcol = R_DATA->backcolour;
	if (x<0) x=0;
	if (y<0) y=0;
	if (x>(vc->xchars-1)) x=vc->xchars-1;
	if (y>(vc->ychars-1)) x=vc->ychars-1;

	if (a>(vc->xchars-1)) a=vc->xchars-1;
	if (b>(vc->ychars-1)) b=vc->ychars-1;

	if (a<x) a=x;
	if (b<y) b=y;


	vidc = *vidc_current;
	xs=vc->xcur;
	ys=vc->ycur;

	vc->xcur = 0;
	vc->ycur = 0;
 	if ((vc->flags&LOSSY) == 0)
	{
                register int c;
                /* This has *GOT* to be turboed */
                for ( vc->ycur=y; vc->ycur<=b; vc->ycur++ )
                {
                        for ( vc->xcur=x; vc->xcur<=a; vc->xcur++ )
                        {
                                c = (vc->charmap)[vc->xcur+vc->ycur*vc->xchars];
            			if ((c&BOLD)!=0)
					R_DATA->font = R_DATA->boldfont;
				else	
					R_DATA->font = R_DATA->normalfont;
				R_DATA->fast_render = ((c>>8)&0x7)|(((c>>11)&0x7)<<8)| (R_DATA->font->pixel_height<<16);
				if ( c & BLINKING )
					 c+=1<<8 | 1;
				if ((c&BLINKING)!=0) {
				    R_DATA->forecolour+=16;
				    R_DATA->backcolour+=16;
				}
                                vidcconsole_render( vc, c&0xff );
                        }
                }
	}
	vc->xcur = xs;
	vc->ycur = ys;
	R_DATA->forecolour = p_forecol;
	R_DATA->backcolour = p_backcol;
	R_DATA->font = p_font;
	return 0;
}


int
vidcconsole_swapin(vc)
	struct vconsole *vc;
{
	register int counter;
	int xs, ys;
	struct vidc_state vidc;
	font_struct *p_font = R_DATA->font;
	int p_forecol = R_DATA->forecolour;
	int p_backcol = R_DATA->backcolour;

#ifdef ACTIVITY_WARNING
	vconsole_pending = 0;
#endif
	vidc_write ( VIDC_CP1, 0x0 );

	vidc = *vidc_current;
	vidc_write ( VIDC_PALREG, 0x00000000 );
	for ( counter=0; counter<255; counter++ )
		vidc_write ( VIDC_PALETTE, 0x00000000 );
	xs=vc->xcur;
	ys=vc->ycur;
/*TODO This needs to be vidc_restore (something) */
        vidcconsole_mode ( vc, &MODE );

	vc->xcur = 0;
	vc->ycur = 0;
 	if ( (vc->flags&LOSSY) == 0 )
	{
                register int c;
                /* This has *GOT* to be turboed */
                for ( vc->ycur=0; vc->ycur<vc->ychars; vc->ycur++ )
                {
                        for ( vc->xcur=0; vc->xcur<vc->xchars; vc->xcur++ )
                        {
                                c = (vc->charmap)[vc->xcur+vc->ycur*vc->xchars];
            			if ((c&BOLD)!=0)
					R_DATA->font = R_DATA->boldfont;
				else	
					R_DATA->font = R_DATA->normalfont;
/*
    				R_DATA->forecolour = ((c>>8)&0x7);
 				R_DATA->backcolour = ((c>>11)&0x7);
*/
				R_DATA->fast_render = ((c>>8)&0x7)|(((c>>11)&0x7)<<8)| (R_DATA->font->pixel_height<<16);
				if ( c & BLINKING )
					c+=1<<8 | 1;
				if ((c&BLINKING)!=0)
				{
				    R_DATA->forecolour+=16;
				    R_DATA->backcolour+=16;
				}
                                vidcconsole_render( vc, c&0xff );
                        }
                }
	}
	else
	{
	    vc->CLS ( vc );
	}

	if ( vc->vtty==1 )
	{
	    vc->xcur = xs;
	    vc->ycur = ys;
	    vidcconsole_textpalette ( vc );
	    vidc_write ( VIDC_CP1, 0xffffff );
 	    R_DATA->forecolour = p_forecol;
	    R_DATA->backcolour = p_backcol;
	    R_DATA->font = p_font;
	}
/* Make the cursor blank */
        WriteWord(IOMD_CURSINIT,p_cursor_transparent);
	return 0;

}

int
vidcconsole_mmap(vc, offset, nprot)
	struct vconsole *vc;
	int offset;
	int nprot;
{
	if (offset > videomemory.vidm_size)
		return (-1);
	return(arm_byte_to_page(((videomemory.vidm_pbase) + (offset))));
}

extern void vidcconsolemc_render __P(( unsigned char *addr, unsigned char *fontaddr,
			      int fast_render, int xres ));

void
vidcconsole_render(vc, c)
	struct vconsole *vc;
	char c;
{
	register unsigned char *fontaddr;
	register unsigned char *addr;

	/* Calculate the font's address */

	fontaddr = R_DATA->font->data
            + ((c-(0x20)) * R_DATA->font->height
            * R_DATA->font->width);

	addr = (unsigned char *)dispstart
            + (vc->xcur * R_DATA->font->x_spacing)
            + (vc->ycur * R_DATA->bytes_per_line);

	vidcconsolemc_render ( addr, fontaddr, R_DATA->fast_render,
    	    R_DATA->XRES );
}

/*
 * Uugh.  vidc graphics dont support scrolling regions so we have to emulate
 * it here.  This would normally require much software scrolling which is
 * horriblly slow, so I'm going to try and do a composite scroll, which
 * causes problems for scrollback but it's less speed critical
 */

void
vidcconsole_scrollup(vc, low, high)
	struct vconsole *vc;
	int low;
	int high;
{
    unsigned char *start, *end;

    if ( ( low==0 ) && ( high==vc->ychars-1 ))
    {
	/* All hardware scroll */
        dispstart+=R_DATA->bytes_per_line;
        if ( dispstart >= dispend )
    	    dispstart -= dispsize;

	high=high+1;	/* Big hack */

        WriteWord(IOMD_VIDINIT, dispstart - ptov );
    }
    else
    {
        char *oldstart=(char *)dispstart;

	/* Composite scroll */

	if ( (high-low) > (vc->ychars>>1) )
	{
	    /* Scroll region greater than half the screen */

            dispstart+=R_DATA->bytes_per_line;
            if ( dispstart >= dispend ) dispstart -= dispsize;

            WriteWord(IOMD_VIDINIT, dispstart - ptov );

	    if ( low!=0 )
	    {
    	        start = (unsigned char *)oldstart;
    	        end=(unsigned char*)oldstart+((low+1) * R_DATA->bytes_per_line);
    	        BCOPY ( start, start+R_DATA->bytes_per_line,
		    end-start-R_DATA->bytes_per_line);
	    }

	    if ( high!=(vc->ychars-1) )
	    {
    	        start =(unsigned char *)dispstart+(high)*R_DATA->bytes_per_line;
    	        end=(unsigned char*)dispstart+((vc->ychars)*R_DATA->bytes_per_line);
    	        BCOPY ( start, start+R_DATA->bytes_per_line,
		    end-start-R_DATA->bytes_per_line);
	    }
	    high++;
	}
	else
	{
	    /* Scroll region less than half the screen */

	    /* NO COMPOSITE SCROLL YET */

	    high++;
	    if (low<0) low=0;
	    if (high>(vc->ychars)) high=vc->ychars;
	    if (low>high) return;	/* yuck */
	    start = (unsigned char *)dispstart + ((low)*R_DATA->bytes_per_line);
	    end = (unsigned char *)dispstart +  ((high)*R_DATA->bytes_per_line);
	    BCOPY ( start+R_DATA->bytes_per_line, start,
		(end-start)-R_DATA->bytes_per_line );
	    R_DATA->scrollback_end = dispstart;
	}
    }
    memset ( (char *) dispstart + ((high-1)*R_DATA->bytes_per_line) ,
	     R_DATA->backfillcolour,
	     R_DATA->bytes_per_line   );
}

void
vidcconsole_scrolldown(vc, low, high)
	struct vconsole *vc;
	int low;
	int high;
{
    unsigned char *start;
    unsigned char *end;

    if ( low<0 ) low = 0;
    if ( high>(vc->ychars-1) ) high=vc->ychars-1;
    
    if ( ( low==0 ) && ( high==vc->ychars-1 ))
    {
        dispstart-=R_DATA->bytes_per_line;

        if ( dispstart < dispbase )
    	    dispstart += dispsize;

        WriteWord(IOMD_VIDINIT, dispstart - ptov );
    }
    else
    {
	if ( ((high-low) > (vc->ychars>>1)) )
	{
high--;
   	    if (high!=(vc->ychars-1))
	    {
	        start =(unsigned char*)dispstart+((high+1)*R_DATA->bytes_per_line);
	        end=(unsigned char*)dispstart+((vc->ychars)*R_DATA->bytes_per_line);
  	        BCOPY ( start+R_DATA->bytes_per_line, start,
	 	    (end-start)-R_DATA->bytes_per_line );
	    }

            dispstart-=R_DATA->bytes_per_line;
            if ( dispstart < dispbase )
    	        dispstart += dispsize;
            WriteWord(IOMD_VIDINIT, dispstart - ptov );
    	    start = (unsigned char *)dispstart + (low * R_DATA->bytes_per_line);

   	    if (low!=0)
	    {
	        end = (unsigned char *)dispstart + ((low+1)*R_DATA->bytes_per_line);
  	        BCOPY ( (char*)(dispstart+R_DATA->bytes_per_line),
			(char *)dispstart,
		    (int)((end-dispstart)-R_DATA->bytes_per_line ));
	    }
	}
        else
	{
    	    start = (unsigned char *)dispstart + (low * R_DATA->bytes_per_line);
    	    end = (unsigned char *)dispstart  + ((high+1) * R_DATA->bytes_per_line);
    	    BCOPY ( start, start+R_DATA->bytes_per_line, end-start-R_DATA->bytes_per_line);
	}

    }
    memset ((char*) dispstart + (low*R_DATA->bytes_per_line) ,
		R_DATA->backfillcolour, R_DATA->bytes_per_line );
}

void
vidcconsole_cls(vc)
	struct vconsole *vc;
{
#ifdef RC7500
	dispstart = dispbase;
	dispend = dispstart+dispsize;
    
	WriteWord ( IOMD_VIDINIT, dispstart-ptov );
	WriteWord ( IOMD_VIDSTART, dispstart-ptov );
	WriteWord ( IOMD_VIDEND, (dispend-transfersize)-ptov );
#endif
    
	vidcconsolemc_cls ( (char *)dispstart, (char *)dispstart+R_DATA->screensize, R_DATA->backfillcolour );
    /*
	memset((char *)dispstart,
		R_DATA->backfillcolour, R_DATA->screensize);
    */  
	vc->xcur = vc->ycur = 0;
}

void
vidcconsole_update(vc)
	struct vconsole *vc;
{
}

static char vidcconsole_name[] = VIDC_ENGINE_NAME;

static int scrollback_ptr = 0;

int
vidcconsole_scrollback(vc)
	struct vconsole *vc;
{
	int temp;

	if (scrollback_ptr==0)
	    scrollback_ptr=dispstart;

	temp = scrollback_ptr;

	scrollback_ptr-=R_DATA->bytes_per_line * (vc->ychars-2);
	
        if ( scrollback_ptr < dispbase )
    	    scrollback_ptr += dispsize;

	if (	(scrollback_ptr>dispstart)&&
		(scrollback_ptr<(dispstart+R_DATA->screensize) ) )
	{
	    scrollback_ptr=temp;
	    return 0;
	}

	vc->r_scrolledback = 1;

        WriteWord(IOMD_VIDINIT, scrollback_ptr - ptov );
	return 0;
}

int
vidcconsole_scrollforward(vc)
	struct vconsole *vc;
{
	register int temp;

	if (scrollback_ptr==0)
	    return 0;
	
	temp = scrollback_ptr;

	scrollback_ptr+=R_DATA->bytes_per_line * (vc->ychars - 2);
	
        if ( scrollback_ptr >= dispend )
    	    scrollback_ptr -= dispsize;

	if ( scrollback_ptr == dispstart )
	{
            WriteWord(IOMD_VIDINIT, scrollback_ptr - ptov );
	    scrollback_ptr=0;
	    vc->r_scrolledback = 0;
	    return 0;
	}

        WriteWord(IOMD_VIDINIT, scrollback_ptr - ptov );
	return 0;
}

int
vidcconsole_scrollbackend(vc)
	struct vconsole *vc;
{
	scrollback_ptr = 0;
        WriteWord(IOMD_VIDINIT, dispstart - ptov );
	vc->r_scrolledback = 0;
	return 0;
}

int
vidcconsole_clreos(vc, code)
	struct vconsole *vc;
	int code;
{
    char *addr;
    char *endofscreen;

    addr = (unsigned char *)dispstart
         + (vc->xcur * R_DATA->font->x_spacing)
         + (vc->ycur * R_DATA->bytes_per_line);

    endofscreen = (unsigned char *)dispstart
         + (vc->xchars * R_DATA->font->x_spacing)
         + (vc->ychars * R_DATA->bytes_per_line);


	switch (code)
	{
		case 0:
    			vidcconsolemc_cls ( addr, 
				(unsigned char *)dispend, 
				R_DATA->backfillcolour );
			if ((unsigned char *)endofscreen > (unsigned char *)dispend) {
				char string[80];
				sprintf(string, "(addr=%08x eos=%08x dispend=%08x dispstart=%08x base=%08x)",
				   (u_int)addr, (u_int)endofscreen, dispend, dispstart, dispbase);
				dprintf(string);
				vidcconsolemc_cls((unsigned char *)dispbase, (unsigned char *)(dispbase + (endofscreen - dispend)), R_DATA->backfillcolour);
			}
			break;

		case 1:
    			vidcconsolemc_cls ( (unsigned char *)dispstart+R_DATA->screensize, 
				addr, 
				R_DATA->backfillcolour );
			break;
			
		case 2:
		default:
			vidcconsole_cls ( vc );
			break;
	}
	return 0;
}

#define VIDC R_DATA->vidc

int
vidcconsole_debugprint(vc)
	struct vconsole *vc;
{
#ifdef	DEVLOPING
    printf ( "VIDCCONSOLE DEBUG INFORMATION\n\n" );
    printf ( "res (%d, %d) charsize (%d, %d) cursor (%d, %d)\n"
							      , R_DATA->XRES, R_DATA->YRES
							      , vc->xchars, vc->ychars, vc->xcur, vc->ycur );
    printf ( "bytes_per_line %d\n"			      , R_DATA->bytes_per_line 		     );
    printf ( "pixelsperbyte  %d\n"			      , R_DATA->pixelsperbyte		     );
    printf ( "dispstart      %08x\n"			      , dispstart 		     );
    printf ( "dispend        %08x\n"			      , dispend 		     );
    printf ( "screensize     %08x\n"			      , R_DATA->screensize 		     );

    printf ( "fontwidth      %08x\n"			      , R_DATA->font->pixel_width 	     );
    printf ( "fontheight     %08x\n"			      , R_DATA->font->pixel_height           );
    printf ( "\n" 										     );
    printf ( "palreg = %08x  bcol    = %08x\n"		      , VIDC.palreg, VIDC.bcol		     );
    printf ( "cp1    = %08x  cp2     = %08x  cp3    = %08x\n" , VIDC.cp1, VIDC.cp2, VIDC.cp3         );
    printf ( "hcr    = %08x  hswr    = %08x  hbsr   = %08x\n" , VIDC.hcr, VIDC.hswr, VIDC.hbsr       );
    printf ( "hder   = %08x  hber    = %08x  hcsr   = %08x\n" , VIDC.hder, VIDC.hber, VIDC.hcsr      );
    printf ( "hir    = %08x\n"				      , VIDC.hir 			     );
    printf ( "vcr    = %08x  vswr    = %08x  vbsr   = %08x\n" , VIDC.vcr, VIDC.vswr, VIDC.vbsr       );
    printf ( "vder   = %08x  vber    = %08x  vcsr   = %08x\n" , VIDC.vder, VIDC.vber, VIDC.vcsr      );
    printf ( "vcer   = %08x\n"				      , VIDC.vcer 			     );
    printf ( "ereg   = %08x  fsynreg = %08x  conreg = %08x\n" , VIDC.ereg, VIDC.fsynreg, VIDC.conreg );
    printf ( "\n" );
    printf ( "flash %08x, cursor_flash %08x", R_DATA->flash, R_DATA->cursor_flash );
#else
    printf ( "VIDCCONSOLE - NO DEBUG INFO\n" );
#endif
    return 0;
}

#ifdef NICE_UPDATE
static int need_update = 0;

void
vidcconsole_updatecursor(arg)
	void *arg;
{
	struct vconsole *vc = vconsole_current;

	vidc_write(VIDC_HCSR, R_DATA->frontporch-17+ (vc->xcur)*R_DATA->font->pixel_width );
	vidc_write(VIDC_VCSR, R_DATA->topporch-2+ (vc->ycur+1)*R_DATA->font->pixel_height-2 + 3
	    - R_DATA->font->pixel_height);
	vidc_write(VIDC_VCER, R_DATA->topporch-2+ (vc->ycur+3)*R_DATA->font->pixel_height+2 + 3 );
	return;
}

int
vidcconsole_cursorupdate(vc)
	struct vconsole *vc;
{
    timeout ( vidcconsole_updatecursor, NULL, 20 );
    return 0;
}

#else

static int
vidcconsole_cursorupdate(vc)
	struct vconsole *vc;
{
	vidc_write(VIDC_HCSR, R_DATA->frontporch-17+ (vc->xcur)*R_DATA->font->pixel_width );
	vidc_write(VIDC_VCSR, R_DATA->topporch-2+ (vc->ycur+1)*R_DATA->font->pixel_height-2 + 3
	    - R_DATA->font->pixel_height);
	vidc_write(VIDC_VCER, R_DATA->topporch-2+ (vc->ycur+3)*R_DATA->font->pixel_height+2 + 3 );
	return (0);
}

#endif

#define DEFAULT_CURSORSPEED (25)

static int CURSORSPEED = DEFAULT_CURSORSPEED;

static int
vidcconsole_cursorflashrate(vc, rate)
	struct vconsole *vc;
	int rate;
{
	CURSORSPEED = 60/rate;
	return(0);
}

static int cursorcounter=DEFAULT_CURSORSPEED;
static int flashcounter=DEFAULT_CURSORSPEED;
#ifdef PRETTYCURSOR
static int pretty=0xff;
#endif

static int cursor_col = 0x0;

int
vidcconsole_cursorintr(arg)
	void *arg;
{
	struct vconsole *vc = arg;
	if ( cursor_flash==0 )
		return 0;

	/*
	 * We don't need this.
	 */
#ifndef RC7500
	if (vconsole_blankcounter >= 0)
		vconsole_blankcounter--;

	if (vconsole_blankcounter == 0) {
		vconsole_blankcounter=vconsole_blankinit;
		vidcconsole_blank ( vc, BLANK_OFF );
	}
#endif

	cursorcounter--;
	if (cursorcounter<=0) {
		cursorcounter=CURSORSPEED;
		cursor_col = cursor_col ^ 0xffffff;
#ifdef ACTIVITY_WARNING
		if (vconsole_pending)  {
			if ( cursor_col==0 )
				WriteWord(IOMD_CURSINIT,p_cursor_transparent);
		        else
				WriteWord(IOMD_CURSINIT,p_cursor_normal);
			vidc_write ( VIDC_CP1, cursor_col&0xff );
		} else
#endif
		{
			if ( cursor_col==0 )
				WriteWord(IOMD_CURSINIT,p_cursor_transparent);
			else
				WriteWord(IOMD_CURSINIT,p_cursor_normal);
			vidc_write ( VIDC_CP1, 0xffffff );
		}
	}
	return(0);	/* Pass interrupt on down the chain */
}

int
vidcconsole_flashintr(arg)
	void *arg;
{
	struct vconsole *vc = arg;
	if ( flash==0 )
		return 0;

	flashcounter--;
	if (flashcounter<=0) {
		flashcounter=CURSORSPEED;
		if ( cursor_col == 0 ) {

			vidc_write(VIDC_PALREG, 0x00000010);
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(255,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0, 255,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(255, 255,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0, 255));
			vidc_write(VIDC_PALETTE, VIDC_COL(255,   0, 255));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0, 255, 255));
			vidc_write(VIDC_PALETTE, VIDC_COL(255, 255, 255));
			vidc_write(VIDC_PALETTE, VIDC_COL(128, 128, 128));
			vidc_write(VIDC_PALETTE, VIDC_COL(255, 128, 128));
			vidc_write(VIDC_PALETTE, VIDC_COL(128, 255, 128));
			vidc_write(VIDC_PALETTE, VIDC_COL(255, 255, 128));
			vidc_write(VIDC_PALETTE, VIDC_COL(128, 128, 255));
			vidc_write(VIDC_PALETTE, VIDC_COL(255, 128, 255));
			vidc_write(VIDC_PALETTE, VIDC_COL(255, 255, 255));
		} else {
			vidc_write(VIDC_PALREG, 0x00000010);
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
			vidc_write(VIDC_PALETTE, VIDC_COL(  0,   0,   0));
		}
	}
	return(0);	/* Pass interrupt on down the chain */
}

static int
vidc_cursor_init(vc)
	struct vconsole *vc;
{
	static char *cursor_data = NULL;
	int counter;
	int line;

	if (!cursor_data) {
		/* Allocate cursor memory first time round */

		cursor_data = (char *)kmem_alloc(kernel_map, NBPG);
		if (!cursor_data)
			panic("Cannot allocate memory for hardware cursor\n");
		WriteWord(IOMD_CURSINIT, pmap_extract(kernel_pmap,
		    (vm_offset_t)cursor_data));
	}

	/* Blank the cursor while initialising it's sprite */

	vidc_write ( VIDC_CP1, 0x0 );
	vidc_write ( VIDC_CP2, 0x0 );
	vidc_write ( VIDC_CP3, 0x0 );

 	cursor_normal       = cursor_data;
	cursor_transparent  = cursor_data + (R_DATA->font->pixel_height *
					R_DATA->font->pixel_width);

 	cursor_transparent += 32;
	cursor_transparent = (char *)((int)cursor_transparent & (~31) );

	for ( line = 0; line<R_DATA->font->pixel_height; ++ line )
	{
	    for ( counter=0; counter<R_DATA->font->pixel_width/4;counter++ )
		cursor_normal[line*R_DATA->font->pixel_width + counter]=0x55;
	    for ( ; counter<8; counter++ )
		cursor_normal[line*R_DATA->font->pixel_width + counter]=0;
	}

	for ( line = 0; line<R_DATA->font->pixel_height; ++ line )
	{
	    for ( counter=0; counter<R_DATA->font->pixel_width/4;counter++ )
		cursor_transparent[line*R_DATA->font->pixel_width + counter]=0x00;
	    for ( ; counter<8; counter++ )
		cursor_transparent[line*R_DATA->font->pixel_width + counter]=0;
	}


	p_cursor_normal = pmap_extract(kernel_pmap,(vm_offset_t)cursor_normal );
	p_cursor_transparent = pmap_extract(kernel_pmap,(vm_offset_t)cursor_transparent);

/*
	memset ( cursor_normal, 0x55,
		R_DATA->font->pixel_width*R_DATA->font->pixel_height );

	memset ( cursor_transparent, 0x55,
		R_DATA->font->pixel_width*R_DATA->font->pixel_height );
*/

	/* Ok, now see the cursor */

	vidc_write ( VIDC_CP1, 0xffffff );
        return 0;
}

int
vidcconsole_setfgcol(vc, col)
	struct vconsole *vc;
	int col;
{
	register int loop;

	if ( R_DATA->forecolour >= 16 )
		R_DATA->forecolour=16;
	else
		R_DATA->forecolour=0;
    
	R_DATA->forefillcolour = 0;
    
	R_DATA->forecolour += col;
    
/*TODO
	if ( R_DATA->forecolour >> 1<<R_DATA->BITSPERPIXEL )
		R_DATA->forecolour>>1;
*/

	for (loop = 0; loop < R_DATA->pixelsperbyte; ++loop) {
		R_DATA->forefillcolour |= (R_DATA->forecolour <<
		    loop * R_DATA->BITSPERPIXEL);
	}
	R_DATA->fast_render = R_DATA->forecolour | (R_DATA->backcolour<<8) | (R_DATA->font->pixel_height<<16);
	return 0;
}

int
vidcconsole_setbgcol(vc, col)
	struct vconsole *vc;
	int col;
{
	register int loop;

	if ( R_DATA->backcolour >= 16 )
		R_DATA->backcolour=16;
	else
		R_DATA->backcolour=0;

	R_DATA->backfillcolour = 0;
	R_DATA->backcolour += col;
 /*TODO   
	if ( R_DATA->backcolour >> 1<<R_DATA->BITSPERPIXEL )
		R_DATA->backcolour>>1;
*/

	for (loop = 0; loop < R_DATA->pixelsperbyte; ++loop) {
		R_DATA->backfillcolour |= (R_DATA->backcolour <<
		    loop * R_DATA->BITSPERPIXEL);
	}
	return 0;
}

int
vidcconsole_textpalette(vc)
	struct vconsole *vc;
{
        R_DATA->forecolour = COLOUR_WHITE_8;
        R_DATA->backcolour = COLOUR_BLACK_8;

        vidc_write( VIDC_PALREG , 0x00000000);
        vidc_write( VIDC_PALETTE , VIDC_COL(  0,   0,   0));
        vidc_write( VIDC_PALETTE , VIDC_COL(255,   0,   0));
        vidc_write( VIDC_PALETTE , VIDC_COL(  0, 255,   0));
        vidc_write( VIDC_PALETTE , VIDC_COL(255, 255,   0));
        vidc_write( VIDC_PALETTE , VIDC_COL(  0,   0, 255));
        vidc_write( VIDC_PALETTE , VIDC_COL(255,   0, 255));
        vidc_write( VIDC_PALETTE , VIDC_COL(  0, 255, 255));
        vidc_write( VIDC_PALETTE , VIDC_COL(255, 255, 255));
        vidc_write( VIDC_PALETTE , VIDC_COL(128, 128, 128));
        vidc_write( VIDC_PALETTE , VIDC_COL(255, 128, 128));
        vidc_write( VIDC_PALETTE , VIDC_COL(128, 255, 128));
        vidc_write( VIDC_PALETTE , VIDC_COL(255, 255, 128));
        vidc_write( VIDC_PALETTE , VIDC_COL(128, 128, 255));
        vidc_write( VIDC_PALETTE , VIDC_COL(255, 128, 255));
        vidc_write( VIDC_PALETTE , VIDC_COL(255, 255, 255));

R_DATA->fast_render = R_DATA->forecolour | (R_DATA->backcolour<<8) | (R_DATA->font->pixel_height<<16);
    return 0;
}

int
vidcconsole_sgr(vc, type)
	struct vconsole *vc;
	int type;
{
    switch(type)
    {
        case 0: /* Normal */
	    if (R_DATA->BITSPERPIXEL == 8)
      	    {
        	R_DATA->n_forecolour = COLOUR_WHITE_8;
        	R_DATA->n_backcolour = COLOUR_BLACK_8;
      	    }

	    R_DATA->forecolour = R_DATA->n_forecolour;
            R_DATA->backcolour = R_DATA->n_backcolour;
            R_DATA->font = R_DATA->normalfont;
            break;

	case 1: /* bold */
            R_DATA->font = R_DATA->boldfont;
	    break;	

	case 22: /* not bold */
            R_DATA->font = R_DATA->normalfont;
	    break;	

        case 5:	/* blinking */
	    if ( R_DATA->forecolour < 16 )
	    {
		R_DATA->forecolour+=16;
		R_DATA->backcolour+=16;
		R_DATA->n_forecolour+=16;
		R_DATA->n_backcolour+=16;
	    }
	    break;

        case 25: /* not blinking */
	    if ( R_DATA->forecolour >= 16 )
	    {
		R_DATA->forecolour-=16;
		R_DATA->backcolour-=16;
		R_DATA->n_forecolour-=16;
		R_DATA->n_backcolour-=16;
	    }
	    break;

        case 7: /* reverse */
	    R_DATA->forecolour = R_DATA->n_backcolour;
            R_DATA->backcolour = R_DATA->n_forecolour;
    	    break;
            
        case 27: /* not reverse */
	    R_DATA->forecolour = R_DATA->n_forecolour;
            R_DATA->backcolour = R_DATA->n_backcolour;
    	    break;
    }
R_DATA->fast_render = R_DATA->forecolour | (R_DATA->backcolour<<8) | (R_DATA->font->pixel_height<<16);
    return 0;
}

int
vidcconsole_scrollregion(vc, low, high)
	struct vconsole *vc;
	int low;
	int high;
{
    return 0;
}

int
vidcconsole_blank(vc, type)
	struct vconsole *vc;
	int type;
{
        int ereg;

	vc->blanked=type;

	ereg = 1<<12;
	if (vidc_currentmode->sync_pol & 0x01)
		ereg |= 1<<16;
	if (vidc_currentmode->sync_pol & 0x02)
		ereg |= 1<<18;

	switch (type) {
	case 0:
#ifdef RC7500
		vidc_write(VIDC_EREG, 0x51<<12);
#else
    		vidc_write(VIDC_EREG, ereg);
#endif
		break;
		
	case 1: /* not implemented yet */
	case 2:
	case 3:
		vidc_write(VIDC_EREG, 0);
		break;
	}
	return 0;
}

extern struct tty *find_tp __P((dev_t dev));

int vidcconsole_ioctl ( struct vconsole *vc, dev_t dev, int cmd, caddr_t data,
			int flag, struct proc *p )
{
	int error;
	struct tty *tp;
	struct winsize ws;
	switch ( cmd )
	{
		case CONSOLE_MODE:
    			tp = find_tp(dev);
/*			printf ( "mode ioctl called\n" );*/
			vidcconsole_mode ( vc, (struct vidc_mode *)data );
    			vc->MODECHANGE ( vc );
			ws.ws_row=vc->ychars;
			ws.ws_col=vc->xchars;
			error = (*linesw[tp->t_line].l_ioctl)(tp, TIOCSWINSZ, (char *)&ws, flag, p);
                        error = ttioctl(tp, TIOCSWINSZ, (char *)&ws, flag, p);
			return 0;
			break;

	case CONSOLE_RESETSCREEN:
	{
	extern unsigned int dispbase;
	extern unsigned int dispsize;
	extern unsigned int ptov;
	extern unsigned int transfersize;

	WriteWord ( IOMD_VIDINIT, dispbase-ptov );
	WriteWord ( IOMD_VIDSTART, dispbase-ptov );
	WriteWord ( IOMD_VIDEND, (dispbase+dispsize-transfersize)-ptov );
	return 0;
        }
	case CONSOLE_RESTORESCREEN:
	{
		extern unsigned int dispstart;
		extern unsigned int dispsize;
		extern unsigned int ptov;
		extern unsigned int transfersize;

		WriteWord ( IOMD_VIDINIT, dispstart-ptov );
		WriteWord ( IOMD_VIDSTART, dispstart-ptov );
		WriteWord ( IOMD_VIDEND, (dispstart+dispsize-transfersize)-ptov );
		vidc_stdpalette();
		return 0;
        }
	case CONSOLE_GETINFO:
	{
		extern videomemory_t videomemory;
		register struct console_info *inf = (void *)data;


		inf->videomemory = videomemory;
		inf->width = R_DATA->mode.hder;
		inf->height = R_DATA->mode.vder;
		inf->bpp = R_DATA->mode.bitsperpixel;
		return 0;
	}
	case CONSOLE_PALETTE:
	{
		register struct console_palette *pal = (void *)data;
		vidc_write(VIDC_PALREG, pal->entry);
		vidc_write(VIDC_PALETTE, VIDC_COL(pal->red, pal->green, pal->blue));
 		return 0;
	}
	}
	return -1;
}

int
vidcconsole_attach(vc, parent, self, aux)
	struct vconsole *vc;
	struct device *parent;
	struct device *self;
	void *aux;
{
	vidc_cursor_init ( vc );
	vidcconsole_flash_go ( vc );
	return 0;
}

int
vidcconsole_flash_go(vc)
	struct vconsole *vc;
{
	static int irqclaimed = 0;
	static int lock=0;
	if (lock==1)
		return -1;
	lock=0;

	if (!irqclaimed) {
		cursor_ih.ih_func = vidcconsole_cursorintr;
		cursor_ih.ih_arg = vc;
		cursor_ih.ih_level = IPL_TTY;
		cursor_ih.ih_name = "vsync";
		irq_claim ( IRQ_FLYBACK, &cursor_ih );
		irqclaimed = 1;
	}

	cursor_init = 0;
	return 0;
}

/* What does this function do ? */
int 
vidcconsole_flash(vc, flash)
	struct vconsole *vc;
	int flash;
{
	flash = flash;
	return(0);
}

int
vidcconsole_cursorflash(vc, flash)
	struct vconsole *vc;
	int flash;
{
	cursor_flash = flash;
	return(0);
}

struct render_engine vidcconsole = {
	vidcconsole_name,
	vidcconsole_init,
	
	vidcconsole_putchar,

	vidcconsole_spawn,
	vidcconsole_swapin,
	vidcconsole_mmap,
	vidcconsole_render,
	vidcconsole_scrollup,
	vidcconsole_scrolldown,
	vidcconsole_cls,
	vidcconsole_update,
	vidcconsole_scrollback,
	vidcconsole_scrollforward,
	vidcconsole_scrollbackend,
	vidcconsole_clreos,
	vidcconsole_debugprint,
	vidcconsole_cursorupdate,
	vidcconsole_cursorflashrate,
	vidcconsole_setfgcol,
	vidcconsole_setbgcol,
	vidcconsole_textpalette,
	vidcconsole_sgr,
	vidcconsole_blank,
	vidcconsole_ioctl,
	vidcconsole_redraw,
	vidcconsole_attach,
	vidcconsole_flash,
	vidcconsole_cursorflash
};




struct vidcvideo_softc {
	struct device device;
	int sc_opened;
};

int
vidcvideo_probe(parent, match, aux)
	struct device *parent;
	void *match;
	void *aux;
{
	return 1;
}

void
vidcvideo_attach(parent, self, aux)
	struct device *parent;
	struct device *self;
	void *aux;
{
	struct vidcvideo_softc *vidcvideosoftc = (void *)self;
	vidcvideosoftc->sc_opened=0;

	printf(": vidc20 refclk=%dMHz %dKB %s\n", (VIDC_FREF / 1000000),
	    videomemory.vidm_size / 1024,
	    (videomemory.vidm_type == VIDEOMEM_TYPE_VRAM) ? "VRAM" : "DRAM");
}

struct cfattach vidcvideo_ca = {
	sizeof (struct vidcvideo_softc), vidcvideo_probe, vidcvideo_attach
};

struct cfdriver vidcvideo_cd = {
	NULL, "vidcvideo", DV_DULL
};

int
vidcvideoopen(dev, flags, fmt, p)
	dev_t dev;
	int flags;
	int fmt;
	struct proc *p;
{
	struct vidcvideo_softc *sc;
	struct vconsole vconsole_new;
	int unit = minor(dev);
	int s;

	if (unit >= vidcvideo_cd.cd_ndevs)
		return ENXIO;
	sc = vidcvideo_cd.cd_devs[unit];
	if (!sc)
		return ENXIO;

	s = spltty();
/*	if (sc->sc_opened) {
		(void)splx(s);
		return(EBUSY);
	}*/
	++sc->sc_opened;
	(void)splx(s);

	if (sc->sc_opened == 1) {
		vconsole_new = *vconsole_default;
		vconsole_new.render_engine = &vidcconsole;
		vconsole_spawn_re (
		makedev ( physcon_major, 64 + minor(dev) ),
		    &vconsole_new );
	} else {
		log(LOG_WARNING, "Multiple open of/dev/vidcvideo0 by proc %d\n", p->p_pid);
	}

	return 0;
}

int
vidcvideoclose(dev, flags, fmt, p)
	dev_t dev;
	int flags;
	int fmt;
	struct proc *p;
{
	struct vidcvideo_softc *sc;
	int unit = minor(dev);
	int s;

	if ( unit >= vidcvideo_cd.cd_ndevs )
		return ENXIO;
	sc = vidcvideo_cd.cd_devs[unit];
	if (!sc)
		return ENXIO;

	s = spltty();
	--sc->sc_opened;
	(void)splx(s);

	return 0;
}

extern int physconioctl __P(( dev_t, int, caddr_t, int,	struct proc *));

int
vidcvideoioctl(dev, cmd, data, flag, p)
	dev_t dev;
	int cmd;
	caddr_t data;
	int flag;
	struct proc *p;
{
	dev = makedev(physcon_major, 64 + minor(dev));
	return ( physconioctl ( dev, cmd, data, flag, p ));
}

extern int physconmmap __P((dev_t, int, int));

int
vidcvideommap(dev, offset, prot)
	dev_t dev;
	int offset;
	int prot;
{
	dev = makedev(physcon_major, 64 + minor(dev));
	return(physconmmap(dev, offset, prot));
}