vboxvideo_13.c@ 22089

Last change on this file since 22089 was 22089, checked in by vboxsync, 16 years ago
Additions/x11/vboxvideo_13: merged back vboxvideo_15 parts of r50005: Additions/x11/vboxvideo: fix initial display corruption with large amounts of virtual video RAM
Property svn:eol-style set to `native`
File size: 51.7 KB

Line
1	/** @file
2	*
3	* Linux Additions X11 graphics driver
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	* --------------------------------------------------------------------
21	*
22	* This code is based on:
23	*
24	* X11 VESA driver
25	*
26	* Copyright (c) 2000 by Conectiva S.A. (http://www.conectiva.com)
27	*
28	* Permission is hereby granted, free of charge, to any person obtaining a
29	* copy of this software and associated documentation files (the "Software"),
30	* to deal in the Software without restriction, including without limitation
31	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
32	* and/or sell copies of the Software, and to permit persons to whom the
33	* Software is furnished to do so, subject to the following conditions:
34	*
35	* The above copyright notice and this permission notice shall be included in
36	* all copies or substantial portions of the Software.
37	*
38	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
39	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
40	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
41	* CONECTIVA LINUX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
42	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
43	* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
44	* SOFTWARE.
45	*
46	* Except as contained in this notice, the name of Conectiva Linux shall
47	* not be used in advertising or otherwise to promote the sale, use or other
48	* dealings in this Software without prior written authorization from
49	* Conectiva Linux.
50	*
51	* Authors: Paulo César Pereira de Andrade <[email protected]>
52	*/
53
54	#include "xorg-server.h"
55	#include "vboxvideo.h"
56	#include "version-generated.h"
57	#include <xf86.h>
58
59	/* All drivers initialising the SW cursor need this */
60	#include "mipointer.h"
61
62	/* All drivers implementing backing store need this */
63	#include "mibstore.h"
64
65	/* Colormap handling */
66	#include "micmap.h"
67	#include "xf86cmap.h"
68
69	/* DPMS */
70	/* #define DPMS_SERVER
71	#include "extensions/dpms.h" */
72
73	/* X.org 1.3+ mode setting */
74	#include "xf86Crtc.h"
75	#include "xf86Modes.h"
76
77	/* Mandatory functions */
78
79	static const OptionInfoRec * VBOXAvailableOptions(int chipid, int busid);
80	static void VBOXIdentify(int flags);
81	#ifndef PCIACCESS
82	static Bool VBOXProbe(DriverPtr drv, int flags);
83	#else
84	static Bool VBOXPciProbe(DriverPtr drv, int entity_num,
85	struct pci_device *dev, intptr_t match_data);
86	#endif
87	static Bool VBOXPreInit(ScrnInfoPtr pScrn, int flags);
88	static Bool VBOXScreenInit(int Index, ScreenPtr pScreen, int argc,
89	char **argv);
90	static Bool VBOXEnterVT(int scrnIndex, int flags);
91	static void VBOXLeaveVT(int scrnIndex, int flags);
92	static Bool VBOXCloseScreen(int scrnIndex, ScreenPtr pScreen);
93	static Bool VBOXSwitchMode(int scrnIndex, DisplayModePtr pMode, int flags);
94	static ModeStatus VBOXValidMode(int scrn, DisplayModePtr p, Bool flag, int pass);
95	static Bool VBOXSetMode(ScrnInfoPtr pScrn, DisplayModePtr pMode);
96	static void VBOXAdjustFrame(int scrnIndex, int x, int y, int flags);
97	static void VBOXFreeScreen(int scrnIndex, int flags);
98	static void VBOXFreeRec(ScrnInfoPtr pScrn);
99
100	/* locally used functions */
101	static Bool VBOXMapVidMem(ScrnInfoPtr pScrn);
102	static void VBOXUnmapVidMem(ScrnInfoPtr pScrn);
103	static void VBOXLoadPalette(ScrnInfoPtr pScrn, int numColors,
104	int *indices,
105	LOCO *colors, VisualPtr pVisual);
106	static void SaveFonts(ScrnInfoPtr pScrn);
107	static void RestoreFonts(ScrnInfoPtr pScrn);
108	static Bool VBOXSaveRestore(ScrnInfoPtr pScrn,
109	vbeSaveRestoreFunction function);
110
111	enum GenericTypes
112	{
113	CHIP_VBOX_GENERIC
114	};
115
116	#ifdef PCIACCESS
117	static const struct pci_id_match vbox_device_match[] = {
118	{
119	VBOX_VENDORID, VBOX_DEVICEID, PCI_MATCH_ANY, PCI_MATCH_ANY,
120	0, 0, 0
121	},
122
123	{ 0, 0, 0 },
124	};
125	#endif
126
127	/* Supported chipsets */
128	static SymTabRec VBOXChipsets[] =
129	{
130	{VBOX_DEVICEID, "vbox"},
131	{-1, NULL}
132	};
133
134	static PciChipsets VBOXPCIchipsets[] = {
135	{ VBOX_DEVICEID, VBOX_DEVICEID, RES_SHARED_VGA },
136	{ -1, -1, RES_UNDEFINED },
137	};
138
139	/*
140	* This contains the functions needed by the server after loading the
141	* driver module. It must be supplied, and gets added the driver list by
142	* the Module Setup funtion in the dynamic case. In the static case a
143	* reference to this is compiled in, and this requires that the name of
144	* this DriverRec be an upper-case version of the driver name.
145	*/
146
147	_X_EXPORT DriverRec VBOXDRV = {
148	VBOX_VERSION,
149	VBOX_DRIVER_NAME,
150	VBOXIdentify,
151	#ifdef PCIACCESS
152	NULL,
153	#else
154	VBOXProbe,
155	#endif
156	VBOXAvailableOptions,
157	NULL,
158	0,
159	NULL,
160
161	#ifdef PCIACCESS
162	vbox_device_match,
163	VBOXPciProbe
164	#endif
165	};
166
167	/* No options for now */
168	static const OptionInfoRec VBOXOptions[] = {
169	{ -1, NULL, OPTV_NONE, {0}, FALSE }
170	};
171
172	static VBOXPtr
173	VBOXGetRec(ScrnInfoPtr pScrn)
174	{
175	if (!pScrn->driverPrivate) {
176	pScrn->driverPrivate = xcalloc(sizeof(VBOXRec), 1);
177	}
178
179	return ((VBOXPtr)pScrn->driverPrivate);
180	}
181
182	static void
183	VBOXFreeRec(ScrnInfoPtr pScrn)
184	{
185	VBOXPtr pVBox = VBOXGetRec(pScrn);
186	xfree(pVBox->savedPal);
187	xfree(pVBox->fonts);
188	xfree(pScrn->driverPrivate);
189	pScrn->driverPrivate = NULL;
190	}
191
192	/* X.org 1.3+ mode-setting support ******************************************/
193
194	/* For descriptions of these functions and structures, see
195	hw/xfree86/modes/xf86Crtc.h and hw/xfree86/modes/xf86Modes.h in the
196	X.Org source tree. */
197
198	static Bool
199	VBOXCrtcResize(ScrnInfoPtr scrn, int width, int height)
200	{
201	int bpp = scrn->bitsPerPixel;
202	ScreenPtr pScreen = scrn->pScreen;
203	PixmapPtr pPixmap = NULL;
204	VBOXPtr pVBox = VBOXGetRec(scrn);
205	Bool rc = TRUE;
206
207	TRACE_LOG("width=%d, height=%d\n", width, height);
208	/* We only support horizontal resolutions which are a multiple of 8.
209	* Round up if necessary. */
210	width = (width + 7) & ~7;
211	if (width * height * bpp / 8 >= scrn->videoRam * 1024)
212	{
213	xf86DrvMsg(scrn->scrnIndex, X_ERROR,
214	"Unable to set up a virtual screen size of %dx%d with %d Kb of video memory. Please increase the video memory size.\n",
215	width, height, scrn->videoRam);
216	rc = FALSE;
217	}
218	if (rc) {
219	pPixmap = pScreen->GetScreenPixmap(pScreen);
220	if (NULL == pPixmap) {
221	xf86DrvMsg(scrn->scrnIndex, X_ERROR,
222	"Failed to get the screen pixmap.\n");
223	rc = FALSE;
224	}
225	}
226	if (rc) {
227	if (
228	!pScreen->ModifyPixmapHeader(pPixmap, width, height,
229	scrn->depth, bpp, width * bpp / 8,
230	pVBox->base)
231	) {
232	xf86DrvMsg(scrn->scrnIndex, X_ERROR,
233	"Failed to set up the screen pixmap.\n");
234	rc = FALSE;
235	}
236	}
237	if (rc) {
238	scrn->virtualX = width;
239	scrn->virtualY = height;
240	scrn->displayWidth = width;
241	#ifdef VBOX_DRI
242	if (pVBox->useDRI)
243	VBOXDRIUpdateStride(scrn, pVBox);
244	#endif
245	}
246	TRACE_LOG("returning %s\n", rc ? "TRUE" : "FALSE");
247	return rc;
248	}
249
250	static const xf86CrtcConfigFuncsRec VBOXCrtcConfigFuncs = {
251	VBOXCrtcResize
252	};
253
254	static void
255	vbox_crtc_dpms(xf86CrtcPtr crtc, int mode)
256	{ (void) crtc; (void) mode; }
257
258	static Bool
259	vbox_crtc_lock (xf86CrtcPtr crtc)
260	{ (void) crtc; return FALSE; }
261
262	static Bool
263	vbox_crtc_mode_fixup (xf86CrtcPtr crtc, DisplayModePtr mode,
264	DisplayModePtr adjusted_mode)
265	{
266	ScrnInfoPtr pScrn = crtc->scrn;
267	int xRes = adjusted_mode->HDisplay;
268
269	(void) mode;
270	TRACE_LOG("name=%s, HDisplay=%d, VDisplay=%d\n", adjusted_mode->name,
271	adjusted_mode->HDisplay, adjusted_mode->VDisplay);
272	/* We only support horizontal resolutions which are a multiple of 8. Round down if
273	necessary. */
274	if (xRes % 8 != 0)
275	{
276	xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
277	"VirtualBox only supports screen widths which are a multiple of 8. Rounding down from %d to %d\n",
278	xRes, xRes - (xRes % 8));
279	adjusted_mode->HDisplay = xRes - (xRes % 8);
280	}
281	return TRUE;
282	}
283
284	static void
285	vbox_crtc_stub (xf86CrtcPtr crtc)
286	{ (void) crtc; }
287
288	static void
289	vbox_crtc_mode_set (xf86CrtcPtr crtc, DisplayModePtr mode,
290	DisplayModePtr adjusted_mode, int x, int y)
291	{
292	(void) mode;
293	TRACE_LOG("name=%s, HDisplay=%d, VDisplay=%d, x=%d, y=%d\n", adjusted_mode->name,
294	adjusted_mode->HDisplay, adjusted_mode->VDisplay, x, y);
295	VBOXSetMode(crtc->scrn, adjusted_mode);
296	VBOXAdjustFrame(crtc->scrn->scrnIndex, x, y, 0);
297	vboxSaveVideoMode(crtc->scrn, adjusted_mode->HDisplay,
298	adjusted_mode->VDisplay, crtc->scrn->bitsPerPixel);
299	}
300
301	static void
302	vbox_crtc_gamma_set (xf86CrtcPtr crtc, CARD16 *red,
303	CARD16 green, CARD16 blue, int size)
304	{ (void) crtc; (void) red; (void) green; (void) blue; (void) size; }
305
306	static void *
307	vbox_crtc_shadow_allocate (xf86CrtcPtr crtc, int width, int height)
308	{ (void) crtc; (void) width; (void) height; return NULL; }
309
310	static const xf86CrtcFuncsRec VBOXCrtcFuncs = {
311	.dpms = vbox_crtc_dpms,
312	.save = NULL, /* These two are never called by the server. */
313	.restore = NULL,
314	.lock = vbox_crtc_lock,
315	.unlock = NULL, /* This will not be invoked if lock returns FALSE. */
316	.mode_fixup = vbox_crtc_mode_fixup,
317	.prepare = vbox_crtc_stub,
318	.mode_set = vbox_crtc_mode_set,
319	.commit = vbox_crtc_stub,
320	.gamma_set = vbox_crtc_gamma_set,
321	.shadow_allocate = vbox_crtc_shadow_allocate,
322	.shadow_create = NULL, /* These two should not be invoked if allocate
323	returns NULL. */
324	.shadow_destroy = NULL,
325	.set_cursor_colors = NULL, /* We are still using the old cursor API. */
326	.set_cursor_position = NULL,
327	.show_cursor = NULL,
328	.hide_cursor = NULL,
329	.load_cursor_argb = NULL,
330	.destroy = vbox_crtc_stub
331	};
332
333	static void
334	vbox_output_stub (xf86OutputPtr output)
335	{ (void) output; }
336
337	static void
338	vbox_output_dpms (xf86OutputPtr output, int mode)
339	{ (void) output; (void) mode; }
340
341	static int
342	vbox_output_mode_valid (xf86OutputPtr output, DisplayModePtr mode)
343	{
344	ScrnInfoPtr pScrn = output->scrn;
345	int rc = MODE_OK;
346	TRACE_LOG("HDisplay=%d, VDisplay=%d\n", mode->HDisplay, mode->VDisplay);
347	/* We always like modes specified by the user in the configuration
348	* file, as doing otherwise is likely to annoy people. */
349	if ( !(mode->type & M_T_USERDEF)
350	&& vbox_device_available(VBOXGetRec(pScrn))
351	&& !vboxHostLikesVideoMode(pScrn, mode->HDisplay, mode->VDisplay,
352	pScrn->bitsPerPixel)
353	)
354	rc = MODE_BAD;
355	TRACE_LOG("returning %s\n", MODE_OK == rc ? "MODE_OK" : "MODE_BAD");
356	return rc;
357	}
358
359	static Bool
360	vbox_output_mode_fixup (xf86OutputPtr output, DisplayModePtr mode,
361	DisplayModePtr adjusted_mode)
362	{ (void) output; (void) mode; (void) adjusted_mode; return TRUE; }
363
364	static void
365	vbox_output_mode_set (xf86OutputPtr output, DisplayModePtr mode,
366	DisplayModePtr adjusted_mode)
367	{ (void) output; (void) mode; (void) adjusted_mode; }
368
369	/* A virtual monitor is always connected. */
370	static xf86OutputStatus
371	vbox_output_detect (xf86OutputPtr output)
372	{
373	(void) output;
374	return XF86OutputStatusConnected;
375	}
376
377	static void
378	vbox_output_add_mode (DisplayModePtr pModes, const char pszName, int x, int y,
379	Bool isPreferred, Bool isUserDef)
380	{
381	TRACE_LOG("pszName=%s, x=%d, y=%d\n", pszName, x, y);
382	DisplayModePtr pMode = xnfcalloc(1, sizeof(DisplayModeRec));
383
384	pMode->status = MODE_OK;
385	/* We don't ask the host whether it likes user defined modes,
386	* as we assume that the user really wanted that mode. */
387	pMode->type = isUserDef ? M_T_USERDEF : M_T_BUILTIN;
388	if (isPreferred)
389	pMode->type \|= M_T_PREFERRED;
390	/* VBox only supports screen widths which are a multiple of 8 */
391	pMode->HDisplay = (x + 7) & ~7;
392	pMode->HSyncStart = pMode->HDisplay + 2;
393	pMode->HSyncEnd = pMode->HDisplay + 4;
394	pMode->HTotal = pMode->HDisplay + 6;
395	pMode->VDisplay = y;
396	pMode->VSyncStart = pMode->VDisplay + 2;
397	pMode->VSyncEnd = pMode->VDisplay + 4;
398	pMode->VTotal = pMode->VDisplay + 6;
399	pMode->Clock = pMode->HTotal * pMode->VTotal * 60 / 1000; /* kHz */
400	if (NULL == pszName) {
401	xf86SetModeDefaultName(pMode);
402	} else {
403	pMode->name = xnfstrdup(pszName);
404	}
405	pModes = xf86ModesAdd(pModes, pMode);
406	}
407
408	static DisplayModePtr
409	vbox_output_get_modes (xf86OutputPtr output)
410	{
411	bool rc;
412	unsigned i;
413	DisplayModePtr pModes = NULL;
414	ScrnInfoPtr pScrn = output->scrn;
415	VBOXPtr pVBox = VBOXGetRec(pScrn);
416
417	TRACE_ENTRY();
418	if (vbox_device_available(pVBox))
419	{
420	uint32_t x, y, bpp, display;
421	rc = vboxGetDisplayChangeRequest(pScrn, &x, &y, &bpp, &display);
422	/* @todo - check the display number once we support multiple displays. */
423	/* If we don't find a display request, see if we have a saved hint
424	* from a previous session. */
425	if (!rc \|\| (0 == x) \|\| (0 == y))
426	rc = vboxRetrieveVideoMode(pScrn, &x, &y, &bpp);
427	if (rc && (0 != x) && (0 != y)) {
428	/* We prefer a slightly smaller size to a slightly larger one */
429	x -= (x % 8);
430	vbox_output_add_mode(&pModes, NULL, x, y, TRUE, FALSE);
431	}
432	}
433	/* Also report any modes the user may have requested in the xorg.conf
434	* configuration file. */
435	for (i = 0; pScrn->display->modes[i] != NULL; i++)
436	{
437	int x, y;
438	if (2 == sscanf(pScrn->display->modes[i], "%dx%d", &x, &y))
439	vbox_output_add_mode(&pModes, pScrn->display->modes[i], x, y,
440	FALSE, TRUE);
441	}
442	TRACE_EXIT();
443	return pModes;
444	}
445
446	#ifdef RANDR_12_INTERFACE
447	/* We don't yet have mutable properties, whatever they are. */
448	static Bool
449	vbox_output_set_property(xf86OutputPtr output, Atom property,
450	RRPropertyValuePtr value)
451	{ (void) output; (void) property; (void) value; return FALSE; }
452	#endif
453
454	static const xf86OutputFuncsRec VBOXOutputFuncs = {
455	.create_resources = vbox_output_stub,
456	.dpms = vbox_output_dpms,
457	.save = NULL, /* These two are never called by the server. */
458	.restore = NULL,
459	.mode_valid = vbox_output_mode_valid,
460	.mode_fixup = vbox_output_mode_fixup,
461	.prepare = vbox_output_stub,
462	.commit = vbox_output_stub,
463	.mode_set = vbox_output_mode_set,
464	.detect = vbox_output_detect,
465	.get_modes = vbox_output_get_modes,
466	#ifdef RANDR_12_INTERFACE
467	.set_property = vbox_output_set_property,
468	#endif
469	.destroy = vbox_output_stub
470	};
471
472	/*
473	* List of symbols from other modules that this module references. This
474	* list is used to tell the loader that it is OK for symbols here to be
475	* unresolved providing that it hasn't been told that they are essential
476	* via a call to xf86LoaderReqSymbols() or xf86LoaderReqSymLists(). The
477	* purpose is this is to avoid warnings about unresolved symbols that are
478	* not required.
479	*/
480	static const char *fbSymbols[] = {
481	"fbPictureInit",
482	"fbScreenInit",
483	NULL
484	};
485
486	static const char *shadowfbSymbols[] = {
487	"ShadowFBInit2",
488	NULL
489	};
490
491	static const char *vbeSymbols[] = {
492	"VBEExtendedInit",
493	"VBEFindSupportedDepths",
494	"VBEGetModeInfo",
495	"VBEGetVBEInfo",
496	"VBEGetVBEMode",
497	"VBEPrintModes",
498	"VBESaveRestore",
499	"VBESetDisplayStart",
500	"VBESetGetDACPaletteFormat",
501	"VBESetGetLogicalScanlineLength",
502	"VBESetGetPaletteData",
503	"VBESetModeNames",
504	"VBESetModeParameters",
505	"VBESetVBEMode",
506	"VBEValidateModes",
507	"vbeDoEDID",
508	"vbeFree",
509	NULL
510	};
511
512	static const char *ramdacSymbols[] = {
513	"xf86InitCursor",
514	"xf86CreateCursorInfoRec",
515	NULL
516	};
517
518	#ifdef VBOX_DRI
519	static const char *drmSymbols[] = {
520	"drmFreeVersion",
521	"drmGetVersion",
522	NULL
523	};
524
525	static const char *driSymbols[] = {
526	"DRICloseScreen",
527	"DRICreateInfoRec",
528	"DRIDestroyInfoRec",
529	"DRIFinishScreenInit",
530	"DRIGetSAREAPrivate",
531	"DRILock",
532	"DRIMoveBuffersHelper",
533	"DRIQueryVersion",
534	"DRIScreenInit",
535	"DRIUnlock",
536	"GlxSetVisualConfigs",
537	"DRICreatePCIBusID",
538	NULL
539	};
540	#endif
541
542	#ifdef XFree86LOADER
543	/* Module loader interface */
544	static MODULESETUPPROTO(vboxSetup);
545
546	static XF86ModuleVersionInfo vboxVersionRec =
547	{
548	VBOX_DRIVER_NAME,
549	"Sun Microsystems, Inc.",
550	MODINFOSTRING1,
551	MODINFOSTRING2,
552	XORG_VERSION_CURRENT,
553	1, /* Module major version. Xorg-specific */
554	0, /* Module minor version. Xorg-specific */
555	1, /* Module patchlevel. Xorg-specific */
556	ABI_CLASS_VIDEODRV, /* This is a video driver */
557	ABI_VIDEODRV_VERSION,
558	MOD_CLASS_VIDEODRV,
559	{0, 0, 0, 0}
560	};
561
562	/*
563	* This data is accessed by the loader. The name must be the module name
564	* followed by "ModuleData".
565	*/
566	_X_EXPORT XF86ModuleData vboxvideoModuleData = { &vboxVersionRec, vboxSetup, NULL };
567
568	static pointer
569	vboxSetup(pointer Module, pointer Options, int ErrorMajor, int ErrorMinor)
570	{
571	static Bool Initialised = FALSE;
572
573	if (!Initialised)
574	{
575	Initialised = TRUE;
576	#ifdef PCIACCESS
577	xf86AddDriver(&VBOXDRV, Module, HaveDriverFuncs);
578	#else
579	xf86AddDriver(&VBOXDRV, Module, 0);
580	#endif
581	LoaderRefSymLists(fbSymbols,
582	shadowfbSymbols,
583	vbeSymbols,
584	ramdacSymbols,
585	#ifdef VBOX_DRI
586	drmSymbols, driSymbols,
587	#endif
588	NULL);
589	return (pointer)TRUE;
590	}
591
592	if (ErrorMajor)
593	*ErrorMajor = LDR_ONCEONLY;
594	return (NULL);
595	}
596
597	#endif /* XFree86Loader defined */
598
599	static const OptionInfoRec *
600	VBOXAvailableOptions(int chipid, int busid)
601	{
602	return (VBOXOptions);
603	}
604
605	static void
606	VBOXIdentify(int flags)
607	{
608	xf86PrintChipsets(VBOX_NAME, "guest driver for VirtualBox", VBOXChipsets);
609	}
610
611	/*
612	* This function is called once, at the start of the first server generation to
613	* do a minimal probe for supported hardware.
614	*/
615
616	#ifdef PCIACCESS
617	static Bool
618	VBOXPciProbe(DriverPtr drv, int entity_num, struct pci_device *dev,
619	intptr_t match_data)
620	{
621	ScrnInfoPtr pScrn;
622
623	TRACE_ENTRY();
624	pScrn = xf86ConfigPciEntity(NULL, 0, entity_num, VBOXPCIchipsets,
625	NULL, NULL, NULL, NULL, NULL);
626	if (pScrn != NULL) {
627	VBOXPtr pVBox = VBOXGetRec(pScrn);
628
629	pScrn->driverVersion = VBOX_VERSION;
630	pScrn->driverName = VBOX_DRIVER_NAME;
631	pScrn->name = VBOX_NAME;
632	pScrn->Probe = NULL;
633	pScrn->PreInit = VBOXPreInit;
634	pScrn->ScreenInit = VBOXScreenInit;
635	pScrn->SwitchMode = VBOXSwitchMode;
636	pScrn->ValidMode = VBOXValidMode;
637	pScrn->AdjustFrame = VBOXAdjustFrame;
638	pScrn->EnterVT = VBOXEnterVT;
639	pScrn->LeaveVT = VBOXLeaveVT;
640	pScrn->FreeScreen = VBOXFreeScreen;
641
642	pVBox->pciInfo = dev;
643	}
644
645	TRACE_LOG("returning %s\n", BOOL_STR(pScrn != NULL));
646	return (pScrn != NULL);
647	}
648	#endif
649
650	#ifndef PCIACCESS
651	static Bool
652	VBOXProbe(DriverPtr drv, int flags)
653	{
654	Bool foundScreen = FALSE;
655	int numDevSections;
656	GDevPtr *devSections;
657
658	/*
659	* Find the config file Device sections that match this
660	* driver, and return if there are none.
661	*/
662	if ((numDevSections = xf86MatchDevice(VBOX_NAME,
663	&devSections)) <= 0)
664	return (FALSE);
665
666	/* PCI BUS */
667	if (xf86GetPciVideoInfo()) {
668	int numUsed;
669	int *usedChips;
670	int i;
671	numUsed = xf86MatchPciInstances(VBOX_NAME, VBOX_VENDORID,
672	VBOXChipsets, VBOXPCIchipsets,
673	devSections, numDevSections,
674	drv, &usedChips);
675	if (numUsed > 0) {
676	if (flags & PROBE_DETECT)
677	foundScreen = TRUE;
678	else {
679	for (i = 0; i < numUsed; i++) {
680	ScrnInfoPtr pScrn = NULL;
681	/* Allocate a ScrnInfoRec */
682	if ((pScrn = xf86ConfigPciEntity(pScrn,0,usedChips[i],
683	VBOXPCIchipsets,NULL,
684	NULL,NULL,NULL,NULL))) {
685	pScrn->driverVersion = VBOX_VERSION;
686	pScrn->driverName = VBOX_DRIVER_NAME;
687	pScrn->name = VBOX_NAME;
688	pScrn->Probe = VBOXProbe;
689	pScrn->PreInit = VBOXPreInit;
690	pScrn->ScreenInit = VBOXScreenInit;
691	pScrn->SwitchMode = VBOXSwitchMode;
692	pScrn->ValidMode = VBOXValidMode;
693	pScrn->AdjustFrame = VBOXAdjustFrame;
694	pScrn->EnterVT = VBOXEnterVT;
695	pScrn->LeaveVT = VBOXLeaveVT;
696	pScrn->FreeScreen = VBOXFreeScreen;
697	foundScreen = TRUE;
698	}
699	}
700	}
701	xfree(usedChips);
702	}
703	}
704
705	xfree(devSections);
706
707	return (foundScreen);
708	}
709	#endif
710
711	/*
712	* QUOTE from the XFree86 DESIGN document:
713	*
714	* The purpose of this function is to find out all the information
715	* required to determine if the configuration is usable, and to initialise
716	* those parts of the ScrnInfoRec that can be set once at the beginning of
717	* the first server generation.
718	*
719	* (...)
720	*
721	* This includes probing for video memory, clocks, ramdac, and all other
722	* HW info that is needed. It includes determining the depth/bpp/visual
723	* and related info. It includes validating and determining the set of
724	* video modes that will be used (and anything that is required to
725	* determine that).
726	*
727	* This information should be determined in the least intrusive way
728	* possible. The state of the HW must remain unchanged by this function.
729	* Although video memory (including MMIO) may be mapped within this
730	* function, it must be unmapped before returning.
731	*
732	* END QUOTE
733	*/
734
735	static Bool
736	VBOXPreInit(ScrnInfoPtr pScrn, int flags)
737	{
738	VBOXPtr pVBox;
739	Gamma gzeros = {0.0, 0.0, 0.0};
740	rgb rzeros = {0, 0, 0};
741	xf86OutputPtr output;
742
743	/* Are we really starting the server, or is this just a dummy run? */
744	if (flags & PROBE_DETECT)
745	return (FALSE);
746
747	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
748	"VirtualBox guest additions video driver version "
749	VBOX_VERSION_STRING "\n");
750
751	/* Get our private data from the ScrnInfoRec structure. */
752	pVBox = VBOXGetRec(pScrn);
753
754	/* Initialise the guest library */
755	vbox_init(pScrn->scrnIndex, pVBox);
756
757	/* Entity information seems to mean bus information. */
758	pVBox->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
759
760	/* We need the vbe module because we use VBE code to save and restore
761	text mode, in order to keep our code simple. */
762	if (!xf86LoadSubModule(pScrn, "vbe"))
763	return (FALSE);
764	xf86LoaderReqSymLists(vbeSymbols, NULL);
765
766	if ((pVBox->pVbe = VBEExtendedInit(NULL, pVBox->pEnt->index,
767	SET_BIOS_SCRATCH
768	\| RESTORE_BIOS_SCRATCH)) == NULL)
769	return (FALSE);
770
771	#ifndef PCIACCESS
772	if (pVBox->pEnt->location.type != BUS_PCI)
773	return FALSE;
774
775	pVBox->pciInfo = xf86GetPciInfoForEntity(pVBox->pEnt->index);
776	pVBox->pciTag = pciTag(pVBox->pciInfo->bus,
777	pVBox->pciInfo->device,
778	pVBox->pciInfo->func);
779	#endif
780
781	/* The ramdac module is needed for the hardware cursor. */
782	if (!xf86LoadSubModule(pScrn, "ramdac"))
783	return FALSE;
784	xf86LoaderReqSymLists(ramdacSymbols, NULL);
785
786	/* The framebuffer module. */
787	if (xf86LoadSubModule(pScrn, "fb") == NULL)
788	return (FALSE);
789	xf86LoaderReqSymLists(fbSymbols, NULL);
790
791	if (!xf86LoadSubModule(pScrn, "shadowfb"))
792	return FALSE;
793	xf86LoaderReqSymLists(shadowfbSymbols, NULL);
794
795	/* Set up our ScrnInfoRec structure to describe our virtual
796	capabilities to X. */
797
798	pScrn->chipset = "vbox";
799
800	/* I assume that this is no longer a requirement in the config file. */
801	pScrn->monitor = pScrn->confScreen->monitor;
802
803	pScrn->progClock = TRUE;
804	pScrn->rgbBits = 8;
805
806	/* Using the PCI information caused problems with non-powers-of-two
807	sized video RAM configurations */
808	pScrn->videoRam = inl(VBE_DISPI_IOPORT_DATA) / 1024;
809
810	/* Query the host for the preferred colour depth */
811	{
812	uint32_t cx, cy, iDisplay, cBits = 24;
813
814	if (vbox_device_available(pVBox))
815	{
816	/* We only support 16 and 24 bits depth (i.e. 16 and 32bpp) */
817	if ( vboxGetDisplayChangeRequest(pScrn, &cx, &cy, &cBits,
818	&iDisplay)
819	&& (cBits != 16)
820	)
821	cBits = 24;
822	}
823	if (!xf86SetDepthBpp(pScrn, cBits, 0, 0, Support32bppFb))
824	return FALSE;
825	}
826	if (pScrn->bitsPerPixel != 32 && pScrn->bitsPerPixel != 16)
827	{
828	xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
829	"The VBox additions only support 16 and 32bpp graphics modes\n");
830	return FALSE;
831	}
832	xf86PrintDepthBpp(pScrn);
833
834	/* options */
835	xf86CollectOptions(pScrn, NULL);
836	if (!(pVBox->Options = xalloc(sizeof(VBOXOptions))))
837	return FALSE;
838	memcpy(pVBox->Options, VBOXOptions, sizeof(VBOXOptions));
839	xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pVBox->Options);
840
841	/* Initialise CRTC and output configuration for use with randr1.2. */
842	xf86CrtcConfigInit(pScrn, &VBOXCrtcConfigFuncs);
843
844	/* Setup our single virtual CRTC. */
845	xf86CrtcCreate(pScrn, &VBOXCrtcFuncs);
846
847	/* Set up our single virtual output. */
848	output = xf86OutputCreate(pScrn, &VBOXOutputFuncs, "VBOX1");
849
850	/* Set a sane minimum and maximum mode size */
851	xf86CrtcSetSizeRange(pScrn, 64, 64, 32000, 32000);
852
853	/* We are not interested in the monitor section in the configuration file. */
854	xf86OutputUseScreenMonitor(output, FALSE);
855	output->possible_crtcs = 1;
856	output->possible_clones = 0;
857
858	/* Now create our initial CRTC/output configuration. */
859	if (!xf86InitialConfiguration(pScrn, TRUE)) {
860	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Initial CRTC configuration failed!\n");
861	return (FALSE);
862	}
863
864	/* Colour weight - we always call this, since we are always in
865	truecolour. */
866	if (!xf86SetWeight(pScrn, rzeros, rzeros))
867	return (FALSE);
868
869	/* visual init */
870	if (!xf86SetDefaultVisual(pScrn, -1))
871	return (FALSE);
872
873	xf86SetGamma(pScrn, gzeros);
874
875	/* Set a default display resolution. */
876	xf86SetDpi(pScrn, 96, 96);
877
878	/* Framebuffer-related setup */
879	pScrn->bitmapBitOrder = BITMAP_BIT_ORDER;
880
881	#ifdef VBOX_DRI
882	/* Load the dri module. */
883	if (xf86LoadSubModule(pScrn, "dri")) {
884	xf86LoaderReqSymLists(driSymbols, drmSymbols, NULL);
885	}
886	#endif
887	return (TRUE);
888	}
889
890	/**
891	* This function hooks into the chain that is called when framebuffer access
892	* is allowed or disallowed by a call to EnableDisableFBAccess in the server.
893	* In other words, it observes when the server wishes access to the
894	* framebuffer to be enabled and when it should be disabled. We need to know
895	* this because we disable access ourselves during mode switches (presumably
896	* the server should do this but it doesn't) and want to know whether to
897	* restore it or not afterwards.
898	*/
899	static void
900	vboxEnableDisableFBAccess(int scrnIndex, Bool enable)
901	{
902	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
903	VBOXPtr pVBox = VBOXGetRec(pScrn);
904
905	TRACE_LOG("enable=%s\n", enable ? "TRUE" : "FALSE");
906	pVBox->accessEnabled = enable;
907	pVBox->EnableDisableFBAccess(scrnIndex, enable);
908	TRACE_EXIT();
909	}
910
911	/*
912	* QUOTE from the XFree86 DESIGN document:
913	*
914	* This is called at the start of each server generation.
915	*
916	* (...)
917	*
918	* Decide which operations need to be placed under resource access
919	* control. (...) Map any video memory or other memory regions. (...)
920	* Save the video card state. (...) Initialise the initial video
921	* mode.
922	*
923	* End QUOTE.Initialise the initial video mode.
924	*/
925	static Bool
926	VBOXScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
927	{
928	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
929	VBOXPtr pVBox = VBOXGetRec(pScrn);
930	VisualPtr visual;
931	unsigned flags;
932
933	if (pVBox->mapPhys == 0) {
934	#ifdef PCIACCESS
935	pVBox->mapPhys = pVBox->pciInfo->regions[0].base_addr;
936	#else
937	pVBox->mapPhys = pVBox->pciInfo->memBase[0];
938	#endif
939	/* pVBox->mapSize = 1 << pVBox->pciInfo->size[0]; */
940	/* Using the PCI information caused problems with
941	non-powers-of-two sized video RAM configurations */
942	pVBox->mapSize = inl(VBE_DISPI_IOPORT_DATA);
943	pVBox->mapOff = 0;
944	}
945
946	if (!VBOXMapVidMem(pScrn))
947	return (FALSE);
948
949	/* save current video state */
950	VBOXSaveRestore(pScrn, MODE_SAVE);
951	pVBox->savedPal = VBESetGetPaletteData(pVBox->pVbe, FALSE, 0, 256,
952	NULL, FALSE, FALSE);
953
954	/* mi layer - reset the visual list (?)*/
955	miClearVisualTypes();
956	if (!xf86SetDefaultVisual(pScrn, -1))
957	return (FALSE);
958	if (!miSetVisualTypes(pScrn->depth, TrueColorMask,
959	pScrn->rgbBits, TrueColor))
960	return (FALSE);
961	if (!miSetPixmapDepths())
962	return (FALSE);
963
964	/* Needed before we initialise DRI. */
965	pScrn->virtualX = (pScrn->virtualX + 7) & ~7;
966	pScrn->displayWidth = pScrn->virtualX;
967
968	#ifdef VBOX_DRI
969	pVBox->useDRI = VBOXDRIScreenInit(scrnIndex, pScreen, pVBox);
970	#endif
971
972	/* I checked in the sources, and XFree86 4.2 does seem to support
973	this function for 32bpp. */
974	if (!fbScreenInit(pScreen, pVBox->base,
975	pScrn->virtualX, pScrn->virtualY,
976	pScrn->xDpi, pScrn->yDpi,
977	pScrn->virtualX, pScrn->bitsPerPixel))
978	return (FALSE);
979
980	/* Fixup RGB ordering */
981	visual = pScreen->visuals + pScreen->numVisuals;
982	while (--visual >= pScreen->visuals) {
983	if ((visual->class \| DynamicClass) == DirectColor) {
984	visual->offsetRed = pScrn->offset.red;
985	visual->offsetGreen = pScrn->offset.green;
986	visual->offsetBlue = pScrn->offset.blue;
987	visual->redMask = pScrn->mask.red;
988	visual->greenMask = pScrn->mask.green;
989	visual->blueMask = pScrn->mask.blue;
990	}
991	}
992
993	/* must be after RGB ordering fixed */
994	fbPictureInit(pScreen, 0, 0);
995
996	xf86SetBlackWhitePixels(pScreen);
997	miInitializeBackingStore(pScreen);
998	xf86SetBackingStore(pScreen);
999
1000	/* We need to keep track of whether we are currently switched to a virtual
1001	* terminal to know whether a mode set operation is currently safe to do.
1002	*/
1003	pVBox->vtSwitch = FALSE;
1004	/* Initialise DGA. The cast is unfortunately correct - it gets cast back
1005	to (unsigned char ) later. /
1006	xf86DiDGAInit(pScreen, (unsigned long) pVBox->base);
1007
1008	/* Initialise randr 1.2 mode-setting functions and set first mode. */
1009	if (!xf86CrtcScreenInit(pScreen)) {
1010	return FALSE;
1011	}
1012
1013	if (!xf86SetDesiredModes(pScrn)) {
1014	return FALSE;
1015	}
1016
1017	/* set the viewport */
1018	VBOXAdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
1019
1020	/* software cursor */
1021	miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
1022
1023	/* colourmap code - apparently, we need this even in Truecolour */
1024	if (!miCreateDefColormap(pScreen))
1025	return (FALSE);
1026
1027	flags = CMAP_RELOAD_ON_MODE_SWITCH;
1028
1029	if(!xf86HandleColormaps(pScreen, 256,
1030	8 /* DAC is switchable to 8 bits per primary color */,
1031	VBOXLoadPalette, NULL, flags))
1032	return (FALSE);
1033
1034	/* Hook our observer function ito the chain which is called when
1035	* framebuffer access is enabled or disabled in the server, and
1036	* assume an initial state of enabled. */
1037	pVBox->accessEnabled = TRUE;
1038	pVBox->EnableDisableFBAccess = pScrn->EnableDisableFBAccess;
1039	pScrn->EnableDisableFBAccess = vboxEnableDisableFBAccess;
1040
1041	pVBox->CloseScreen = pScreen->CloseScreen;
1042	pScreen->CloseScreen = VBOXCloseScreen;
1043	pScreen->SaveScreen = xf86SaveScreen;
1044
1045	/* We probably do want to support power management - even if we just use
1046	a dummy function. */
1047	xf86DPMSInit(pScreen, xf86DPMSSet, 0);
1048
1049	/* Report any unused options (only for the first generation) */
1050	if (serverGeneration == 1)
1051	xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
1052
1053	if (vbox_device_available(pVBox) && vbox_open (pScrn, pScreen, pVBox)) {
1054	if (vbox_cursor_init(pScreen) != TRUE)
1055	xf86DrvMsg(scrnIndex, X_ERROR,
1056	"Unable to start the VirtualBox mouse pointer integration with the host system.\n");
1057	if (vboxEnableVbva(pScrn) == TRUE)
1058	xf86DrvMsg(scrnIndex, X_INFO,
1059	"The VBox video extensions are now enabled.\n");
1060	vboxEnableGraphicsCap(pVBox);
1061	/* Report the largest resolution that we support */
1062	}
1063
1064	#ifdef VBOX_DRI
1065	if (pVBox->useDRI)
1066	pVBox->useDRI = VBOXDRIFinishScreenInit(pScreen);
1067	#endif
1068	return (TRUE);
1069	}
1070
1071	static Bool
1072	VBOXEnterVT(int scrnIndex, int flags)
1073	{
1074	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
1075	VBOXPtr pVBox = VBOXGetRec(pScrn);
1076	bool rc;
1077
1078	TRACE_ENTRY();
1079	pVBox->vtSwitch = FALSE;
1080	#ifdef VBOX_DRI
1081	if (pVBox->useDRI)
1082	DRIUnlock(screenInfo.screens[scrnIndex]);
1083	#endif
1084	rc = xf86SetDesiredModes(pScrn);
1085	TRACE_LOG("returning %s\n", rc ? "TRUE" : "FALSE");
1086	return rc;
1087	}
1088
1089	static void
1090	VBOXLeaveVT(int scrnIndex, int flags)
1091	{
1092	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
1093	VBOXPtr pVBox = VBOXGetRec(pScrn);
1094
1095	TRACE_ENTRY();
1096	pVBox->vtSwitch = TRUE;
1097	VBOXSaveRestore(pScrn, MODE_RESTORE);
1098	if (vbox_device_available(pVBox))
1099	{
1100	if (pVBox->useVbva == TRUE)
1101	vboxDisableVbva(pScrn);
1102	vboxDisableGraphicsCap(pVBox);
1103	}
1104	#ifdef VBOX_DRI
1105	if (pVBox->useDRI)
1106	DRILock(screenInfo.screens[scrnIndex], 0);
1107	#endif
1108	TRACE_EXIT();
1109	}
1110
1111	static Bool
1112	VBOXCloseScreen(int scrnIndex, ScreenPtr pScreen)
1113	{
1114	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
1115	VBOXPtr pVBox = VBOXGetRec(pScrn);
1116
1117	#ifdef VBOX_DRI
1118	if (pVBox->useDRI)
1119	VBOXDRICloseScreen(pScreen, pVBox);
1120	pVBox->useDRI = false;
1121	#endif
1122
1123	if (vbox_device_available(pVBox))
1124	{
1125	if (TRUE == pVBox->useVbva)
1126	vboxDisableVbva(pScrn);
1127	vboxDisableGraphicsCap(pVBox);
1128	}
1129	if (pScrn->vtSema) {
1130	VBOXSaveRestore(xf86Screens[scrnIndex], MODE_RESTORE);
1131	if (pVBox->savedPal)
1132	VBESetGetPaletteData(pVBox->pVbe, TRUE, 0, 256,
1133	pVBox->savedPal, FALSE, TRUE);
1134	VBOXUnmapVidMem(pScrn);
1135	}
1136	pScrn->vtSema = FALSE;
1137
1138	/* Remove our observer functions from the X server call chains. */
1139	pScrn->EnableDisableFBAccess = pVBox->EnableDisableFBAccess;
1140	pScreen->CloseScreen = pVBox->CloseScreen;
1141	return pScreen->CloseScreen(scrnIndex, pScreen);
1142	}
1143
1144	/**
1145	* Quoted from "How to add an (S)VGA driver to XFree86"
1146	* (http://www.xfree86.org/3.3.6/VGADriver.html):
1147	*
1148	* The ValidMode() function is required. It is used to check for any
1149	* chipset-dependent reasons why a graphics mode might not be valid. It gets
1150	* called by higher levels of the code after the Probe() stage. In many cases
1151	* no special checking will be required and this function will simply return
1152	* TRUE always.
1153	*
1154	* Note: we check here that our generated video modes fulfil the X server's
1155	* criteria for the monitor, since this can otherwise cause problems in
1156	* randr 1.2.
1157	*/
1158	static ModeStatus
1159	VBOXValidMode(int scrn, DisplayModePtr p, Bool flag, int pass)
1160	{
1161	static int warned = 0;
1162	ScrnInfoPtr pScrn = xf86Screens[scrn];
1163	MonPtr mon = pScrn->monitor;
1164	ModeStatus ret = MODE_BAD;
1165	DisplayModePtr mode;
1166	float v;
1167
1168	TRACE_LOG("HDisplay=%d, VDisplay=%d, flag=%s, pass=%d\n",
1169	p->HDisplay, p->VDisplay, flag ? "TRUE" : "FALSE", pass);
1170	if (pass != MODECHECK_FINAL) {
1171	if (!warned) {
1172	xf86DrvMsg(scrn, X_WARNING, "VBOXValidMode called unexpectedly\n");
1173	warned = 1;
1174	}
1175	}
1176	#if 0
1177	/*
1178	* First off, if this isn't a mode we handed to the server (ie,
1179	* M_T_BUILTIN), then we reject it out of hand.
1180	*/
1181	if (!(p->type & M_T_BUILTIN))
1182	return MODE_NOMODE;
1183	#endif
1184	/*
1185	* Finally, walk through the vsync rates 1Hz at a time looking for a mode
1186	* that will fit. This is assuredly a terrible way to do this, but
1187	* there's no obvious method for computing a mode of a given size that
1188	* will pass xf86CheckModeForMonitor.
1189	*/
1190	for (v = mon->vrefresh[0].lo; v <= mon->vrefresh[0].hi; v++) {
1191	mode = xf86CVTMode(p->HDisplay, p->VDisplay, v, 0, 0);
1192	ret = xf86CheckModeForMonitor(mode, mon);
1193	xfree(mode);
1194	if (ret == MODE_OK)
1195	break;
1196	}
1197
1198	if (ret != MODE_OK)
1199	{
1200	xf86DrvMsg(scrn, X_WARNING, "Graphics mode %s rejected by the X server\n", p->name);
1201	}
1202	TRACE_LOG("returning %d\n", ret);
1203	return ret;
1204	}
1205
1206	static Bool
1207	VBOXSwitchMode(int scrnIndex, DisplayModePtr pMode, int flags)
1208	{
1209	ScrnInfoPtr pScrn;
1210	VBOXPtr pVBox;
1211	Bool rc;
1212
1213	TRACE_LOG("HDisplay=%d, VDisplay=%d\n", pMode->HDisplay, pMode->VDisplay);
1214	pScrn = xf86Screens[scrnIndex]; /* Why does X have three ways of refering to the screen? */
1215	pVBox = VBOXGetRec(pScrn);
1216	/* We want to disable access to the framebuffer before switching mode.
1217	* After doing the switch, we allow access if it was allowed before. */
1218	if (pVBox->accessEnabled)
1219	pVBox->EnableDisableFBAccess(scrnIndex, FALSE);
1220	rc = xf86SetSingleMode(pScrn, pMode, 0);
1221	if (pVBox->accessEnabled)
1222	pVBox->EnableDisableFBAccess(scrnIndex, TRUE);
1223	TRACE_LOG("returning %s\n", rc ? "TRUE" : "FALSE");
1224	return rc;
1225	}
1226
1227	/* Set a graphics mode. Poke the required values into registers, enable
1228	guest-host acceleration functions and tell the host we support advanced
1229	graphics functions. */
1230	static Bool
1231	VBOXSetMode(ScrnInfoPtr pScrn, DisplayModePtr pMode)
1232	{
1233	VBOXPtr pVBox;
1234	Bool rc = TRUE;
1235
1236	int bpp = pScrn->depth == 24 ? 32 : 16;
1237	TRACE_LOG("HDisplay=%d, VDisplay=%d, displayWidth=%d\n",
1238	pMode->HDisplay, pMode->VDisplay, pScrn->displayWidth);
1239	pVBox = VBOXGetRec(pScrn);
1240	/* Don't fiddle with the hardware if we are switched
1241	* to a virtual terminal. */
1242	if (!pVBox->vtSwitch)
1243	{
1244	if ( vbox_device_available(pVBox)
1245	&& (TRUE == pVBox->useVbva)
1246	&& (vboxDisableVbva(pScrn) != TRUE)
1247	) /* This would be bad. */
1248	rc = FALSE;
1249	if (rc)
1250	{
1251	/* Disable linear framebuffer mode before making changes to the resolution. */
1252	outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_ENABLE);
1253	outw(VBE_DISPI_IOPORT_DATA, VBE_DISPI_DISABLED);
1254	/* Unlike the resolution, the depth is fixed for a given screen
1255	for the lifetime of the X session. */
1256	outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_BPP);
1257	outw(VBE_DISPI_IOPORT_DATA, bpp);
1258	/* HDisplay and VDisplay are actually monitor information about
1259	the display part of the scanlines. */
1260	outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_XRES);
1261	outw(VBE_DISPI_IOPORT_DATA, pMode->HDisplay);
1262	outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_YRES);
1263	outw(VBE_DISPI_IOPORT_DATA, pMode->VDisplay);
1264	/* Set the virtual resolution. We are still using VESA to control
1265	the virtual offset. */
1266	outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_VIRT_WIDTH);
1267	outw(VBE_DISPI_IOPORT_DATA, pScrn->displayWidth);
1268	/* Enable linear framebuffer mode. */
1269	outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_ENABLE);
1270	outw(VBE_DISPI_IOPORT_DATA,
1271	VBE_DISPI_ENABLED \| VBE_DISPI_LFB_ENABLED);
1272	/* Enable acceleration and tell the host we support graphics */
1273	if (vbox_device_available(pVBox))
1274	{
1275	if ((TRUE == pVBox->useVbva) && (vboxEnableVbva(pScrn) != TRUE))
1276	/* Bad but not fatal */
1277	pVBox->useVbva = FALSE;
1278	vboxEnableGraphicsCap(pVBox);
1279	}
1280	}
1281	}
1282	TRACE_LOG("returning %s\n", rc ? "TRUE" : "FALSE");
1283	return rc;
1284	}
1285
1286	static void
1287	VBOXAdjustFrame(int scrnIndex, int x, int y, int flags)
1288	{
1289	VBOXPtr pVBox = VBOXGetRec(xf86Screens[scrnIndex]);
1290	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
1291
1292	TRACE_ENTRY();
1293	/* Don't fiddle with the hardware if we are switched
1294	* to a virtual terminal. */
1295	if (!pVBox->vtSwitch) {
1296	pVBox->viewportX = x;
1297	pVBox->viewportY = y;
1298	/* If VBVA is enabled the graphics card will not notice the change. */
1299	if (pVBox->useVbva == TRUE)
1300	vboxDisableVbva(pScrn);
1301	VBESetDisplayStart(pVBox->pVbe, x, y, TRUE);
1302	if (pVBox->useVbva == TRUE)
1303	vboxEnableVbva(pScrn);
1304	}
1305	TRACE_EXIT();
1306	}
1307
1308	static void
1309	VBOXFreeScreen(int scrnIndex, int flags)
1310	{
1311	VBOXFreeRec(xf86Screens[scrnIndex]);
1312	}
1313
1314	static Bool
1315	VBOXMapVidMem(ScrnInfoPtr pScrn)
1316	{
1317	VBOXPtr pVBox = VBOXGetRec(pScrn);
1318	Bool rc = TRUE;
1319
1320	TRACE_ENTRY();
1321	if (NULL == pVBox->base)
1322	{
1323	pScrn->memPhysBase = pVBox->mapPhys;
1324	pScrn->fbOffset = pVBox->mapOff;
1325
1326	#ifdef PCIACCESS
1327	(void) pci_device_map_range(pVBox->pciInfo,
1328	pScrn->memPhysBase,
1329	pVBox->mapSize,
1330	PCI_DEV_MAP_FLAG_WRITABLE,
1331	& pVBox->base);
1332
1333	if (pVBox->base) {
1334	pScrn->memPhysBase = pVBox->mapPhys;
1335	pVBox->VGAbase = xf86MapDomainMemory(pScrn->scrnIndex, 0,
1336	pVBox->pciInfo,
1337	0xa0000, 0x10000);
1338	}
1339	#else
1340	pVBox->base = xf86MapPciMem(pScrn->scrnIndex,
1341	VIDMEM_FRAMEBUFFER,
1342	pVBox->pciTag, pVBox->mapPhys,
1343	(unsigned) pVBox->mapSize);
1344
1345	if (pVBox->base) {
1346	pScrn->memPhysBase = pVBox->mapPhys;
1347	pVBox->VGAbase = xf86MapDomainMemory(pScrn->scrnIndex, 0,
1348	pVBox->pciTag,
1349	0xa0000, 0x10000);
1350	}
1351	#endif
1352	/* We need this for saving/restoring textmode */
1353	pVBox->ioBase = pScrn->domainIOBase;
1354
1355	rc = pVBox->base != NULL;
1356	}
1357	TRACE_LOG("returning %s\n", rc ? "TRUE" : "FALSE");
1358	return rc;
1359	}
1360
1361	static void
1362	VBOXUnmapVidMem(ScrnInfoPtr pScrn)
1363	{
1364	VBOXPtr pVBox = VBOXGetRec(pScrn);
1365
1366	TRACE_ENTRY();
1367	if (pVBox->base == NULL)
1368	return;
1369
1370	#ifdef PCIACCESS
1371	(void) pci_device_unmap_range(pVBox->pciInfo,
1372	pVBox->base,
1373	pVBox->mapSize);
1374	xf86UnMapVidMem(pScrn->scrnIndex, pVBox->VGAbase, 0x10000);
1375	#else
1376	xf86UnMapVidMem(pScrn->scrnIndex, pVBox->base,
1377	(unsigned) pVBox->mapSize);
1378	xf86UnMapVidMem(pScrn->scrnIndex, pVBox->VGAbase, 0x10000);
1379	#endif
1380	pVBox->base = NULL;
1381	TRACE_EXIT();
1382	}
1383
1384	static void
1385	VBOXLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
1386	LOCO *colors, VisualPtr pVisual)
1387	{
1388	VBOXPtr pVBox = VBOXGetRec(pScrn);
1389	int i, idx;
1390	#define VBOXDACDelay() \
1391	do { \
1392	(void)inb(pVBox->ioBase + VGA_IOBASE_COLOR + VGA_IN_STAT_1_OFFSET); \
1393	(void)inb(pVBox->ioBase + VGA_IOBASE_COLOR + VGA_IN_STAT_1_OFFSET); \
1394	} while (0)
1395
1396	TRACE_ENTRY();
1397	for (i = 0; i < numColors; i++) {
1398	idx = indices[i];
1399	outb(pVBox->ioBase + VGA_DAC_WRITE_ADDR, idx);
1400	VBOXDACDelay();
1401	outb(pVBox->ioBase + VGA_DAC_DATA, colors[idx].red);
1402	VBOXDACDelay();
1403	outb(pVBox->ioBase + VGA_DAC_DATA, colors[idx].green);
1404	VBOXDACDelay();
1405	outb(pVBox->ioBase + VGA_DAC_DATA, colors[idx].blue);
1406	VBOXDACDelay();
1407	}
1408	TRACE_EXIT();
1409	}
1410
1411	/*
1412	* Just adapted from the std* functions in vgaHW.c
1413	*/
1414	static void
1415	WriteAttr(VBOXPtr pVBox, int index, int value)
1416	{
1417	(void) inb(pVBox->ioBase + VGA_IOBASE_COLOR + VGA_IN_STAT_1_OFFSET);
1418
1419	index \|= 0x20;
1420	outb(pVBox->ioBase + VGA_ATTR_INDEX, index);
1421	outb(pVBox->ioBase + VGA_ATTR_DATA_W, value);
1422	}
1423
1424	static int
1425	ReadAttr(VBOXPtr pVBox, int index)
1426	{
1427	(void) inb(pVBox->ioBase + VGA_IOBASE_COLOR + VGA_IN_STAT_1_OFFSET);
1428
1429	index \|= 0x20;
1430	outb(pVBox->ioBase + VGA_ATTR_INDEX, index);
1431	return (inb(pVBox->ioBase + VGA_ATTR_DATA_R));
1432	}
1433
1434	#define WriteMiscOut(value) outb(pVBox->ioBase + VGA_MISC_OUT_W, value)
1435	#define ReadMiscOut() inb(pVBox->ioBase + VGA_MISC_OUT_R)
1436	#define WriteSeq(index, value) \
1437	outb(pVBox->ioBase + VGA_SEQ_INDEX, (index));\
1438	outb(pVBox->ioBase + VGA_SEQ_DATA, value)
1439
1440	static int
1441	ReadSeq(VBOXPtr pVBox, int index)
1442	{
1443	outb(pVBox->ioBase + VGA_SEQ_INDEX, index);
1444
1445	return (inb(pVBox->ioBase + VGA_SEQ_DATA));
1446	}
1447
1448	#define WriteGr(index, value) \
1449	outb(pVBox->ioBase + VGA_GRAPH_INDEX, index); \
1450	outb(pVBox->ioBase + VGA_GRAPH_DATA, value)
1451
1452	static int
1453	ReadGr(VBOXPtr pVBox, int index)
1454	{
1455	outb(pVBox->ioBase + VGA_GRAPH_INDEX, index);
1456
1457	return (inb(pVBox->ioBase + VGA_GRAPH_DATA));
1458	}
1459
1460	#define WriteCrtc(index, value) \
1461	outb(pVBox->ioBase + (VGA_IOBASE_COLOR + VGA_CRTC_INDEX_OFFSET), index); \
1462	outb(pVBox->ioBase + (VGA_IOBASE_COLOR + VGA_CRTC_DATA_OFFSET), value)
1463
1464	static void
1465	SeqReset(VBOXPtr pVBox, Bool start)
1466	{
1467	if (start) {
1468	WriteSeq(0x00, 0x01); /* Synchronous Reset */
1469	}
1470	else {
1471	WriteSeq(0x00, 0x03); /* End Reset */
1472	}
1473	}
1474
1475	static void
1476	SaveFonts(ScrnInfoPtr pScrn)
1477	{
1478	VBOXPtr pVBox = VBOXGetRec(pScrn);
1479	unsigned char miscOut, attr10, gr4, gr5, gr6, seq2, seq4, scrn;
1480	Bool cont = TRUE;
1481
1482	TRACE_ENTRY();
1483	if (pVBox->fonts != NULL)
1484	cont = FALSE;
1485
1486	if (cont)
1487	{
1488	/* If in graphics mode, don't save anything */
1489	attr10 = ReadAttr(pVBox, 0x10);
1490	if (attr10 & 0x01)
1491	cont = FALSE;
1492	}
1493
1494	if (cont)
1495	{
1496	pVBox->fonts = xalloc(16384);
1497
1498	/* save the registers that are needed here */
1499	miscOut = ReadMiscOut();
1500	gr4 = ReadGr(pVBox, 0x04);
1501	gr5 = ReadGr(pVBox, 0x05);
1502	gr6 = ReadGr(pVBox, 0x06);
1503	seq2 = ReadSeq(pVBox, 0x02);
1504	seq4 = ReadSeq(pVBox, 0x04);
1505
1506	/* Force into colour mode */
1507	WriteMiscOut(miscOut \| 0x01);
1508
1509	scrn = ReadSeq(pVBox, 0x01) \| 0x20;
1510	SeqReset(pVBox, TRUE);
1511	WriteSeq(0x01, scrn);
1512	SeqReset(pVBox, FALSE);
1513
1514	WriteAttr(pVBox, 0x10, 0x01); /* graphics mode */
1515
1516	/font1 /
1517	WriteSeq(0x02, 0x04); /* write to plane 2 */
1518	WriteSeq(0x04, 0x06); /* enable plane graphics */
1519	WriteGr(0x04, 0x02); /* read plane 2 */
1520	WriteGr(0x05, 0x00); /* write mode 0, read mode 0 */
1521	WriteGr(0x06, 0x05); /* set graphics */
1522	slowbcopy_frombus(pVBox->VGAbase, pVBox->fonts, 8192);
1523
1524	/* font2 */
1525	WriteSeq(0x02, 0x08); /* write to plane 3 */
1526	WriteSeq(0x04, 0x06); /* enable plane graphics */
1527	WriteGr(0x04, 0x03); /* read plane 3 */
1528	WriteGr(0x05, 0x00); /* write mode 0, read mode 0 */
1529	WriteGr(0x06, 0x05); /* set graphics */
1530	slowbcopy_frombus(pVBox->VGAbase, pVBox->fonts + 8192, 8192);
1531
1532	scrn = ReadSeq(pVBox, 0x01) & ~0x20;
1533	SeqReset(pVBox, TRUE);
1534	WriteSeq(0x01, scrn);
1535	SeqReset(pVBox, FALSE);
1536
1537	/* Restore clobbered registers */
1538	WriteAttr(pVBox, 0x10, attr10);
1539	WriteSeq(0x02, seq2);
1540	WriteSeq(0x04, seq4);
1541	WriteGr(0x04, gr4);
1542	WriteGr(0x05, gr5);
1543	WriteGr(0x06, gr6);
1544	WriteMiscOut(miscOut);
1545	}
1546	TRACE_EXIT();
1547	}
1548
1549	static void
1550	RestoreFonts(ScrnInfoPtr pScrn)
1551	{
1552	VBOXPtr pVBox = VBOXGetRec(pScrn);
1553	unsigned char miscOut, attr10, gr1, gr3, gr4, gr5, gr6, gr8, seq2, seq4, scrn;
1554
1555	TRACE_ENTRY();
1556	if (pVBox->fonts != NULL)
1557	{
1558	/* save the registers that are needed here */
1559	miscOut = ReadMiscOut();
1560	attr10 = ReadAttr(pVBox, 0x10);
1561	gr1 = ReadGr(pVBox, 0x01);
1562	gr3 = ReadGr(pVBox, 0x03);
1563	gr4 = ReadGr(pVBox, 0x04);
1564	gr5 = ReadGr(pVBox, 0x05);
1565	gr6 = ReadGr(pVBox, 0x06);
1566	gr8 = ReadGr(pVBox, 0x08);
1567	seq2 = ReadSeq(pVBox, 0x02);
1568	seq4 = ReadSeq(pVBox, 0x04);
1569
1570	/* Force into colour mode */
1571	WriteMiscOut(miscOut \| 0x01);
1572
1573	scrn = ReadSeq(pVBox, 0x01) & ~0x20;
1574	SeqReset(pVBox, TRUE);
1575	WriteSeq(0x01, scrn);
1576	SeqReset(pVBox, FALSE);
1577
1578	WriteAttr(pVBox, 0x10, 0x01); /* graphics mode */
1579	if (pScrn->depth == 4) {
1580	/* GJA */
1581	WriteGr(0x03, 0x00); /* don't rotate, write unmodified */
1582	WriteGr(0x08, 0xFF); /* write all bits in a byte */
1583	WriteGr(0x01, 0x00); /* all planes come from CPU */
1584	}
1585
1586	WriteSeq(0x02, 0x04); /* write to plane 2 */
1587	WriteSeq(0x04, 0x06); /* enable plane graphics */
1588	WriteGr(0x04, 0x02); /* read plane 2 */
1589	WriteGr(0x05, 0x00); /* write mode 0, read mode 0 */
1590	WriteGr(0x06, 0x05); /* set graphics */
1591	slowbcopy_tobus(pVBox->fonts, pVBox->VGAbase, 8192);
1592
1593	WriteSeq(0x02, 0x08); /* write to plane 3 */
1594	WriteSeq(0x04, 0x06); /* enable plane graphics */
1595	WriteGr(0x04, 0x03); /* read plane 3 */
1596	WriteGr(0x05, 0x00); /* write mode 0, read mode 0 */
1597	WriteGr(0x06, 0x05); /* set graphics */
1598	slowbcopy_tobus(pVBox->fonts + 8192, pVBox->VGAbase, 8192);
1599
1600	scrn = ReadSeq(pVBox, 0x01) & ~0x20;
1601	SeqReset(pVBox, TRUE);
1602	WriteSeq(0x01, scrn);
1603	SeqReset(pVBox, FALSE);
1604
1605	/* restore the registers that were changed */
1606	WriteMiscOut(miscOut);
1607	WriteAttr(pVBox, 0x10, attr10);
1608	WriteGr(0x01, gr1);
1609	WriteGr(0x03, gr3);
1610	WriteGr(0x04, gr4);
1611	WriteGr(0x05, gr5);
1612	WriteGr(0x06, gr6);
1613	WriteGr(0x08, gr8);
1614	WriteSeq(0x02, seq2);
1615	WriteSeq(0x04, seq4);
1616	}
1617	TRACE_EXIT();
1618	}
1619
1620	Bool
1621	VBOXSaveRestore(ScrnInfoPtr pScrn, vbeSaveRestoreFunction function)
1622	{
1623	VBOXPtr pVBox;
1624	Bool rc = TRUE;
1625
1626	TRACE_ENTRY();
1627	if (MODE_QUERY < 0 \|\| function > MODE_RESTORE)
1628	rc = FALSE;
1629
1630	if (rc)
1631	{
1632	pVBox = VBOXGetRec(pScrn);
1633
1634	/* Query amount of memory to save state */
1635	if (function == MODE_QUERY \|\|
1636	(function == MODE_SAVE && pVBox->state == NULL))
1637	{
1638
1639	/* Make sure we save at least this information in case of failure */
1640	(void)VBEGetVBEMode(pVBox->pVbe, &pVBox->stateMode);
1641	SaveFonts(pScrn);
1642
1643	if (!VBESaveRestore(pVBox->pVbe,function,(pointer)&pVBox->state,
1644	&pVBox->stateSize,&pVBox->statePage)
1645	)
1646	rc = FALSE;
1647	}
1648	}
1649	if (rc)
1650	{
1651	/* Save/Restore Super VGA state */
1652	if (function != MODE_QUERY) {
1653
1654	if (function == MODE_RESTORE)
1655	memcpy(pVBox->state, pVBox->pstate,
1656	(unsigned) pVBox->stateSize);
1657
1658	if ( (rc = VBESaveRestore(pVBox->pVbe,function,
1659	(pointer)&pVBox->state,
1660	&pVBox->stateSize,&pVBox->statePage)
1661	)
1662	&& (function == MODE_SAVE)
1663	)
1664	{
1665	/* don't rely on the memory not being touched */
1666	if (pVBox->pstate == NULL)
1667	pVBox->pstate = xalloc(pVBox->stateSize);
1668	memcpy(pVBox->pstate, pVBox->state,
1669	(unsigned) pVBox->stateSize);
1670	}
1671
1672	if (function == MODE_RESTORE)
1673	{
1674	VBESetVBEMode(pVBox->pVbe, pVBox->stateMode, NULL);
1675	RestoreFonts(pScrn);
1676	}
1677	}
1678	}
1679	TRACE_LOG("returning %s\n", rc ? "TRUE" : "FALSE");
1680	return rc;
1681	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/x11/vboxvideo/vboxvideo_13.c@ 22089

Download in other formats: