WebSVN - shark - Blame - Rev 326 - /shark/trunk/drivers/grx/gd.c

Rev	Author	Line No.	Line
2	pj	1	#include <ll/i386/hw-data.h>
		2	#include <ll/i386/mem.h>
		3	#include <ll/i386/cons.h>
		4	#include <ll/sys/ll/ll-func.h>
		5
		6	#include <drivers/llpci.h>
		7	#include <drivers/pci.h>
		8
		9	#include <drivers/gd.h>
		10
		11	#include "drivers/s3.h"
		12	#include "drivers/trident.h"
		13	#include "drivers/vesa.h"
		14	#include "drivers/chips.h"
		15
		16	BYTE bus, dev;
		17	ModeInfoBlock vbemi;
		18	BYTE actbank;
		19	BYTE type;
		20
		21	DWORD flb=0;
		22	int linear;
		23	BYTE trylinear;
		24	/BYTE gmode = FALSE;/
		25
		26	#define NMODES 13
		27	static struct gmode allmodes[NMODES] = {
		28	{640, 400, 640, 8, 0x100},
		29	{640, 480, 640, 8, 0x101},
		30	{800, 600, 800, 8, 0x103},
		31	{1024, 768, 1024, 8, 0x105},
		32	{640, 480, 1280, 15, 0x110},
		33	{800, 600, 1600, 15, 0x113},
		34	{1024, 768, 2048, 15, 0x116},
		35	{640, 480, 1280, 16, 0x111},
		36	{800, 600, 1600, 16, 0x114},
		37	{1024, 768, 2048, 16, 0x117},
		38	{640, 480, 1920, 24, 0x112},
		39	{800, 600, 2400, 24, 0x115},
		40	{1024, 768, 3072, 24, 0x118}
		41	};
		42	static struct gmode actualmode;
		43
		44
		45	static int myceil(float f)
		46	{
		47	int i = (int) f;
		48	float f1 = f - i;
		49
		50	if (f1 != 0) {
		51	return i + 1;
		52	} else {
		53	return i;
		54	}
		55	}
		56
		57	/************************************************************************/
		58	/* GD Common Interface */
		59	/************************************************************************/
		60	int gd_init(WORD flags)
		61	{
		62	struct pci_regs *r;
		63	int dummy;
		64
		65	memset(&actualmode, 0, sizeof(struct gmode));
		66	type = UNKNOWN;
		67
		68	if (pci_init() == 1) {
		69	if ((r = pci_class((0x0300) << 8, 0, &bus, &dev)) != NULL) {
		70	cprintf("PCI video card found!!!\n");
		71	cprintf("Vendor: %x\n", r->VendorId);
		72	cprintf("Card: %x\n", r->DeviceId);
		73	/* flb = r->IoBaseAddress & 0xFF800000; */
		74
		75	dummy = pcibios_read_config_dword(bus, dev, 16, &flb);
		76	flb = flb & 0xFF800000;
		77	/* Err... Have to set type!!! */
		78
		79	cprintf("FLB @ %lx\n", flb);
		80	if (flb < 32 * 1024 * 1024) {
		81	/flb = 32 0x1000000;*/
		82	/flb = 0xF3000000;/
		83	flb = 0x02000000;
		84	cprintf("Wrong FLB!!! Forced to %lx\n", flb);
		85	pcibios_write_config_dword(bus, dev, 16, flb);
		86	}
		87	}
		88	}
		89
		90	/* VESA driver needs the V86 Mode... */
326	giacomo	91	//vm86_init();
2	pj	92
		93	/* First, check VESA... */
		94	if (vbe_getinfo() == 1) {
		95	type = VESA;
		96
		97	if (flags & NOLINEAR) {
		98	trylinear = 0;
		99	} else {
		100	trylinear = 1;
		101	}
		102	}
		103
		104	/* Then, the other graph cards... Override VESA!!! */
		105	if (trident_test() == 1) {
		106	type = TRIDENT;
		107	trylinear = 0;
		108	}
		109
		110	if (s3_test() == 1) {
		111	type = S3;
		112	if (flags & NOLINEAR) {
		113	trylinear = 0;
		114	} else {
		115	trylinear = 1;
		116	}
		117	return 1;
		118	}
		119
		120	if (type == UNKNOWN) {
		121	return -1;
		122	}
		123	if (type == VESA) {
		124	return vbe_check_id();
		125	}
		126	return -2;
		127	}
		128
		129	void gd_showmodeinfo(void)
		130	{
		131	cprintf("Mode number %x\n", actualmode.modenum);
		132	cprintf("MaxX: %u\n", actualmode.xdim);
		133	cprintf("MaxY: %u\n", actualmode.ydim);
		134	cprintf("BPR: %u\n", actualmode.bpr);
		135	}
		136
		137	void gd_showinfo(void)
		138	{
		139	DWORD addr;
		140
		141	addr = gd_getflb();
		142
		143	if (addr != 0) {
		144	cprintf ("\t gd: Frame Linear Buffer @ %lx (%luM)\n",
		145	addr, (addr / 0x1000000));
		146	}
		147
		148	if (type == VESA) {
		149	cprintf("Vesa SVGA card\n");
		150	vbe_showinfo();
		151	}
		152	if (type == TRIDENT) {
		153	cprintf("Trident graphic card\n");
		154	trident_showinfo();
		155	}
		156
		157	if (type == S3) {
		158	cprintf("S3 graphic card\n");
		159	s3_showinfo();
		160	}
		161	}
		162
		163	int gd_setmode(WORD mode)
		164	{
		165	WORD app;
		166	int i;
		167	#ifndef VM86
		168	BYTE p1, p2;
		169	#endif
		170
		171	if (mode == 0) {
		172	X_REGS16 inregs, outregs;
		173	X_SREGS16 sregs;
		174
		175	if (actualmode.modenum != 0) {
		176	inregs.x.ax = 0x03;
		177	#ifndef VM86
		178	p1 = inp(0x21);
		179	p2 = inp(0xA1);
		180	outp(0x21,0xFF);
		181	outp(0xA1,0xFF);
		182	X_callBIOS(0x10, &inregs, &outregs, &sregs);
		183	outp(0x21,p1);
		184	outp(0xA1,p2);
		185	#else
		186	vm86_callBIOS(0x10, &inregs, &outregs, &sregs);
		187	#endif
		188	}
		189	return 1;
		190	}
		191
		192	for (i = 0; i < NMODES; i++) {
		193	if ((mode == allmodes[i].modenum)) {
		194	memcpy(&actualmode, &(allmodes[i]), sizeof(struct gmode));
		195	}
		196	}
		197
		198	if (type == VESA) {
		199	if (vbe_getmodeinfo(&vbemi, mode) < 0) {
		200	return -1;
		201	}
		202
		203	app = mode;
		204	if (trylinear) {
		205	/* try linear... */
		206	cprintf("Mode: %x\n", mode);
		207	mode = mode \| 0x4000;
		208	cprintf("Lin_Mode: %x\n", mode);
		209	linear = TRUE;
		210	if (vbe_setmode(mode) == 1) {
		211	return linear;
		212	}
		213	}
		214	actbank = 0;
		215	Load_Write_Bank_256(0);
		216	linear = FALSE;
		217	mode = app;
		218	if (vbe_setmode(mode) < 0) {
		219	return -1;
		220	}
		221	return linear;
		222	}
		223
		224	if (type == S3) {
		225	/* Still use VESA to open graph... */
		226	if (vbe_getmodeinfo(&vbemi, mode) < 0) {
		227	return -1;
		228	}
		229	if (vbe_setmode(mode) < 0) {
		230	return -1;
		231	}
		232	if ((flb != 0) && trylinear) {
		233	linear = TRUE;
		234	s3_linear(flb);
		235	pcibios_write_config_dword(bus, dev, 16, flb);
		236	return TRUE;
		237	}
		238	linear = FALSE;
		239	actbank = 0;
		240	Load_Write_Bank_256(0);
		241	return FALSE;
		242	}
		243
		244	if (type == TRIDENT) {
		245	/* Still use VESA to open graph... */
		246	if (vbe_getmodeinfo(&vbemi, mode) < 0) {
		247	return -1;
		248	}
		249	if (vbe_setmode(mode) < 0) {
		250	return -1;
		251	}
		252
		253	actbank = 0;
		254	Load_Write_Bank_256(0);
		255	return FALSE;
		256	}
		257
		258	return -2;
		259	}
		260
		261	DWORD gd_getflb(void)
		262	{
		263	if (type == VESA) {
		264	return vbe_getflb();
		265	}
		266	if (type == S3) {
		267	return flb;
		268	}
		269	return 0;
		270	}
		271
		272	DWORD gd_getmem(void)
		273	{
		274	if (type == VESA) {
		275	return vbe_getmem();
		276	}
		277	if (type == S3) {
		278	return s3_getmem();
		279	}
		280	if (type == TRIDENT) {
		281	return trident_getmem();
		282	}
		283
		284	return 0;
		285	}
		286
		287	WORD gd_getbpr(void)
		288	{
		289	if (actualmode.bpr) return actualmode.bpr;
		290	return -2;
		291	}
		292
51	pj	293	int gd_getmodeinfo(grx_vga_modeinfo *m)
2	pj	294	{
		295	if (actualmode.modenum == 0) {
		296	return -1;
		297	}
		298
		299	m->width = actualmode.xdim;
		300	m->height = actualmode.ydim;
		301	m->bytesperpixel = (myceil((float)actualmode.bpp / 8));
		302	/* m->colors = myexp(2, actualmode.bpp); */
		303	m->colors = 1 << actualmode.bpp;
		304	m->linewidth = gd_getbpr();
		305	m->maxlogicalwidth = gd_getbpr(); /* 4 the moment... */
		306	m->startaddressrange = 0; /* don't know :( */
		307	m->maxpixels = gd_getmem() / m->bytesperpixel;
		308	m->haveblit = 0;
		309	m->flags = 0;
		310
		311	/* Extended fields: */
		312	m->chiptype = type; /* Chiptype detected */
		313	m->memory = gd_getmem();
		314	m->linewidth_unit = 0; /* don't know :( */
		315	if (linear) {
		316	m->linear_aperture = (LIN_ADDR)gd_getflb();
		317	m->aperture_size = gd_getmem();
		318	} else {
		319	m->linear_aperture = 0;
		320	m->aperture_size = 0xFFFF;
		321	}
		322	m->set_aperture_page = NULL;
		323	m->extensions = NULL;
		324	return 1;
		325	}
		326
		327	void Load_Write_Bank_256(BYTE bank)
		328	{
		329	if (bank != actbank) {
		330	actbank = bank;
		331	if (type == VESA) {
		332	if (vbe_setbank(&vbemi, bank) < 0)
		333	ll_abort(259);
		334	}
		335	if (type == S3) {
		336	s3_setpage(bank);
		337	}
		338	if (type == TRIDENT) {
		339	trident_setpage(bank);
		340	}
		341	}
		342	}
		343
		344	/************************************************************************/
		345	/* BANK HANDLING FUNCS */
		346	/************************************************************************/
		347
		348	LIN_ADDR start_address(WORD bpr, WORD x, WORD y)
		349	{
		350	LIN_ADDR a;
		351
		352	a = (LIN_ADDR)(y * bpr +x);
		353	return a;
		354	}
		355
		356	void Seg_Off_256(WORD x, WORD y, WORD pitch, WORD offs, WORD seg)
		357	{
		358	DWORD a;
		359
		360	a = y * pitch + x;
		361	*offs = a & 0x0000FFFF;
		362	*seg = a >> 16;
		363	}
		364
		365	void Seg_Off_Hi(WORD x, WORD y, WORD pitch, WORD offs, WORD seg)
		366	{
		367	DWORD a;
		368
		369	a = y * pitch + x * 2;
		370	*offs = a & 0x0000FFFF;
		371	*seg = a >> 16;
		372	}
		373
		374	int gd_modenum(WORD x, WORD y, BYTE depth)
		375	{
		376	int mode, i;
		377
		378	mode = -1;
		379
		380	for (i = 0; i < NMODES; i++) {
		381	if ((depth == allmodes[i].bpp) && (x == allmodes[i].xdim) && (y == allmodes[i].ydim)) {
		382	mode = allmodes[i].modenum;
		383	} else {
		384	}
		385	}
		386
		387	if ((mode != -1) && (vbe_checkmode(mode) != -1))
		388	return mode;
		389	return -1;
		390	}

Subversion Repositories shark

(root)/shark/trunk/drivers/grx/gd.c - Rev 326