plan 9 kernel history: overview | file list | diff list

2001/0430/pc/vgacyber938x.c (diff list | history)

2001/0430/sys/src/9/pc/vgacyber938x.c:1,2252001/0527/sys/src/9/pc/vgacyber938x.c:1,210 (short | long | prev | next)
1998/0205    
#include "u.h" 
#include "../port/lib.h" 
#include "mem.h" 
#include "dat.h" 
#include "fns.h" 
#include "io.h" 
#include "../port/error.h" 
 
#define	Image	IMAGE 
#include <draw.h> 
#include <memdraw.h> 
1999/0119    
#include <cursor.h> 
1998/0205    
#include "screen.h" 
 
1998/0829    
enum { 
	CursorON	= 0xC8, 
	CursorOFF	= 0x00, 
}; 
 
1998/0205    
static int 
cyber938xpageset(VGAscr*, int page) 
{ 
	int opage; 
 
	opage = inb(0x3D8); 
 
	outb(0x3D8, page); 
	outb(0x3D9, page); 
 
	return opage; 
} 
 
static void 
cyber938xpage(VGAscr* scr, int page) 
{ 
	lock(&scr->devlock); 
	cyber938xpageset(scr, page); 
	unlock(&scr->devlock); 
} 
 
static ulong 
cyber938xlinear(VGAscr* scr, int* size, int* align) 
{ 
	ulong aperture, oaperture; 
	int oapsize, wasupamem; 
2001/0410    
	int osize; 
1998/0205    
	Pcidev *p; 
 
2001/0410    
	osize = *size; 
1998/0205    
	oaperture = scr->aperture; 
	oapsize = scr->apsize; 
	wasupamem = scr->isupamem; 
	if(wasupamem) 
		upafree(oaperture, oapsize); 
	scr->isupamem = 0; 
2001/0410    
	scr->mmio = 0; 
1998/0205    
 
	if(p = pcimatch(nil, 0x1023, 0)){ 
		aperture = p->mem[0].bar & ~0x0F; 
		*size = p->mem[0].size; 
2001/0410    
		/* 
		 * Heuristic to detect the MMIO space.  We're flying blind 
		 * here, with only the XFree86 source to guide us. 
		 */ 
		if(p->mem[1].size == 0x20000) 
			scr->mmio = (ulong*)(p->mem[1].bar & ~0x0F); 
1998/0205    
	} 
	else 
		aperture = 0; 
 
	aperture = upamalloc(aperture, *size, *align); 
	if(aperture == 0){ 
		if(wasupamem && upamalloc(oaperture, oapsize, 0)) 
			scr->isupamem = 1; 
	} 
	else 
		scr->isupamem = 1; 
 
2001/0410    
	if(aperture) 
		addvgaseg("cyber938xscreen", aperture, osize); 
	if(scr->mmio) 
		addvgaseg("cyber938xmmio", (ulong)scr->mmio, 0x20000); 
                 
1998/0205    
	return aperture; 
} 
 
static void 
cyber938xcurdisable(VGAscr*) 
{ 
1998/0829    
	vgaxo(Crtx, 0x50, CursorOFF); 
1998/0205    
} 
 
static void 
cyber938xcurload(VGAscr* scr, Cursor* curs) 
{ 
	uchar *p; 
	int islinear, opage, y; 
 
	cyber938xcurdisable(scr); 
 
	opage = 0; 
	p = KADDR(scr->aperture); 
	islinear = vgaxi(Crtx, 0x21) & 0x20; 
	if(!islinear){ 
		lock(&scr->devlock); 
		opage = cyber938xpageset(scr, scr->storage>>16); 
		p += (scr->storage & 0xFFFF); 
	} 
	else 
		p += scr->storage; 
 
	for(y = 0; y < 16; y++){ 
		*p++ = curs->set[2*y]|curs->clr[2*y]; 
		*p++ = curs->set[2*y + 1]|curs->clr[2*y + 1]; 
		*p++ = 0x00; 
		*p++ = 0x00; 
		*p++ = curs->set[2*y]; 
		*p++ = curs->set[2*y + 1]; 
		*p++ = 0x00; 
		*p++ = 0x00; 
	} 
1998/0829    
	memset(p, 0, (32-y)*8); 
1998/0205    
 
	if(!islinear){ 
		cyber938xpageset(scr, opage); 
		unlock(&scr->devlock); 
	} 
 
	/* 
	 * Save the cursor hotpoint and enable the cursor. 
	 */ 
	scr->offset = curs->offset; 
1998/0829    
	vgaxo(Crtx, 0x50, CursorON); 
1998/0205    
} 
 
static int 
cyber938xcurmove(VGAscr* scr, Point p) 
{ 
	int x, xo, y, yo; 
 
	/* 
	 * Mustn't position the cursor offscreen even partially, 
	 * or it might disappear. Therefore, if x or y is -ve, adjust the 
	 * cursor origins instead. 
	 */ 
	if((x = p.x+scr->offset.x) < 0){ 
		xo = -x; 
		x = 0; 
	} 
	else 
		xo = 0; 
	if((y = p.y+scr->offset.y) < 0){ 
		yo = -y; 
		y = 0; 
	} 
	else 
		yo = 0; 
 
	/* 
	 * Load the new values. 
	 */ 
	vgaxo(Crtx, 0x46, xo); 
	vgaxo(Crtx, 0x47, yo); 
	vgaxo(Crtx, 0x40, x & 0xFF); 
	vgaxo(Crtx, 0x41, (x>>8) & 0xFF); 
	vgaxo(Crtx, 0x42, y & 0xFF); 
	vgaxo(Crtx, 0x43, (y>>8) & 0xFF); 
 
	return 0; 
1998/0209    
} 
 
static void 
cyber938xcurenable(VGAscr* scr) 
{ 
	int i; 
	ulong storage; 
 
	cyber938xcurdisable(scr); 
 
	/* 
	 * Cursor colours. 
	 */ 
	for(i = 0x48; i < 0x4C; i++) 
1999/1005    
		vgaxo(Crtx, i, 0x00); 
1998/0209    
	for(i = 0x4C; i < 0x50; i++) 
1999/1005    
		vgaxo(Crtx, i, 0xFF); 
1998/0209    
 
	/* 
	 * Find a place for the cursor data in display memory. 
	 */ 
1998/0829    
	storage = ((scr->gscreen->width*BY2WD*scr->gscreen->r.max.y+1023)/1024); 
1998/0209    
	vgaxo(Crtx, 0x44, storage & 0xFF); 
	vgaxo(Crtx, 0x45, (storage>>8) & 0xFF); 
1998/0829    
	storage *= 1024; 
1998/0209    
	scr->storage = storage; 
 
	/* 
	 * Load, locate and enable the 32x32 cursor. 
	 * (64x64 is bit 0, X11 format is bit 6 and cursor 
1998/0214    
	 * enable is bit 7). Bit 3 needs to be set on 9382 
	 * chips otherwise even the white bits are black. 
1998/0209    
	 */ 
	cyber938xcurload(scr, &arrow); 
	cyber938xcurmove(scr, ZP); 
1998/0829    
	vgaxo(Crtx, 0x50, CursorON); 
1998/0205    
} 
 
VGAdev vgacyber938xdev = { 
	"cyber938x", 
 
2001/0430    
	nil,				/* enable */ 
	nil,				/* disable */ 
2001/0527    
	0,				/* enable */ 
	0,				/* disable */ 
1998/0205    
	cyber938xpage,			/* page */ 
	cyber938xlinear,		/* linear */ 
2001/0430    
	nil,				/* drawinit */ 
1998/0205    
}; 
 
VGAcur vgacyber938xcur = { 
	"cyber938xhwgc", 
 
	cyber938xcurenable,		/* enable */ 
	cyber938xcurdisable,		/* disable */ 
	cyber938xcurload,		/* load */ 
	cyber938xcurmove,		/* move */ 
}; 


source code copyright © 1990-2005 Lucent Technologies; see license
Plan 9 distribution
comments to russ cox (rsc@swtch.com)