DevVGA.cpp@ 61092

Last change on this file since 61092 was 61006, checked in by vboxsync, 9 years ago
added pointer to internal bug
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 239.2 KB

Line
1	/* $Id: DevVGA.cpp 61006 2016-05-17 14:07:32Z vboxsync $ */
2	/** @file
3	* DevVGA - VBox VGA/VESA device.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 Oracle Corporation
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	*
18	* This code is based on:
19	*
20	* QEMU VGA Emulator.
21	*
22	* Copyright (c) 2003 Fabrice Bellard
23	*
24	* Permission is hereby granted, free of charge, to any person obtaining a copy
25	* of this software and associated documentation files (the "Software"), to deal
26	* in the Software without restriction, including without limitation the rights
27	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
28	* copies of the Software, and to permit persons to whom the Software is
29	* furnished to do so, subject to the following conditions:
30	*
31	* The above copyright notice and this permission notice shall be included in
32	* all copies or substantial portions of the Software.
33	*
34	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
35	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
36	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
37	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
38	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
39	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
40	* THE SOFTWARE.
41	*/
42
43
44	/*********************************************************************************************************************************
45	* Defined Constants And Macros *
46	*********************************************************************************************************************************/
47
48	/* WARNING!!! All defines that affect VGAState should be placed to DevVGA.h !!!
49	* NEVER place them here as this would lead to VGASTATE inconsistency
50	* across different .cpp files !!!
51	*/
52	/** The size of the VGA GC mapping.
53	* This is supposed to be all the VGA memory accessible to the guest.
54	* The initial value was 256KB but NTAllInOne.iso appears to access more
55	* thus the limit was upped to 512KB.
56	*
57	* @todo Someone with some VGA knowhow should make a better guess at this value.
58	*/
59	#define VGA_MAPPING_SIZE _512K
60
61	#ifdef VBOX_WITH_HGSMI
62	#define PCIDEV_2_VGASTATE(pPciDev) ((PVGASTATE)((uintptr_t)pPciDev - RT_OFFSETOF(VGASTATE, Dev)))
63	#endif /* VBOX_WITH_HGSMI */
64	/** Converts a vga adaptor state pointer to a device instance pointer. */
65	#define VGASTATE2DEVINS(pVgaState) ((pVgaState)->CTX_SUFF(pDevIns))
66
67	/** Check that the video modes fit into virtual video memory.
68	* Only works when VBE_NEW_DYN_LIST is defined! */
69	#define VRAM_SIZE_FIX
70
71	/** Check buffer if an VRAM offset is within the right range or not. */
72	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
73	# define VERIFY_VRAM_WRITE_OFF_RETURN(pThis, off) \
74	do { \
75	if ((off) >= VGA_MAPPING_SIZE) \
76	{ \
77	AssertMsgReturn((off) < (pThis)->vram_size, ("%RX32 !< %RX32\n", (uint32_t)(off), (pThis)->vram_size), VINF_SUCCESS); \
78	Log2(("%Rfn[%d]: %RX32 -> R3\n", __PRETTY_FUNCTION__, __LINE__, (off))); \
79	return VINF_IOM_R3_MMIO_WRITE; \
80	} \
81	} while (0)
82	#else
83	# define VERIFY_VRAM_WRITE_OFF_RETURN(pThis, off) \
84	AssertMsgReturn((off) < (pThis)->vram_size, ("%RX32 !< %RX32\n", (uint32_t)(off), (pThis)->vram_size), VINF_SUCCESS)
85	#endif
86
87	/** Check buffer if an VRAM offset is within the right range or not. */
88	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
89	# define VERIFY_VRAM_READ_OFF_RETURN(pThis, off, rcVar) \
90	do { \
91	if ((off) >= VGA_MAPPING_SIZE) \
92	{ \
93	AssertMsgReturn((off) < (pThis)->vram_size, ("%RX32 !< %RX32\n", (uint32_t)(off), (pThis)->vram_size), 0xff); \
94	Log2(("%Rfn[%d]: %RX32 -> R3\n", __PRETTY_FUNCTION__, __LINE__, (off))); \
95	(rcVar) = VINF_IOM_R3_MMIO_READ; \
96	return 0; \
97	} \
98	} while (0)
99	#else
100	# define VERIFY_VRAM_READ_OFF_RETURN(pThis, off, rcVar) \
101	do { \
102	AssertMsgReturn((off) < (pThis)->vram_size, ("%RX32 !< %RX32\n", (uint32_t)(off), (pThis)->vram_size), 0xff); \
103	NOREF(rcVar); \
104	} while (0)
105	#endif
106
107	/** @def VBOX_WITH_VMSVGA_BACKUP_VGA_FB
108	* Enables correct VGA MMIO read/write handling when VMSVGA is enabled. It
109	* is SLOW and probably not entirely right, but it helps with getting 3dmark
110	* output and other stuff. */
111	#define VBOX_WITH_VMSVGA_BACKUP_VGA_FB 1
112
113
114	/*********************************************************************************************************************************
115	* Header Files *
116	*********************************************************************************************************************************/
117	#define LOG_GROUP LOG_GROUP_DEV_VGA
118	#include <VBox/vmm/pdmdev.h>
119	#include <VBox/vmm/pgm.h>
120	#ifdef IN_RING3
121	# include <iprt/cdefs.h>
122	# include <iprt/mem.h>
123	# include <iprt/ctype.h>
124	#endif /* IN_RING3 */
125	#include <iprt/assert.h>
126	#include <iprt/asm.h>
127	#include <iprt/file.h>
128	#include <iprt/time.h>
129	#include <iprt/string.h>
130	#include <iprt/uuid.h>
131
132	#include <VBox/VMMDev.h>
133	#include <VBox/VBoxVideo.h>
134	#include <VBox/bioslogo.h>
135
136	/* should go BEFORE any other DevVGA include to make all DevVGA.h config defines be visible */
137	#include "DevVGA.h"
138
139	#if defined(VBE_NEW_DYN_LIST) && defined(IN_RING3) && !defined(VBOX_DEVICE_STRUCT_TESTCASE)
140	# include "DevVGAModes.h"
141	# include <stdio.h> /* sscan */
142	#endif
143
144	#include "VBoxDD.h"
145	#include "VBoxDD2.h"
146
147	#ifdef VBOX_WITH_VMSVGA
148	#include "DevVGA-SVGA.h"
149	#include "vmsvga/svga_reg.h"
150	#endif
151
152
153	/*********************************************************************************************************************************
154	* Structures and Typedefs *
155	*********************************************************************************************************************************/
156	#pragma pack(1)
157
158	/** BMP File Format Bitmap Header. */
159	typedef struct
160	{
161	uint16_t Type; /* File Type Identifier */
162	uint32_t FileSize; /* Size of File */
163	uint16_t Reserved1; /* Reserved (should be 0) */
164	uint16_t Reserved2; /* Reserved (should be 0) */
165	uint32_t Offset; /* Offset to bitmap data */
166	} BMPINFO;
167
168	/** Pointer to a bitmap header*/
169	typedef BMPINFO *PBMPINFO;
170
171	/** OS/2 1.x Information Header Format. */
172	typedef struct
173	{
174	uint32_t Size; /* Size of Remaining Header */
175	uint16_t Width; /* Width of Bitmap in Pixels */
176	uint16_t Height; /* Height of Bitmap in Pixels */
177	uint16_t Planes; /* Number of Planes */
178	uint16_t BitCount; /* Color Bits Per Pixel */
179	} OS2HDR;
180
181	/** Pointer to a OS/2 1.x header format */
182	typedef OS2HDR *POS2HDR;
183
184	/** OS/2 2.0 Information Header Format. */
185	typedef struct
186	{
187	uint32_t Size; /* Size of Remaining Header */
188	uint32_t Width; /* Width of Bitmap in Pixels */
189	uint32_t Height; /* Height of Bitmap in Pixels */
190	uint16_t Planes; /* Number of Planes */
191	uint16_t BitCount; /* Color Bits Per Pixel */
192	uint32_t Compression; /* Compression Scheme (0=none) */
193	uint32_t SizeImage; /* Size of bitmap in bytes */
194	uint32_t XPelsPerMeter; /* Horz. Resolution in Pixels/Meter */
195	uint32_t YPelsPerMeter; /* Vert. Resolution in Pixels/Meter */
196	uint32_t ClrUsed; /* Number of Colors in Color Table */
197	uint32_t ClrImportant; /* Number of Important Colors */
198	uint16_t Units; /* Resolution Measurement Used */
199	uint16_t Reserved; /* Reserved FIelds (always 0) */
200	uint16_t Recording; /* Orientation of Bitmap */
201	uint16_t Rendering; /* Halftone Algorithm Used on Image */
202	uint32_t Size1; /* Halftone Algorithm Data */
203	uint32_t Size2; /* Halftone Algorithm Data */
204	uint32_t ColorEncoding; /* Color Table Format (always 0) */
205	uint32_t Identifier; /* Misc. Field for Application Use */
206	} OS22HDR;
207
208	/** Pointer to a OS/2 2.0 header format */
209	typedef OS22HDR *POS22HDR;
210
211	/** Windows 3.x Information Header Format. */
212	typedef struct
213	{
214	uint32_t Size; /* Size of Remaining Header */
215	uint32_t Width; /* Width of Bitmap in Pixels */
216	uint32_t Height; /* Height of Bitmap in Pixels */
217	uint16_t Planes; /* Number of Planes */
218	uint16_t BitCount; /* Bits Per Pixel */
219	uint32_t Compression; /* Compression Scheme (0=none) */
220	uint32_t SizeImage; /* Size of bitmap in bytes */
221	uint32_t XPelsPerMeter; /* Horz. Resolution in Pixels/Meter */
222	uint32_t YPelsPerMeter; /* Vert. Resolution in Pixels/Meter */
223	uint32_t ClrUsed; /* Number of Colors in Color Table */
224	uint32_t ClrImportant; /* Number of Important Colors */
225	} WINHDR;
226
227	/** Pointer to a Windows 3.x header format */
228	typedef WINHDR *PWINHDR;
229
230	#pragma pack()
231
232	#define BMP_ID 0x4D42
233
234	/** @name BMP compressions.
235	* @{ */
236	#define BMP_COMPRESS_NONE 0
237	#define BMP_COMPRESS_RLE8 1
238	#define BMP_COMPRESS_RLE4 2
239	/** @} */
240
241	/** @name BMP header sizes.
242	* @{ */
243	#define BMP_HEADER_OS21 12
244	#define BMP_HEADER_OS22 64
245	#define BMP_HEADER_WIN3 40
246	/** @} */
247
248	/** The BIOS boot menu text position, X. */
249	#define LOGO_F12TEXT_X 304
250	/** The BIOS boot menu text position, Y. */
251	#define LOGO_F12TEXT_Y 460
252
253	/** Width of the "Press F12 to select boot device." bitmap.
254	Anything that exceeds the limit of F12BootText below is filled with
255	background. */
256	#define LOGO_F12TEXT_WIDTH 286
257	/** Height of the boot device selection bitmap, see LOGO_F12TEXT_WIDTH. */
258	#define LOGO_F12TEXT_HEIGHT 12
259
260	/** The BIOS logo delay time (msec). */
261	#define LOGO_DELAY_TIME 2000
262
263	#define LOGO_MAX_WIDTH 640
264	#define LOGO_MAX_HEIGHT 480
265	#define LOGO_MAX_SIZE LOGO_MAX_WIDTH * LOGO_MAX_HEIGHT * 4
266
267
268	/*********************************************************************************************************************************
269	* Internal Functions *
270	*********************************************************************************************************************************/
271	#ifndef IN_RING3
272	RT_C_DECLS_BEGIN
273	DECLEXPORT(FNPGMRZPHYSPFHANDLER) vgaLbfAccessPfHandler;
274	RT_C_DECLS_END
275	#endif
276	PGM_ALL_CB_DECL(FNPGMPHYSHANDLER) vgaLFBAccessHandler;
277
278
279	/*********************************************************************************************************************************
280	* Global Variables *
281	*********************************************************************************************************************************/
282	/* "Press F12 to select boot device." bitmap. */
283	static const uint8_t g_abLogoF12BootText[] =
284	{
285	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
286	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
287	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x07, 0x0F, 0x7C,
288	0xF8, 0xF0, 0x01, 0xE0, 0x81, 0x9F, 0x3F, 0x00, 0x70, 0xF8, 0x00, 0xE0, 0xC3,
289	0x07, 0x0F, 0x1F, 0x3E, 0x70, 0x00, 0xF0, 0xE1, 0xC3, 0x07, 0x0E, 0x00, 0x6E,
290	0x7C, 0x60, 0xE0, 0xE1, 0xC3, 0x07, 0xC6, 0x80, 0x81, 0x31, 0x63, 0xC6, 0x00,
291	0x30, 0x80, 0x61, 0x0C, 0x00, 0x36, 0x63, 0x00, 0x8C, 0x19, 0x83, 0x61, 0xCC,
292	0x18, 0x36, 0x00, 0xCC, 0x8C, 0x19, 0xC3, 0x06, 0xC0, 0x8C, 0x31, 0x3C, 0x30,
293	0x8C, 0x19, 0x83, 0x31, 0x60, 0x60, 0x00, 0x0C, 0x18, 0x00, 0x0C, 0x60, 0x18,
294	0x00, 0x80, 0xC1, 0x18, 0x00, 0x30, 0x06, 0x60, 0x18, 0x30, 0x80, 0x01, 0x00,
295	0x33, 0x63, 0xC6, 0x30, 0x00, 0x30, 0x63, 0x80, 0x19, 0x0C, 0x03, 0x06, 0x00,
296	0x0C, 0x18, 0x18, 0xC0, 0x81, 0x03, 0x00, 0x03, 0x18, 0x0C, 0x00, 0x60, 0x30,
297	0x06, 0x00, 0x87, 0x01, 0x18, 0x06, 0x0C, 0x60, 0x00, 0xC0, 0xCC, 0x98, 0x31,
298	0x0C, 0x00, 0xCC, 0x18, 0x30, 0x0C, 0xC3, 0x80, 0x01, 0x00, 0x03, 0x66, 0xFE,
299	0x18, 0x30, 0x00, 0xC0, 0x02, 0x06, 0x06, 0x00, 0x18, 0x8C, 0x01, 0x60, 0xE0,
300	0x0F, 0x86, 0x3F, 0x03, 0x18, 0x00, 0x30, 0x33, 0x66, 0x0C, 0x03, 0x00, 0x33,
301	0xFE, 0x0C, 0xC3, 0x30, 0xE0, 0x0F, 0xC0, 0x87, 0x9B, 0x31, 0x63, 0xC6, 0x00,
302	0xF0, 0x80, 0x01, 0x03, 0x00, 0x06, 0x63, 0x00, 0x8C, 0x19, 0x83, 0x61, 0xCC,
303	0x18, 0x06, 0x00, 0x6C, 0x8C, 0x19, 0xC3, 0x00, 0x80, 0x8D, 0x31, 0xC3, 0x30,
304	0x8C, 0x19, 0x03, 0x30, 0xB3, 0xC3, 0x87, 0x0F, 0x1F, 0x00, 0x2C, 0x60, 0x80,
305	0x01, 0xE0, 0x87, 0x0F, 0x00, 0x3E, 0x7C, 0x60, 0xF0, 0xE1, 0xE3, 0x07, 0x00,
306	0x0F, 0x3E, 0x7C, 0xFC, 0x00, 0xC0, 0xC3, 0xC7, 0x30, 0x0E, 0x3E, 0x7C, 0x00,
307	0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x1E, 0xC0, 0x00, 0x60, 0x00,
308	0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x00, 0x00,
309	0x0C, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00,
310	0x00, 0x00, 0x00, 0xC0, 0x0C, 0x87, 0x31, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00,
311	0x00, 0x06, 0x00, 0x00, 0x18, 0x00, 0x30, 0x00, 0x00, 0x00, 0x03, 0x00, 0x30,
312	0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
313	0xF8, 0x83, 0xC1, 0x07, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00,
314	0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x30,
315	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
318	};
319
320
321	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
322
323
324	/**
325	* Set a VRAM page dirty.
326	*
327	* @param pThis VGA instance data.
328	* @param offVRAM The VRAM offset of the page to set.
329	*/
330	DECLINLINE(void) vga_set_dirty(PVGASTATE pThis, RTGCPHYS offVRAM)
331	{
332	AssertMsg(offVRAM < pThis->vram_size, ("offVRAM = %p, pThis->vram_size = %p\n", offVRAM, pThis->vram_size));
333	ASMBitSet(&pThis->au32DirtyBitmap[0], offVRAM >> PAGE_SHIFT);
334	pThis->fHasDirtyBits = true;
335	}
336
337	/**
338	* Tests if a VRAM page is dirty.
339	*
340	* @returns true if dirty.
341	* @returns false if clean.
342	* @param pThis VGA instance data.
343	* @param offVRAM The VRAM offset of the page to check.
344	*/
345	DECLINLINE(bool) vga_is_dirty(PVGASTATE pThis, RTGCPHYS offVRAM)
346	{
347	AssertMsg(offVRAM < pThis->vram_size, ("offVRAM = %p, pThis->vram_size = %p\n", offVRAM, pThis->vram_size));
348	return ASMBitTest(&pThis->au32DirtyBitmap[0], offVRAM >> PAGE_SHIFT);
349	}
350
351	/**
352	* Reset dirty flags in a give range.
353	*
354	* @param pThis VGA instance data.
355	* @param offVRAMStart Offset into the VRAM buffer of the first page.
356	* @param offVRAMEnd Offset into the VRAM buffer of the last page - exclusive.
357	*/
358	DECLINLINE(void) vga_reset_dirty(PVGASTATE pThis, RTGCPHYS offVRAMStart, RTGCPHYS offVRAMEnd)
359	{
360	Assert(offVRAMStart < pThis->vram_size);
361	Assert(offVRAMEnd <= pThis->vram_size);
362	Assert(offVRAMStart < offVRAMEnd);
363	ASMBitClearRange(&pThis->au32DirtyBitmap[0], offVRAMStart >> PAGE_SHIFT, offVRAMEnd >> PAGE_SHIFT);
364	}
365
366	/* force some bits to zero */
367	static const uint8_t sr_mask[8] = {
368	(uint8_t)~0xfc,
369	(uint8_t)~0xc2,
370	(uint8_t)~0xf0,
371	(uint8_t)~0xc0,
372	(uint8_t)~0xf1,
373	(uint8_t)~0xff,
374	(uint8_t)~0xff,
375	(uint8_t)~0x01,
376	};
377
378	static const uint8_t gr_mask[16] = {
379	(uint8_t)~0xf0, /* 0x00 */
380	(uint8_t)~0xf0, /* 0x01 */
381	(uint8_t)~0xf0, /* 0x02 */
382	(uint8_t)~0xe0, /* 0x03 */
383	(uint8_t)~0xfc, /* 0x04 */
384	(uint8_t)~0x84, /* 0x05 */
385	(uint8_t)~0xf0, /* 0x06 */
386	(uint8_t)~0xf0, /* 0x07 */
387	(uint8_t)~0x00, /* 0x08 */
388	(uint8_t)~0xff, /* 0x09 */
389	(uint8_t)~0xff, /* 0x0a */
390	(uint8_t)~0xff, /* 0x0b */
391	(uint8_t)~0xff, /* 0x0c */
392	(uint8_t)~0xff, /* 0x0d */
393	(uint8_t)~0xff, /* 0x0e */
394	(uint8_t)~0xff, /* 0x0f */
395	};
396
397	#define cbswap_32(__x) \
398	((uint32_t)( \
399	(((uint32_t)(__x) & (uint32_t)0x000000ffUL) << 24) \| \
400	(((uint32_t)(__x) & (uint32_t)0x0000ff00UL) << 8) \| \
401	(((uint32_t)(__x) & (uint32_t)0x00ff0000UL) >> 8) \| \
402	(((uint32_t)(__x) & (uint32_t)0xff000000UL) >> 24) ))
403
404	#ifdef WORDS_BIGENDIAN
405	#define PAT(x) cbswap_32(x)
406	#else
407	#define PAT(x) (x)
408	#endif
409
410	#ifdef WORDS_BIGENDIAN
411	#define BIG 1
412	#else
413	#define BIG 0
414	#endif
415
416	#ifdef WORDS_BIGENDIAN
417	#define GET_PLANE(data, p) (((data) >> (24 - (p) * 8)) & 0xff)
418	#else
419	#define GET_PLANE(data, p) (((data) >> ((p) * 8)) & 0xff)
420	#endif
421
422	static const uint32_t mask16[16] = {
423	PAT(0x00000000),
424	PAT(0x000000ff),
425	PAT(0x0000ff00),
426	PAT(0x0000ffff),
427	PAT(0x00ff0000),
428	PAT(0x00ff00ff),
429	PAT(0x00ffff00),
430	PAT(0x00ffffff),
431	PAT(0xff000000),
432	PAT(0xff0000ff),
433	PAT(0xff00ff00),
434	PAT(0xff00ffff),
435	PAT(0xffff0000),
436	PAT(0xffff00ff),
437	PAT(0xffffff00),
438	PAT(0xffffffff),
439	};
440
441	#undef PAT
442
443	#ifdef WORDS_BIGENDIAN
444	#define PAT(x) (x)
445	#else
446	#define PAT(x) cbswap_32(x)
447	#endif
448
449	static const uint32_t dmask16[16] = {
450	PAT(0x00000000),
451	PAT(0x000000ff),
452	PAT(0x0000ff00),
453	PAT(0x0000ffff),
454	PAT(0x00ff0000),
455	PAT(0x00ff00ff),
456	PAT(0x00ffff00),
457	PAT(0x00ffffff),
458	PAT(0xff000000),
459	PAT(0xff0000ff),
460	PAT(0xff00ff00),
461	PAT(0xff00ffff),
462	PAT(0xffff0000),
463	PAT(0xffff00ff),
464	PAT(0xffffff00),
465	PAT(0xffffffff),
466	};
467
468	static const uint32_t dmask4[4] = {
469	PAT(0x00000000),
470	PAT(0x0000ffff),
471	PAT(0xffff0000),
472	PAT(0xffffffff),
473	};
474
475	#if defined(IN_RING3)
476	static uint32_t expand4[256];
477	static uint16_t expand2[256];
478	static uint8_t expand4to8[16];
479	#endif /* IN_RING3 */
480
481	/* Update the values needed for calculating Vertical Retrace and
482	* Display Enable status bits more or less accurately. The Display Enable
483	* bit is set (indicating disabled display signal) when either the
484	* horizontal (hblank) or vertical (vblank) blanking is active. The
485	* Vertical Retrace bit is set when vertical retrace (vsync) is active.
486	* Unless the CRTC is horribly misprogrammed, vsync implies vblank.
487	*/
488	static void vga_update_retrace_state(PVGASTATE pThis)
489	{
490	unsigned htotal_cclks, vtotal_lines, chars_per_sec;
491	unsigned hblank_start_cclk, hblank_end_cclk, hblank_width, hblank_skew_cclks;
492	unsigned vsync_start_line, vsync_end, vsync_width;
493	unsigned vblank_start_line, vblank_end, vblank_width;
494	unsigned char_dots, clock_doubled, clock_index;
495	const int clocks[] = {25175000, 28322000, 25175000, 25175000};
496	vga_retrace_s *r = &pThis->retrace_state;
497
498	/* For horizontal timings, we only care about the blanking start/end. */
499	htotal_cclks = pThis->cr[0x00] + 5;
500	hblank_start_cclk = pThis->cr[0x02];
501	hblank_end_cclk = (pThis->cr[0x03] & 0x1f) + ((pThis->cr[0x05] & 0x80) >> 2);
502	hblank_skew_cclks = (pThis->cr[0x03] >> 5) & 3;
503
504	/* For vertical timings, we need both the blanking start/end... */
505	vtotal_lines = pThis->cr[0x06] + ((pThis->cr[0x07] & 1) << 8) + ((pThis->cr[0x07] & 0x20) << 4) + 2;
506	vblank_start_line = pThis->cr[0x15] + ((pThis->cr[0x07] & 8) << 5) + ((pThis->cr[0x09] & 0x20) << 4);
507	vblank_end = pThis->cr[0x16];
508	/* ... and the vertical retrace (vsync) start/end. */
509	vsync_start_line = pThis->cr[0x10] + ((pThis->cr[0x07] & 4) << 6) + ((pThis->cr[0x07] & 0x80) << 2);
510	vsync_end = pThis->cr[0x11] & 0xf;
511
512	/* Calculate the blanking and sync widths. The way it's implemented in
513	* the VGA with limited-width compare counters is quite a piece of work.
514	*/
515	hblank_width = (hblank_end_cclk - hblank_start_cclk) & 0x3f;/* 6 bits */
516	vblank_width = (vblank_end - vblank_start_line) & 0xff; /* 8 bits */
517	vsync_width = (vsync_end - vsync_start_line) & 0xf; /* 4 bits */
518
519	/* Calculate the dot and character clock rates. */
520	clock_doubled = (pThis->sr[0x01] >> 3) & 1; /* Clock doubling bit. */
521	clock_index = (pThis->msr >> 2) & 3;
522	char_dots = (pThis->sr[0x01] & 1) ? 8 : 9; /* 8 or 9 dots per cclk. */
523
524	chars_per_sec = clocks[clock_index] / char_dots;
525	Assert(chars_per_sec); /* Can't possibly be zero. */
526
527	htotal_cclks <<= clock_doubled;
528
529	/* Calculate the number of cclks per entire frame. */
530	r->frame_cclks = vtotal_lines * htotal_cclks;
531	Assert(r->frame_cclks); /* Can't possibly be zero. */
532
533	if (r->v_freq_hz) { /* Could be set to emulate a specific rate. */
534	r->cclk_ns = 1000000000 / (r->frame_cclks * r->v_freq_hz);
535	} else {
536	r->cclk_ns = 1000000000 / chars_per_sec;
537	}
538	Assert(r->cclk_ns);
539	r->frame_ns = r->frame_cclks * r->cclk_ns;
540
541	/* Calculate timings in cclks/lines. Stored but not directly used. */
542	r->hb_start = hblank_start_cclk + hblank_skew_cclks;
543	r->hb_end = hblank_start_cclk + hblank_width + hblank_skew_cclks;
544	r->h_total = htotal_cclks;
545	Assert(r->h_total); /* Can't possibly be zero. */
546
547	r->vb_start = vblank_start_line;
548	r->vb_end = vblank_start_line + vblank_width + 1;
549	r->vs_start = vsync_start_line;
550	r->vs_end = vsync_start_line + vsync_width + 1;
551
552	/* Calculate timings in nanoseconds. For easier comparisons, the frame
553	* is considered to start at the beginning of the vertical and horizontal
554	* blanking period.
555	*/
556	r->h_total_ns = htotal_cclks * r->cclk_ns;
557	r->hb_end_ns = hblank_width * r->cclk_ns;
558	r->vb_end_ns = vblank_width * r->h_total_ns;
559	r->vs_start_ns = (r->vs_start - r->vb_start) * r->h_total_ns;
560	r->vs_end_ns = (r->vs_end - r->vb_start) * r->h_total_ns;
561	Assert(r->h_total_ns); /* See h_total. */
562	}
563
564	static uint8_t vga_retrace(PVGASTATE pThis)
565	{
566	vga_retrace_s *r = &pThis->retrace_state;
567
568	if (r->frame_ns) {
569	uint8_t val = pThis->st01 & ~(ST01_V_RETRACE \| ST01_DISP_ENABLE);
570	unsigned cur_frame_ns, cur_line_ns;
571	uint64_t time_ns;
572
573	time_ns = PDMDevHlpTMTimeVirtGetNano(VGASTATE2DEVINS(pThis));
574
575	/* Determine the time within the frame. */
576	cur_frame_ns = time_ns % r->frame_ns;
577
578	/* See if we're in the vertical blanking period... */
579	if (cur_frame_ns < r->vb_end_ns) {
580	val \|= ST01_DISP_ENABLE;
581	/* ... and additionally in the vertical sync period. */
582	if (cur_frame_ns >= r->vs_start_ns && cur_frame_ns <= r->vs_end_ns)
583	val \|= ST01_V_RETRACE;
584	} else {
585	/* Determine the time within the current scanline. */
586	cur_line_ns = cur_frame_ns % r->h_total_ns;
587	/* See if we're in the horizontal blanking period. */
588	if (cur_line_ns < r->hb_end_ns)
589	val \|= ST01_DISP_ENABLE;
590	}
591	return val;
592	} else {
593	return pThis->st01 ^ (ST01_V_RETRACE \| ST01_DISP_ENABLE);
594	}
595	}
596
597	int vga_ioport_invalid(PVGASTATE pThis, uint32_t addr)
598	{
599	if (pThis->msr & MSR_COLOR_EMULATION) {
600	/* Color */
601	return (addr >= 0x3b0 && addr <= 0x3bf);
602	} else {
603	/* Monochrome */
604	return (addr >= 0x3d0 && addr <= 0x3df);
605	}
606	}
607
608	static uint32_t vga_ioport_read(PVGASTATE pThis, uint32_t addr)
609	{
610	int val, index;
611
612	/* check port range access depending on color/monochrome mode */
613	if (vga_ioport_invalid(pThis, addr)) {
614	val = 0xff;
615	Log(("VGA: following read ignored\n"));
616	} else {
617	switch(addr) {
618	case 0x3c0:
619	if (pThis->ar_flip_flop == 0) {
620	val = pThis->ar_index;
621	} else {
622	val = 0;
623	}
624	break;
625	case 0x3c1:
626	index = pThis->ar_index & 0x1f;
627	if (index < 21)
628	val = pThis->ar[index];
629	else
630	val = 0;
631	break;
632	case 0x3c2:
633	val = pThis->st00;
634	break;
635	case 0x3c4:
636	val = pThis->sr_index;
637	break;
638	case 0x3c5:
639	val = pThis->sr[pThis->sr_index];
640	Log2(("vga: read SR%x = 0x%02x\n", pThis->sr_index, val));
641	break;
642	case 0x3c7:
643	val = pThis->dac_state;
644	break;
645	case 0x3c8:
646	val = pThis->dac_write_index;
647	break;
648	case 0x3c9:
649	val = pThis->palette[pThis->dac_read_index * 3 + pThis->dac_sub_index];
650	if (++pThis->dac_sub_index == 3) {
651	pThis->dac_sub_index = 0;
652	pThis->dac_read_index++;
653	}
654	break;
655	case 0x3ca:
656	val = pThis->fcr;
657	break;
658	case 0x3cc:
659	val = pThis->msr;
660	break;
661	case 0x3ce:
662	val = pThis->gr_index;
663	break;
664	case 0x3cf:
665	val = pThis->gr[pThis->gr_index];
666	Log2(("vga: read GR%x = 0x%02x\n", pThis->gr_index, val));
667	break;
668	case 0x3b4:
669	case 0x3d4:
670	val = pThis->cr_index;
671	break;
672	case 0x3b5:
673	case 0x3d5:
674	val = pThis->cr[pThis->cr_index];
675	Log2(("vga: read CR%x = 0x%02x\n", pThis->cr_index, val));
676	break;
677	case 0x3ba:
678	case 0x3da:
679	val = pThis->st01 = vga_retrace(pThis);
680	pThis->ar_flip_flop = 0;
681	break;
682	default:
683	val = 0x00;
684	break;
685	}
686	}
687	Log(("VGA: read addr=0x%04x data=0x%02x\n", addr, val));
688	return val;
689	}
690
691	static void vga_ioport_write(PVGASTATE pThis, uint32_t addr, uint32_t val)
692	{
693	int index;
694
695	Log(("VGA: write addr=0x%04x data=0x%02x\n", addr, val));
696
697	/* check port range access depending on color/monochrome mode */
698	if (vga_ioport_invalid(pThis, addr)) {
699	Log(("VGA: previous write ignored\n"));
700	return;
701	}
702
703	switch(addr) {
704	case 0x3c0:
705	if (pThis->ar_flip_flop == 0) {
706	val &= 0x3f;
707	pThis->ar_index = val;
708	} else {
709	index = pThis->ar_index & 0x1f;
710	switch(index) {
711	case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
712	case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:
713	pThis->ar[index] = val & 0x3f;
714	break;
715	case 0x10:
716	pThis->ar[index] = val & ~0x10;
717	break;
718	case 0x11:
719	pThis->ar[index] = val;
720	break;
721	case 0x12:
722	pThis->ar[index] = val & ~0xc0;
723	break;
724	case 0x13:
725	pThis->ar[index] = val & ~0xf0;
726	break;
727	case 0x14:
728	pThis->ar[index] = val & ~0xf0;
729	break;
730	default:
731	break;
732	}
733	}
734	pThis->ar_flip_flop ^= 1;
735	break;
736	case 0x3c2:
737	pThis->msr = val & ~0x10;
738	if (pThis->fRealRetrace)
739	vga_update_retrace_state(pThis);
740	pThis->st00 = (pThis->st00 & ~0x10) \| (0x90 >> ((val >> 2) & 0x3));
741	break;
742	case 0x3c4:
743	pThis->sr_index = val & 7;
744	break;
745	case 0x3c5:
746	Log2(("vga: write SR%x = 0x%02x\n", pThis->sr_index, val));
747	pThis->sr[pThis->sr_index] = val & sr_mask[pThis->sr_index];
748	/* Allow SR07 to disable VBE. */
749	if (pThis->sr_index == 0x07 && !(val & 1))
750	{
751	pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] = VBE_DISPI_DISABLED;
752	pThis->bank_offset = 0;
753	}
754	if (pThis->fRealRetrace && pThis->sr_index == 0x01)
755	vga_update_retrace_state(pThis);
756	#ifndef IN_RC
757	/* The VGA region is (could be) affected by this change; reset all aliases we've created. */
758	if ( pThis->sr_index == 4 /* mode */
759	\|\| pThis->sr_index == 2 /* plane mask */)
760	{
761	if (pThis->fRemappedVGA)
762	{
763	IOMMMIOResetRegion(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), 0x000a0000);
764	pThis->fRemappedVGA = false;
765	}
766	}
767	#endif
768	break;
769	case 0x3c7:
770	pThis->dac_read_index = val;
771	pThis->dac_sub_index = 0;
772	pThis->dac_state = 3;
773	break;
774	case 0x3c8:
775	pThis->dac_write_index = val;
776	pThis->dac_sub_index = 0;
777	pThis->dac_state = 0;
778	break;
779	case 0x3c9:
780	pThis->dac_cache[pThis->dac_sub_index] = val;
781	if (++pThis->dac_sub_index == 3) {
782	memcpy(&pThis->palette[pThis->dac_write_index * 3], pThis->dac_cache, 3);
783	pThis->dac_sub_index = 0;
784	pThis->dac_write_index++;
785	}
786	break;
787	case 0x3ce:
788	pThis->gr_index = val & 0x0f;
789	break;
790	case 0x3cf:
791	Log2(("vga: write GR%x = 0x%02x\n", pThis->gr_index, val));
792	pThis->gr[pThis->gr_index] = val & gr_mask[pThis->gr_index];
793
794	#ifndef IN_RC
795	/* The VGA region is (could be) affected by this change; reset all aliases we've created. */
796	if (pThis->gr_index == 6 /* memory map mode */)
797	{
798	if (pThis->fRemappedVGA)
799	{
800	IOMMMIOResetRegion(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), 0x000a0000);
801	pThis->fRemappedVGA = false;
802	}
803	}
804	#endif
805	break;
806
807	case 0x3b4:
808	case 0x3d4:
809	pThis->cr_index = val;
810	break;
811	case 0x3b5:
812	case 0x3d5:
813	Log2(("vga: write CR%x = 0x%02x\n", pThis->cr_index, val));
814	/* handle CR0-7 protection */
815	if ((pThis->cr[0x11] & 0x80) && pThis->cr_index <= 7) {
816	/* can always write bit 4 of CR7 */
817	if (pThis->cr_index == 7)
818	pThis->cr[7] = (pThis->cr[7] & ~0x10) \| (val & 0x10);
819	return;
820	}
821	pThis->cr[pThis->cr_index] = val;
822
823	if (pThis->fRealRetrace) {
824	/* The following registers are only updated during a mode set. */
825	switch(pThis->cr_index) {
826	case 0x00:
827	case 0x02:
828	case 0x03:
829	case 0x05:
830	case 0x06:
831	case 0x07:
832	case 0x09:
833	case 0x10:
834	case 0x11:
835	case 0x15:
836	case 0x16:
837	vga_update_retrace_state(pThis);
838	break;
839	}
840	}
841	break;
842	case 0x3ba:
843	case 0x3da:
844	pThis->fcr = val & 0x10;
845	break;
846	}
847	}
848
849	#ifdef CONFIG_BOCHS_VBE
850	static uint32_t vbe_ioport_read_index(PVGASTATE pThis, uint32_t addr)
851	{
852	uint32_t val = pThis->vbe_index;
853	NOREF(addr);
854	return val;
855	}
856
857	static uint32_t vbe_ioport_read_data(PVGASTATE pThis, uint32_t addr)
858	{
859	uint32_t val;
860	NOREF(addr);
861
862	if (pThis->vbe_index < VBE_DISPI_INDEX_NB) {
863	if (pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_GETCAPS) {
864	switch(pThis->vbe_index) {
865	/* XXX: do not hardcode ? */
866	case VBE_DISPI_INDEX_XRES:
867	val = VBE_DISPI_MAX_XRES;
868	break;
869	case VBE_DISPI_INDEX_YRES:
870	val = VBE_DISPI_MAX_YRES;
871	break;
872	case VBE_DISPI_INDEX_BPP:
873	val = VBE_DISPI_MAX_BPP;
874	break;
875	default:
876	Assert(pThis->vbe_index < VBE_DISPI_INDEX_NB);
877	val = pThis->vbe_regs[pThis->vbe_index];
878	break;
879	}
880	} else {
881	switch(pThis->vbe_index) {
882	case VBE_DISPI_INDEX_VBOX_VIDEO:
883	/* Reading from the port means that the old additions are requesting the number of monitors. */
884	val = 1;
885	break;
886	default:
887	Assert(pThis->vbe_index < VBE_DISPI_INDEX_NB);
888	val = pThis->vbe_regs[pThis->vbe_index];
889	break;
890	}
891	}
892	} else {
893	val = 0;
894	}
895	Log(("VBE: read index=0x%x val=0x%x\n", pThis->vbe_index, val));
896	return val;
897	}
898
899	#define VBE_PITCH_ALIGN 4 /* Align pitch to 32 bits - Qt requires that. */
900
901	/* Calculate scanline pitch based on bit depth and width in pixels. */
902	static uint32_t calc_line_pitch(uint16_t bpp, uint16_t width)
903	{
904	uint32_t pitch, aligned_pitch;
905
906	if (bpp <= 4)
907	pitch = width >> 1;
908	else
909	pitch = width * ((bpp + 7) >> 3);
910
911	/* Align the pitch to some sensible value. */
912	aligned_pitch = (pitch + (VBE_PITCH_ALIGN - 1)) & ~(VBE_PITCH_ALIGN - 1);
913	if (aligned_pitch != pitch)
914	Log(("VBE: Line pitch %d aligned to %d bytes\n", pitch, aligned_pitch));
915
916	return aligned_pitch;
917	}
918
919	#ifdef SOME_UNUSED_FUNCTION
920	/* Calculate line width in pixels based on bit depth and pitch. */
921	static uint32_t calc_line_width(uint16_t bpp, uint32_t pitch)
922	{
923	uint32_t width;
924
925	if (bpp <= 4)
926	width = pitch << 1;
927	else
928	width = pitch / ((bpp + 7) >> 3);
929
930	return width;
931	}
932	#endif
933
934	static void recalculate_data(PVGASTATE pThis, bool fVirtHeightOnly)
935	{
936	uint16_t cBPP = pThis->vbe_regs[VBE_DISPI_INDEX_BPP];
937	uint16_t cVirtWidth = pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_WIDTH];
938	uint16_t cX = pThis->vbe_regs[VBE_DISPI_INDEX_XRES];
939	if (!cBPP \|\| !cX)
940	return; /* Not enough data has been set yet. */
941	uint32_t cbLinePitch = calc_line_pitch(cBPP, cVirtWidth);
942	if (!cbLinePitch)
943	cbLinePitch = calc_line_pitch(cBPP, cX);
944	Assert(cbLinePitch != 0);
945	uint32_t cVirtHeight = pThis->vram_size / cbLinePitch;
946	if (!fVirtHeightOnly)
947	{
948	uint16_t offX = pThis->vbe_regs[VBE_DISPI_INDEX_X_OFFSET];
949	uint16_t offY = pThis->vbe_regs[VBE_DISPI_INDEX_Y_OFFSET];
950	uint32_t offStart = cbLinePitch * offY;
951	if (cBPP == 4)
952	offStart += offX >> 1;
953	else
954	offStart += offX * ((cBPP + 7) >> 3);
955	offStart >>= 2;
956	pThis->vbe_line_offset = RT_MIN(cbLinePitch, pThis->vram_size);
957	pThis->vbe_start_addr = RT_MIN(offStart, pThis->vram_size);
958	}
959
960	/* The VBE_DISPI_INDEX_VIRT_HEIGHT is used to prevent setting resolution bigger than VRAM permits
961	* it is used instead of VBE_DISPI_INDEX_YRES only in case
962	* pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_HEIGHT] < pThis->vbe_regs[VBE_DISPI_INDEX_YRES]
963	* We can not simply do pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_HEIGHT] = cVirtHeight since
964	* the cVirtHeight we calculated can exceed the 16bit value range
965	* instead we'll check if it's bigger than pThis->vbe_regs[VBE_DISPI_INDEX_YRES], and if yes,
966	* assign the pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_HEIGHT] with a dummy UINT16_MAX value
967	* that is always bigger than pThis->vbe_regs[VBE_DISPI_INDEX_YRES]
968	* to just ensure the pThis->vbe_regs[VBE_DISPI_INDEX_YRES] is always used */
969	pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_HEIGHT] = (cVirtHeight >= (uint32_t)pThis->vbe_regs[VBE_DISPI_INDEX_YRES])
970	? UINT16_MAX : (uint16_t)cVirtHeight;
971	}
972
973	static void vbe_ioport_write_index(PVGASTATE pThis, uint32_t addr, uint32_t val)
974	{
975	pThis->vbe_index = val;
976	NOREF(addr);
977	}
978
979	static int vbe_ioport_write_data(PVGASTATE pThis, uint32_t addr, uint32_t val)
980	{
981	uint32_t max_bank;
982	NOREF(addr);
983
984	if (pThis->vbe_index <= VBE_DISPI_INDEX_NB) {
985	bool fRecalculate = false;
986	Log(("VBE: write index=0x%x val=0x%x\n", pThis->vbe_index, val));
987	switch(pThis->vbe_index) {
988	case VBE_DISPI_INDEX_ID:
989	if (val == VBE_DISPI_ID0 \|\|
990	val == VBE_DISPI_ID1 \|\|
991	val == VBE_DISPI_ID2 \|\|
992	val == VBE_DISPI_ID3 \|\|
993	val == VBE_DISPI_ID4) {
994	pThis->vbe_regs[pThis->vbe_index] = val;
995	}
996	if (val == VBE_DISPI_ID_VBOX_VIDEO) {
997	pThis->vbe_regs[pThis->vbe_index] = val;
998	} else if (val == VBE_DISPI_ID_ANYX) {
999	pThis->vbe_regs[pThis->vbe_index] = val;
1000	}
1001	#ifdef VBOX_WITH_HGSMI
1002	else if (val == VBE_DISPI_ID_HGSMI) {
1003	pThis->vbe_regs[pThis->vbe_index] = val;
1004	}
1005	#endif /* VBOX_WITH_HGSMI */
1006	break;
1007	case VBE_DISPI_INDEX_XRES:
1008	if (val <= VBE_DISPI_MAX_XRES)
1009	{
1010	pThis->vbe_regs[pThis->vbe_index] = val;
1011	pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_WIDTH] = val;
1012	fRecalculate = true;
1013	}
1014	break;
1015	case VBE_DISPI_INDEX_YRES:
1016	if (val <= VBE_DISPI_MAX_YRES)
1017	pThis->vbe_regs[pThis->vbe_index] = val;
1018	break;
1019	case VBE_DISPI_INDEX_BPP:
1020	if (val == 0)
1021	val = 8;
1022	if (val == 4 \|\| val == 8 \|\| val == 15 \|\|
1023	val == 16 \|\| val == 24 \|\| val == 32) {
1024	pThis->vbe_regs[pThis->vbe_index] = val;
1025	fRecalculate = true;
1026	}
1027	break;
1028	case VBE_DISPI_INDEX_BANK:
1029	if (pThis->vbe_regs[VBE_DISPI_INDEX_BPP] <= 4)
1030	max_bank = pThis->vbe_bank_max >> 2; /* Each bank really covers 256K */
1031	else
1032	max_bank = pThis->vbe_bank_max;
1033	/* Old software may pass garbage in the high byte of bank. If the maximum
1034	* bank fits into a single byte, toss the high byte the user supplied.
1035	*/
1036	if (max_bank < 0x100)
1037	val &= 0xff;
1038	if (val > max_bank)
1039	val = max_bank;
1040	pThis->vbe_regs[pThis->vbe_index] = val;
1041	pThis->bank_offset = (val << 16);
1042
1043	#ifndef IN_RC
1044	/* The VGA region is (could be) affected by this change; reset all aliases we've created. */
1045	if (pThis->fRemappedVGA)
1046	{
1047	IOMMMIOResetRegion(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), 0x000a0000);
1048	pThis->fRemappedVGA = false;
1049	}
1050	#endif
1051	break;
1052
1053	case VBE_DISPI_INDEX_ENABLE:
1054	#ifndef IN_RING3
1055	return VINF_IOM_R3_IOPORT_WRITE;
1056	#else
1057	{
1058	if ((val & VBE_DISPI_ENABLED) &&
1059	!(pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED)) {
1060	int h, shift_control;
1061	/* Check the values before we screw up with a resolution which is too big or small. */
1062	size_t cb = pThis->vbe_regs[VBE_DISPI_INDEX_XRES];
1063	if (pThis->vbe_regs[VBE_DISPI_INDEX_BPP] == 4)
1064	cb = pThis->vbe_regs[VBE_DISPI_INDEX_XRES] >> 1;
1065	else
1066	cb = pThis->vbe_regs[VBE_DISPI_INDEX_XRES] * ((pThis->vbe_regs[VBE_DISPI_INDEX_BPP] + 7) >> 3);
1067	cb *= pThis->vbe_regs[VBE_DISPI_INDEX_YRES];
1068	uint16_t cVirtWidth = pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_WIDTH];
1069	if (!cVirtWidth)
1070	cVirtWidth = pThis->vbe_regs[VBE_DISPI_INDEX_XRES];
1071	if ( !cVirtWidth
1072	\|\| !pThis->vbe_regs[VBE_DISPI_INDEX_YRES]
1073	\|\| cb > pThis->vram_size)
1074	{
1075	AssertMsgFailed(("VIRT WIDTH=%d YRES=%d cb=%d vram_size=%d\n",
1076	pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_WIDTH], pThis->vbe_regs[VBE_DISPI_INDEX_YRES], cb, pThis->vram_size));
1077	return VINF_SUCCESS; /* Note: silent failure like before */
1078	}
1079
1080	/* When VBE interface is enabled, it is reset. */
1081	pThis->vbe_regs[VBE_DISPI_INDEX_X_OFFSET] = 0;
1082	pThis->vbe_regs[VBE_DISPI_INDEX_Y_OFFSET] = 0;
1083	fRecalculate = true;
1084
1085	/* clear the screen (should be done in BIOS) */
1086	if (!(val & VBE_DISPI_NOCLEARMEM)) {
1087	uint16_t cY = RT_MIN(pThis->vbe_regs[VBE_DISPI_INDEX_YRES],
1088	pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_HEIGHT]);
1089	uint16_t cbLinePitch = pThis->vbe_line_offset;
1090	memset(pThis->CTX_SUFF(vram_ptr), 0,
1091	cY * cbLinePitch);
1092	}
1093
1094	/* we initialize the VGA graphic mode (should be done
1095	in BIOS) */
1096	pThis->gr[0x06] = (pThis->gr[0x06] & ~0x0c) \| 0x05; /* graphic mode + memory map 1 */
1097	pThis->cr[0x17] \|= 3; /* no CGA modes */
1098	pThis->cr[0x13] = pThis->vbe_line_offset >> 3;
1099	/* width */
1100	pThis->cr[0x01] = (cVirtWidth >> 3) - 1;
1101	/* height (only meaningful if < 1024) */
1102	h = pThis->vbe_regs[VBE_DISPI_INDEX_YRES] - 1;
1103	pThis->cr[0x12] = h;
1104	pThis->cr[0x07] = (pThis->cr[0x07] & ~0x42) \|
1105	((h >> 7) & 0x02) \| ((h >> 3) & 0x40);
1106	/* line compare to 1023 */
1107	pThis->cr[0x18] = 0xff;
1108	pThis->cr[0x07] \|= 0x10;
1109	pThis->cr[0x09] \|= 0x40;
1110
1111	if (pThis->vbe_regs[VBE_DISPI_INDEX_BPP] == 4) {
1112	shift_control = 0;
1113	pThis->sr[0x01] &= ~8; /* no double line */
1114	} else {
1115	shift_control = 2;
1116	pThis->sr[4] \|= 0x08; /* set chain 4 mode */
1117	pThis->sr[2] \|= 0x0f; /* activate all planes */
1118	/* Indicate non-VGA mode in SR07. */
1119	pThis->sr[7] \|= 1;
1120	}
1121	pThis->gr[0x05] = (pThis->gr[0x05] & ~0x60) \| (shift_control << 5);
1122	pThis->cr[0x09] &= ~0x9f; /* no double scan */
1123	/* sunlover 30.05.2007
1124	* The ar_index remains with bit 0x20 cleared after a switch from fullscreen
1125	* DOS mode on Windows XP guest. That leads to GMODE_BLANK in vga_update_display.
1126	* But the VBE mode is graphics, so not a blank anymore.
1127	*/
1128	pThis->ar_index \|= 0x20;
1129	} else {
1130	/* XXX: the bios should do that */
1131	/* sunlover 21.12.2006
1132	* Here is probably more to reset. When this was executed in GC
1133	* then the update functions could not detect a mode change.
1134	* Or may be these update function should take the pThis->vbe_regs[pThis->vbe_index]
1135	* into account when detecting a mode change.
1136	*
1137	* The 'mode reset not detected' problem is now fixed by executing the
1138	* VBE_DISPI_INDEX_ENABLE case always in RING3 in order to call the
1139	* LFBChange callback.
1140	*/
1141	pThis->bank_offset = 0;
1142	}
1143	pThis->vbe_regs[pThis->vbe_index] = val;
1144	/*
1145	* LFB video mode is either disabled or changed. Notify the display
1146	* and reset VBVA.
1147	*/
1148	pThis->pDrv->pfnLFBModeChange(pThis->pDrv, (val & VBE_DISPI_ENABLED) != 0);
1149	#ifdef VBOX_WITH_HGSMI
1150	VBVAOnVBEChanged(pThis);
1151	#endif /* VBOX_WITH_HGSMI */
1152
1153	/* The VGA region is (could be) affected by this change; reset all aliases we've created. */
1154	if (pThis->fRemappedVGA)
1155	{
1156	IOMMMIOResetRegion(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), 0x000a0000);
1157	pThis->fRemappedVGA = false;
1158	}
1159	break;
1160	}
1161	#endif /* IN_RING3 */
1162	case VBE_DISPI_INDEX_VIRT_WIDTH:
1163	case VBE_DISPI_INDEX_X_OFFSET:
1164	case VBE_DISPI_INDEX_Y_OFFSET:
1165	{
1166	pThis->vbe_regs[pThis->vbe_index] = val;
1167	fRecalculate = true;
1168	}
1169	break;
1170	case VBE_DISPI_INDEX_VBOX_VIDEO:
1171	#ifndef IN_RING3
1172	return VINF_IOM_R3_IOPORT_WRITE;
1173	#else
1174	/* Changes in the VGA device are minimal. The device is bypassed. The driver does all work. */
1175	if (val == VBOX_VIDEO_DISABLE_ADAPTER_MEMORY)
1176	{
1177	pThis->pDrv->pfnProcessAdapterData(pThis->pDrv, NULL, 0);
1178	}
1179	else if (val == VBOX_VIDEO_INTERPRET_ADAPTER_MEMORY)
1180	{
1181	pThis->pDrv->pfnProcessAdapterData(pThis->pDrv, pThis->CTX_SUFF(vram_ptr), pThis->vram_size);
1182	}
1183	else if ((val & 0xFFFF0000) == VBOX_VIDEO_INTERPRET_DISPLAY_MEMORY_BASE)
1184	{
1185	pThis->pDrv->pfnProcessDisplayData(pThis->pDrv, pThis->CTX_SUFF(vram_ptr), val & 0xFFFF);
1186	}
1187	#endif /* IN_RING3 */
1188	break;
1189	default:
1190	break;
1191	}
1192	if (fRecalculate)
1193	{
1194	recalculate_data(pThis, false);
1195	}
1196	}
1197	return VINF_SUCCESS;
1198	}
1199	#endif
1200
1201	/* called for accesses between 0xa0000 and 0xc0000 */
1202	static uint32_t vga_mem_readb(PVGASTATE pThis, RTGCPHYS addr, int *prc)
1203	{
1204	int memory_map_mode, plane;
1205	uint32_t ret;
1206
1207	Log3(("vga: read [0x%x] -> ", addr));
1208	/* convert to VGA memory offset */
1209	memory_map_mode = (pThis->gr[6] >> 2) & 3;
1210	#ifndef IN_RC
1211	RTGCPHYS GCPhys = addr; /* save original address */
1212	#endif
1213
1214	#if !defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
1215	/* Ugly hack to get result from 2dmark and other vmsvga examples. */
1216	if (pThis->svga.fEnabled)
1217	return VINF_IOM_R3_MMIO_READ;
1218	#endif
1219
1220	addr &= 0x1ffff;
1221	switch(memory_map_mode) {
1222	case 0:
1223	break;
1224	case 1:
1225	if (addr >= 0x10000)
1226	return 0xff;
1227	addr += pThis->bank_offset;
1228	break;
1229	case 2:
1230	addr -= 0x10000;
1231	if (addr >= 0x8000)
1232	return 0xff;
1233	break;
1234	default:
1235	case 3:
1236	addr -= 0x18000;
1237	if (addr >= 0x8000)
1238	return 0xff;
1239	break;
1240	}
1241
1242	if (pThis->sr[4] & 0x08) {
1243	/* chain 4 mode : simplest access */
1244	# ifndef IN_RC
1245	/* If all planes are accessible, then map the page to the frame buffer and make it writable. */
1246	if ( (pThis->sr[2] & 3) == 3
1247	&& !vga_is_dirty(pThis, addr))
1248	{
1249	/** @todo only allow read access (doesn't work now) */
1250	STAM_COUNTER_INC(&pThis->StatMapPage);
1251	IOMMMIOMapMMIO2Page(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), GCPhys,
1252	pThis->GCPhysVRAM + addr, X86_PTE_RW \| X86_PTE_P);
1253	/* Set as dirty as write accesses won't be noticed now. */
1254	vga_set_dirty(pThis, addr);
1255	pThis->fRemappedVGA = true;
1256	}
1257	# endif /* IN_RC */
1258	VERIFY_VRAM_READ_OFF_RETURN(pThis, addr, *prc);
1259	#if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
1260	if (pThis->svga.fEnabled && addr < _32K)
1261	ret = ((uint8_t *)pThis->svga.pFrameBufferBackup)[addr];
1262	else
1263	#endif
1264	ret = pThis->CTX_SUFF(vram_ptr)[addr];
1265	} else if (!(pThis->sr[4] & 0x04)) { /* Host access is controlled by SR4, not GR5! */
1266	/* odd/even mode (aka text mode mapping) */
1267	plane = (pThis->gr[4] & 2) \| (addr & 1);
1268	/* See the comment for a similar line in vga_mem_writeb. */
1269	RTGCPHYS off = ((addr & ~1) << 2) \| plane;
1270	VERIFY_VRAM_READ_OFF_RETURN(pThis, off, *prc);
1271	#if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
1272	if (pThis->svga.fEnabled && off < _32K)
1273	ret = ((uint8_t *)pThis->svga.pFrameBufferBackup)[off];
1274	else
1275	#endif
1276	ret = pThis->CTX_SUFF(vram_ptr)[off];
1277	} else {
1278	/* standard VGA latched access */
1279	VERIFY_VRAM_READ_OFF_RETURN(pThis, addr * 4 + 3, *prc);
1280	#if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
1281	if (pThis->svga.fEnabled && addr * 4 + 3 < _32K)
1282	pThis->latch = ((uint32_t *)pThis->svga.pFrameBufferBackup)[addr];
1283	else
1284	#endif
1285	pThis->latch = ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr];
1286
1287	if (!(pThis->gr[5] & 0x08)) {
1288	/* read mode 0 */
1289	plane = pThis->gr[4];
1290	ret = GET_PLANE(pThis->latch, plane);
1291	} else {
1292	/* read mode 1 */
1293	ret = (pThis->latch ^ mask16[pThis->gr[2]]) & mask16[pThis->gr[7]];
1294	ret \|= ret >> 16;
1295	ret \|= ret >> 8;
1296	ret = (~ret) & 0xff;
1297	}
1298	}
1299	Log3((" 0x%02x\n", ret));
1300	return ret;
1301	}
1302
1303	/* called for accesses between 0xa0000 and 0xc0000 */
1304	static int vga_mem_writeb(PVGASTATE pThis, RTGCPHYS addr, uint32_t val)
1305	{
1306	int memory_map_mode, plane, write_mode, b, func_select, mask;
1307	uint32_t write_mask, bit_mask, set_mask;
1308
1309	Log3(("vga: [0x%x] = 0x%02x\n", addr, val));
1310	/* convert to VGA memory offset */
1311	memory_map_mode = (pThis->gr[6] >> 2) & 3;
1312	#ifndef IN_RC
1313	RTGCPHYS GCPhys = addr; /* save original address */
1314	#endif
1315
1316	#if !defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
1317	/* Ugly hack to get result from 2dmark and other vmsvga examples. */
1318	if (pThis->svga.fEnabled)
1319	return VINF_IOM_R3_MMIO_WRITE;
1320	#endif
1321
1322	addr &= 0x1ffff;
1323	switch(memory_map_mode) {
1324	case 0:
1325	break;
1326	case 1:
1327	if (addr >= 0x10000)
1328	return VINF_SUCCESS;
1329	addr += pThis->bank_offset;
1330	break;
1331	case 2:
1332	addr -= 0x10000;
1333	if (addr >= 0x8000)
1334	return VINF_SUCCESS;
1335	break;
1336	default:
1337	case 3:
1338	addr -= 0x18000;
1339	if (addr >= 0x8000)
1340	return VINF_SUCCESS;
1341	break;
1342	}
1343
1344	if (pThis->sr[4] & 0x08) {
1345	/* chain 4 mode : simplest access */
1346	plane = addr & 3;
1347	mask = (1 << plane);
1348	if (pThis->sr[2] & mask) {
1349	# ifndef IN_RC
1350	/* If all planes are accessible, then map the page to the frame buffer and make it writable. */
1351	if ( (pThis->sr[2] & 3) == 3
1352	&& !vga_is_dirty(pThis, addr))
1353	{
1354	STAM_COUNTER_INC(&pThis->StatMapPage);
1355	IOMMMIOMapMMIO2Page(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), GCPhys,
1356	pThis->GCPhysVRAM + addr, X86_PTE_RW \| X86_PTE_P);
1357	pThis->fRemappedVGA = true;
1358	}
1359	# endif /* IN_RC */
1360
1361	VERIFY_VRAM_WRITE_OFF_RETURN(pThis, addr);
1362	#if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
1363	if (pThis->svga.fEnabled && addr < _32K)
1364	((uint8_t *)pThis->svga.pFrameBufferBackup)[addr] = val;
1365	else
1366	#endif
1367	pThis->CTX_SUFF(vram_ptr)[addr] = val;
1368	Log3(("vga: chain4: [0x%x]\n", addr));
1369	pThis->plane_updated \|= mask; /* only used to detect font change */
1370	vga_set_dirty(pThis, addr);
1371	}
1372	} else if (!(pThis->sr[4] & 0x04)) { /* Host access is controlled by SR4, not GR5! */
1373	/* odd/even mode (aka text mode mapping) */
1374	plane = (pThis->gr[4] & 2) \| (addr & 1);
1375	mask = (1 << plane);
1376	if (pThis->sr[2] & mask) {
1377	/* 'addr' is offset in a plane, bit 0 selects the plane.
1378	* Mask the bit 0, convert plane index to vram offset,
1379	* that is multiply by the number of planes,
1380	* and select the plane byte in the vram offset.
1381	*/
1382	addr = ((addr & ~1) << 2) \| plane;
1383	VERIFY_VRAM_WRITE_OFF_RETURN(pThis, addr);
1384	#if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
1385	if (pThis->svga.fEnabled && addr < _32K)
1386	((uint8_t *)pThis->svga.pFrameBufferBackup)[addr] = val;
1387	else
1388	#endif
1389	pThis->CTX_SUFF(vram_ptr)[addr] = val;
1390	Log3(("vga: odd/even: [0x%x]\n", addr));
1391	pThis->plane_updated \|= mask; /* only used to detect font change */
1392	vga_set_dirty(pThis, addr);
1393	}
1394	} else {
1395	/* standard VGA latched access */
1396	VERIFY_VRAM_WRITE_OFF_RETURN(pThis, addr * 4 + 3);
1397
1398	#if 0
1399	/* This code does not work reliably (@bugref{8123}) and no longer helps performance either. */
1400	#ifdef IN_RING0
1401	if (((++pThis->cLatchAccesses) & pThis->uMaskLatchAccess) == pThis->uMaskLatchAccess)
1402	{
1403	static uint32_t const s_aMask[5] = { 0x3ff, 0x1ff, 0x7f, 0x3f, 0x1f};
1404	static uint64_t const s_aDelta[5] = {10000000, 5000000, 2500000, 1250000, 625000};
1405	if (PDMDevHlpCanEmulateIoBlock(pThis->CTX_SUFF(pDevIns)))
1406	{
1407	uint64_t u64CurTime = RTTimeSystemNanoTS();
1408
1409	/* About 1000 (or more) accesses per 10 ms will trigger a reschedule
1410	* to the recompiler
1411	*/
1412	if (u64CurTime - pThis->u64LastLatchedAccess < s_aDelta[pThis->iMask])
1413	{
1414	pThis->u64LastLatchedAccess = 0;
1415	pThis->iMask = RT_MIN(pThis->iMask + 1U, RT_ELEMENTS(s_aMask) - 1U);
1416	pThis->uMaskLatchAccess = s_aMask[pThis->iMask];
1417	pThis->cLatchAccesses = pThis->uMaskLatchAccess - 1;
1418	return VINF_EM_RAW_EMULATE_IO_BLOCK;
1419	}
1420	if (pThis->u64LastLatchedAccess)
1421	{
1422	Log2(("Reset mask (was %d) delta %RX64 (limit %x)\n", pThis->iMask, u64CurTime - pThis->u64LastLatchedAccess, s_aDelta[pThis->iMask]));
1423	if (pThis->iMask)
1424	pThis->iMask--;
1425	pThis->uMaskLatchAccess = s_aMask[pThis->iMask];
1426	}
1427	pThis->u64LastLatchedAccess = u64CurTime;
1428	}
1429	else
1430	{
1431	pThis->u64LastLatchedAccess = 0;
1432	pThis->iMask = 0;
1433	pThis->uMaskLatchAccess = s_aMask[pThis->iMask];
1434	pThis->cLatchAccesses = 0;
1435	}
1436	}
1437	#endif
1438	#endif
1439
1440	write_mode = pThis->gr[5] & 3;
1441	switch(write_mode) {
1442	default:
1443	case 0:
1444	/* rotate */
1445	b = pThis->gr[3] & 7;
1446	val = ((val >> b) \| (val << (8 - b))) & 0xff;
1447	val \|= val << 8;
1448	val \|= val << 16;
1449
1450	/* apply set/reset mask */
1451	set_mask = mask16[pThis->gr[1]];
1452	val = (val & ~set_mask) \| (mask16[pThis->gr[0]] & set_mask);
1453	bit_mask = pThis->gr[8];
1454	break;
1455	case 1:
1456	val = pThis->latch;
1457	goto do_write;
1458	case 2:
1459	val = mask16[val & 0x0f];
1460	bit_mask = pThis->gr[8];
1461	break;
1462	case 3:
1463	/* rotate */
1464	b = pThis->gr[3] & 7;
1465	val = (val >> b) \| (val << (8 - b));
1466
1467	bit_mask = pThis->gr[8] & val;
1468	val = mask16[pThis->gr[0]];
1469	break;
1470	}
1471
1472	/* apply logical operation */
1473	func_select = pThis->gr[3] >> 3;
1474	switch(func_select) {
1475	case 0:
1476	default:
1477	/* nothing to do */
1478	break;
1479	case 1:
1480	/* and */
1481	val &= pThis->latch;
1482	break;
1483	case 2:
1484	/* or */
1485	val \|= pThis->latch;
1486	break;
1487	case 3:
1488	/* xor */
1489	val ^= pThis->latch;
1490	break;
1491	}
1492
1493	/* apply bit mask */
1494	bit_mask \|= bit_mask << 8;
1495	bit_mask \|= bit_mask << 16;
1496	val = (val & bit_mask) \| (pThis->latch & ~bit_mask);
1497
1498	do_write:
1499	/* mask data according to sr[2] */
1500	mask = pThis->sr[2];
1501	pThis->plane_updated \|= mask; /* only used to detect font change */
1502	write_mask = mask16[mask];
1503	#if defined(IN_RING3) && defined(VBOX_WITH_VMSVGA) && defined(VBOX_WITH_VMSVGA_BACKUP_VGA_FB) /** @todo figure out the right way */
1504	if (pThis->svga.fEnabled && addr * 4 + 3U < _32K)
1505	((uint32_t *)pThis->svga.pFrameBufferBackup)[addr] =
1506	(((uint32_t *)pThis->svga.pFrameBufferBackup)[addr] & ~write_mask) \| (val & write_mask);
1507	else
1508	#endif
1509	((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr] =
1510	(((uint32_t *)pThis->CTX_SUFF(vram_ptr))[addr] & ~write_mask) \|
1511	(val & write_mask);
1512	Log3(("vga: latch: [0x%x] mask=0x%08x val=0x%08x\n",
1513	addr * 4, write_mask, val));
1514	vga_set_dirty(pThis, (addr << 2));
1515	}
1516
1517	return VINF_SUCCESS;
1518	}
1519
1520	#if defined(IN_RING3)
1521	typedef void vga_draw_glyph8_func(uint8_t *d, int linesize,
1522	const uint8_t *font_ptr, int h,
1523	uint32_t fgcol, uint32_t bgcol,
1524	int dscan);
1525	typedef void vga_draw_glyph9_func(uint8_t *d, int linesize,
1526	const uint8_t *font_ptr, int h,
1527	uint32_t fgcol, uint32_t bgcol, int dup9);
1528	typedef void vga_draw_line_func(PVGASTATE pThis, uint8_t pbDst, const uint8_t pbSrc, int width);
1529
1530	static inline unsigned int rgb_to_pixel8(unsigned int r, unsigned int g, unsigned b)
1531	{
1532	return ((r >> 5) << 5) \| ((g >> 5) << 2) \| (b >> 6);
1533	}
1534
1535	static inline unsigned int rgb_to_pixel15(unsigned int r, unsigned int g, unsigned b)
1536	{
1537	return ((r >> 3) << 10) \| ((g >> 3) << 5) \| (b >> 3);
1538	}
1539
1540	static inline unsigned int rgb_to_pixel16(unsigned int r, unsigned int g, unsigned b)
1541	{
1542	return ((r >> 3) << 11) \| ((g >> 2) << 5) \| (b >> 3);
1543	}
1544
1545	static inline unsigned int rgb_to_pixel32(unsigned int r, unsigned int g, unsigned b)
1546	{
1547	return (r << 16) \| (g << 8) \| b;
1548	}
1549
1550	#define DEPTH 8
1551	#include "DevVGATmpl.h"
1552
1553	#define DEPTH 15
1554	#include "DevVGATmpl.h"
1555
1556	#define DEPTH 16
1557	#include "DevVGATmpl.h"
1558
1559	#define DEPTH 32
1560	#include "DevVGATmpl.h"
1561
1562	static unsigned int rgb_to_pixel8_dup(unsigned int r, unsigned int g, unsigned b)
1563	{
1564	unsigned int col;
1565	col = rgb_to_pixel8(r, g, b);
1566	col \|= col << 8;
1567	col \|= col << 16;
1568	return col;
1569	}
1570
1571	static unsigned int rgb_to_pixel15_dup(unsigned int r, unsigned int g, unsigned b)
1572	{
1573	unsigned int col;
1574	col = rgb_to_pixel15(r, g, b);
1575	col \|= col << 16;
1576	return col;
1577	}
1578
1579	static unsigned int rgb_to_pixel16_dup(unsigned int r, unsigned int g, unsigned b)
1580	{
1581	unsigned int col;
1582	col = rgb_to_pixel16(r, g, b);
1583	col \|= col << 16;
1584	return col;
1585	}
1586
1587	static unsigned int rgb_to_pixel32_dup(unsigned int r, unsigned int g, unsigned b)
1588	{
1589	unsigned int col;
1590	col = rgb_to_pixel32(r, g, b);
1591	return col;
1592	}
1593
1594	/* return true if the palette was modified */
1595	static bool update_palette16(PVGASTATE pThis)
1596	{
1597	bool full_update = false;
1598	int i;
1599	uint32_t v, col, *palette;
1600
1601	palette = pThis->last_palette;
1602	for(i = 0; i < 16; i++) {
1603	v = pThis->ar[i];
1604	if (pThis->ar[0x10] & 0x80)
1605	v = ((pThis->ar[0x14] & 0xf) << 4) \| (v & 0xf);
1606	else
1607	v = ((pThis->ar[0x14] & 0xc) << 4) \| (v & 0x3f);
1608	v = v * 3;
1609	col = pThis->rgb_to_pixel(c6_to_8(pThis->palette[v]),
1610	c6_to_8(pThis->palette[v + 1]),
1611	c6_to_8(pThis->palette[v + 2]));
1612	if (col != palette[i]) {
1613	full_update = true;
1614	palette[i] = col;
1615	}
1616	}
1617	return full_update;
1618	}
1619
1620	/* return true if the palette was modified */
1621	static bool update_palette256(PVGASTATE pThis)
1622	{
1623	bool full_update = false;
1624	int i;
1625	uint32_t v, col, *palette;
1626	int wide_dac;
1627
1628	palette = pThis->last_palette;
1629	v = 0;
1630	wide_dac = (pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & (VBE_DISPI_ENABLED \| VBE_DISPI_8BIT_DAC))
1631	== (VBE_DISPI_ENABLED \| VBE_DISPI_8BIT_DAC);
1632	for(i = 0; i < 256; i++) {
1633	if (wide_dac)
1634	col = pThis->rgb_to_pixel(pThis->palette[v],
1635	pThis->palette[v + 1],
1636	pThis->palette[v + 2]);
1637	else
1638	col = pThis->rgb_to_pixel(c6_to_8(pThis->palette[v]),
1639	c6_to_8(pThis->palette[v + 1]),
1640	c6_to_8(pThis->palette[v + 2]));
1641	if (col != palette[i]) {
1642	full_update = true;
1643	palette[i] = col;
1644	}
1645	v += 3;
1646	}
1647	return full_update;
1648	}
1649
1650	static void vga_get_offsets(PVGASTATE pThis,
1651	uint32_t *pline_offset,
1652	uint32_t *pstart_addr,
1653	uint32_t *pline_compare)
1654	{
1655	uint32_t start_addr, line_offset, line_compare;
1656	#ifdef CONFIG_BOCHS_VBE
1657	if (pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED) {
1658	line_offset = pThis->vbe_line_offset;
1659	start_addr = pThis->vbe_start_addr;
1660	line_compare = 65535;
1661	} else
1662	#endif
1663	{
1664	/* compute line_offset in bytes */
1665	line_offset = pThis->cr[0x13];
1666	line_offset <<= 3;
1667	if (!(pThis->cr[0x14] & 0x40) && !(pThis->cr[0x17] & 0x40))
1668	{
1669	/* Word mode. Used for odd/even modes. */
1670	line_offset *= 2;
1671	}
1672
1673	/* starting address */
1674	start_addr = pThis->cr[0x0d] \| (pThis->cr[0x0c] << 8);
1675
1676	/* line compare */
1677	line_compare = pThis->cr[0x18] \|
1678	((pThis->cr[0x07] & 0x10) << 4) \|
1679	((pThis->cr[0x09] & 0x40) << 3);
1680	}
1681	*pline_offset = line_offset;
1682	*pstart_addr = start_addr;
1683	*pline_compare = line_compare;
1684	}
1685
1686	/* update start_addr and line_offset. Return TRUE if modified */
1687	static bool update_basic_params(PVGASTATE pThis)
1688	{
1689	bool full_update = false;
1690	uint32_t start_addr, line_offset, line_compare;
1691
1692	pThis->get_offsets(pThis, &line_offset, &start_addr, &line_compare);
1693
1694	if (line_offset != pThis->line_offset \|\|
1695	start_addr != pThis->start_addr \|\|
1696	line_compare != pThis->line_compare) {
1697	pThis->line_offset = line_offset;
1698	pThis->start_addr = start_addr;
1699	pThis->line_compare = line_compare;
1700	full_update = true;
1701	}
1702	return full_update;
1703	}
1704
1705	static inline int get_depth_index(int depth)
1706	{
1707	switch(depth) {
1708	default:
1709	case 8:
1710	return 0;
1711	case 15:
1712	return 1;
1713	case 16:
1714	return 2;
1715	case 32:
1716	return 3;
1717	}
1718	}
1719
1720	static vga_draw_glyph8_func *vga_draw_glyph8_table[4] = {
1721	vga_draw_glyph8_8,
1722	vga_draw_glyph8_16,
1723	vga_draw_glyph8_16,
1724	vga_draw_glyph8_32,
1725	};
1726
1727	static vga_draw_glyph8_func *vga_draw_glyph16_table[4] = {
1728	vga_draw_glyph16_8,
1729	vga_draw_glyph16_16,
1730	vga_draw_glyph16_16,
1731	vga_draw_glyph16_32,
1732	};
1733
1734	static vga_draw_glyph9_func *vga_draw_glyph9_table[4] = {
1735	vga_draw_glyph9_8,
1736	vga_draw_glyph9_16,
1737	vga_draw_glyph9_16,
1738	vga_draw_glyph9_32,
1739	};
1740
1741	static const uint8_t cursor_glyph[32 * 4] = {
1742	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1743	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1744	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1745	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1746	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1747	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1748	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1749	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1750	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1751	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1752	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1753	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1754	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1755	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1756	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1757	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1758	};
1759
1760	/*
1761	* Text mode update
1762	* Missing:
1763	* - underline
1764	* - flashing
1765	*/
1766	static int vga_draw_text(PVGASTATE pThis, bool full_update, bool fFailOnResize, bool reset_dirty,
1767	PDMIDISPLAYCONNECTOR *pDrv)
1768	{
1769	int cx, cy, cheight, cw, ch, cattr, height, width, ch_attr;
1770	int cx_min, cx_max, linesize, x_incr;
1771	int cx_min_upd, cx_max_upd, cy_start;
1772	uint32_t offset, fgcol, bgcol, v, cursor_offset;
1773	uint8_t d1, d, src, s1, dest, cursor_ptr;
1774	const uint8_t font_ptr, font_base[2];
1775	int dup9, line_offset, depth_index, dscan;
1776	uint32_t *palette;
1777	uint32_t *ch_attr_ptr;
1778	vga_draw_glyph8_func *vga_draw_glyph8;
1779	vga_draw_glyph9_func *vga_draw_glyph9;
1780
1781	full_update \|= update_palette16(pThis);
1782	palette = pThis->last_palette;
1783
1784	/* compute font data address (in plane 2) */
1785	v = pThis->sr[3];
1786	offset = (((v >> 4) & 1) \| ((v << 1) & 6)) * 8192 * 4 + 2;
1787	if (offset != pThis->font_offsets[0]) {
1788	pThis->font_offsets[0] = offset;
1789	full_update = true;
1790	}
1791	font_base[0] = pThis->CTX_SUFF(vram_ptr) + offset;
1792
1793	offset = (((v >> 5) & 1) \| ((v >> 1) & 6)) * 8192 * 4 + 2;
1794	font_base[1] = pThis->CTX_SUFF(vram_ptr) + offset;
1795	if (offset != pThis->font_offsets[1]) {
1796	pThis->font_offsets[1] = offset;
1797	full_update = true;
1798	}
1799	if (pThis->plane_updated & (1 << 2)) {
1800	/* if the plane 2 was modified since the last display, it
1801	indicates the font may have been modified */
1802	pThis->plane_updated = 0;
1803	full_update = true;
1804	}
1805	full_update \|= update_basic_params(pThis);
1806
1807	line_offset = pThis->line_offset;
1808	s1 = pThis->CTX_SUFF(vram_ptr) + (pThis->start_addr * 8); /** @todo r=bird: Add comment why we do 8 instead of 4, it's not so obvious... */
1809
1810	/* double scanning - not for 9-wide modes */
1811	dscan = (pThis->cr[9] >> 7) & 1;
1812
1813	/* total width & height */
1814	cheight = (pThis->cr[9] & 0x1f) + 1;
1815	cw = 8;
1816	if (!(pThis->sr[1] & 0x01))
1817	cw = 9;
1818	if (pThis->sr[1] & 0x08)
1819	cw = 16; /* NOTE: no 18 pixel wide */
1820	x_incr = cw * ((pDrv->cBits + 7) >> 3);
1821	width = (pThis->cr[0x01] + 1);
1822	if (pThis->cr[0x06] == 100) {
1823	/* ugly hack for CGA 160x100x16 - explain me the logic */
1824	height = 100;
1825	} else {
1826	height = pThis->cr[0x12] \|
1827	((pThis->cr[0x07] & 0x02) << 7) \|
1828	((pThis->cr[0x07] & 0x40) << 3);
1829	height = (height + 1) / cheight;
1830	}
1831	if ((height * width) > CH_ATTR_SIZE) {
1832	/* better than nothing: exit if transient size is too big */
1833	return VINF_SUCCESS;
1834	}
1835
1836	if (width != (int)pThis->last_width \|\| height != (int)pThis->last_height \|\|
1837	cw != pThis->last_cw \|\| cheight != pThis->last_ch) {
1838	if (fFailOnResize)
1839	{
1840	/* The caller does not want to call the pfnResize. */
1841	return VERR_TRY_AGAIN;
1842	}
1843	pThis->last_scr_width = width * cw;
1844	pThis->last_scr_height = height * cheight;
1845	/* For text modes the direct use of guest VRAM is not implemented, so bpp and cbLine are 0 here. */
1846	int rc = pDrv->pfnResize(pDrv, 0, NULL, 0, pThis->last_scr_width, pThis->last_scr_height);
1847	pThis->last_width = width;
1848	pThis->last_height = height;
1849	pThis->last_ch = cheight;
1850	pThis->last_cw = cw;
1851	full_update = true;
1852	if (rc == VINF_VGA_RESIZE_IN_PROGRESS)
1853	return rc;
1854	AssertRC(rc);
1855	}
1856	cursor_offset = ((pThis->cr[0x0e] << 8) \| pThis->cr[0x0f]) - pThis->start_addr;
1857	if (cursor_offset != pThis->cursor_offset \|\|
1858	pThis->cr[0xa] != pThis->cursor_start \|\|
1859	pThis->cr[0xb] != pThis->cursor_end) {
1860	/* if the cursor position changed, we update the old and new
1861	chars */
1862	if (pThis->cursor_offset < CH_ATTR_SIZE)
1863	pThis->last_ch_attr[pThis->cursor_offset] = ~0;
1864	if (cursor_offset < CH_ATTR_SIZE)
1865	pThis->last_ch_attr[cursor_offset] = ~0;
1866	pThis->cursor_offset = cursor_offset;
1867	pThis->cursor_start = pThis->cr[0xa];
1868	pThis->cursor_end = pThis->cr[0xb];
1869	}
1870	cursor_ptr = pThis->CTX_SUFF(vram_ptr) + (pThis->start_addr + cursor_offset) * 8;
1871	depth_index = get_depth_index(pDrv->cBits);
1872	if (cw == 16)
1873	vga_draw_glyph8 = vga_draw_glyph16_table[depth_index];
1874	else
1875	vga_draw_glyph8 = vga_draw_glyph8_table[depth_index];
1876	vga_draw_glyph9 = vga_draw_glyph9_table[depth_index];
1877
1878	dest = pDrv->pbData;
1879	linesize = pDrv->cbScanline;
1880	ch_attr_ptr = pThis->last_ch_attr;
1881	cy_start = -1;
1882	cx_max_upd = -1;
1883	cx_min_upd = width;
1884
1885	for(cy = 0; cy < (height - dscan); cy = cy + (1 << dscan)) {
1886	d1 = dest;
1887	src = s1;
1888	cx_min = width;
1889	cx_max = -1;
1890	for(cx = 0; cx < width; cx++) {
1891	ch_attr = (uint16_t )src;
1892	if (full_update \|\| ch_attr != (int)*ch_attr_ptr) {
1893	if (cx < cx_min)
1894	cx_min = cx;
1895	if (cx > cx_max)
1896	cx_max = cx;
1897	if (reset_dirty)
1898	*ch_attr_ptr = ch_attr;
1899	#ifdef WORDS_BIGENDIAN
1900	ch = ch_attr >> 8;
1901	cattr = ch_attr & 0xff;
1902	#else
1903	ch = ch_attr & 0xff;
1904	cattr = ch_attr >> 8;
1905	#endif
1906	font_ptr = font_base[(cattr >> 3) & 1];
1907	font_ptr += 32 * 4 * ch;
1908	bgcol = palette[cattr >> 4];
1909	fgcol = palette[cattr & 0x0f];
1910	if (cw != 9) {
1911	if (pThis->fRenderVRAM)
1912	vga_draw_glyph8(d1, linesize,
1913	font_ptr, cheight, fgcol, bgcol, dscan);
1914	} else {
1915	dup9 = 0;
1916	if (ch >= 0xb0 && ch <= 0xdf && (pThis->ar[0x10] & 0x04))
1917	dup9 = 1;
1918	if (pThis->fRenderVRAM)
1919	vga_draw_glyph9(d1, linesize,
1920	font_ptr, cheight, fgcol, bgcol, dup9);
1921	}
1922	if (src == cursor_ptr &&
1923	!(pThis->cr[0x0a] & 0x20)) {
1924	int line_start, line_last, h;
1925	/* draw the cursor */
1926	line_start = pThis->cr[0x0a] & 0x1f;
1927	line_last = pThis->cr[0x0b] & 0x1f;
1928	/* XXX: check that */
1929	if (line_last > cheight - 1)
1930	line_last = cheight - 1;
1931	if (line_last >= line_start && line_start < cheight) {
1932	h = line_last - line_start + 1;
1933	d = d1 + (linesize * line_start << dscan);
1934	if (cw != 9) {
1935	if (pThis->fRenderVRAM)
1936	vga_draw_glyph8(d, linesize,
1937	cursor_glyph, h, fgcol, bgcol, dscan);
1938	} else {
1939	if (pThis->fRenderVRAM)
1940	vga_draw_glyph9(d, linesize,
1941	cursor_glyph, h, fgcol, bgcol, 1);
1942	}
1943	}
1944	}
1945	}
1946	d1 += x_incr;
1947	src += 8; /* Every second byte of a plane is used in text mode. */
1948	ch_attr_ptr++;
1949	}
1950	if (cx_max != -1) {
1951	/* Keep track of the bounding rectangle for updates. */
1952	if (cy_start == -1)
1953	cy_start = cy;
1954	if (cx_min_upd > cx_min)
1955	cx_min_upd = cx_min;
1956	if (cx_max_upd < cx_max)
1957	cx_max_upd = cx_max;
1958	} else if (cy_start >= 0) {
1959	/* Flush updates to display. */
1960	pDrv->pfnUpdateRect(pDrv, cx_min_upd * cw, cy_start * cheight,
1961	(cx_max_upd - cx_min_upd + 1) * cw, (cy - cy_start) * cheight);
1962	cy_start = -1;
1963	cx_max_upd = -1;
1964	cx_min_upd = width;
1965	}
1966	dest += linesize * cheight << dscan;
1967	s1 += line_offset;
1968	}
1969	if (cy_start >= 0)
1970	/* Flush any remaining changes to display. */
1971	pDrv->pfnUpdateRect(pDrv, cx_min_upd * cw, cy_start * cheight,
1972	(cx_max_upd - cx_min_upd + 1) * cw, (cy - cy_start) * cheight);
1973	return VINF_SUCCESS;
1974	}
1975
1976	enum {
1977	VGA_DRAW_LINE2,
1978	VGA_DRAW_LINE2D2,
1979	VGA_DRAW_LINE4,
1980	VGA_DRAW_LINE4D2,
1981	VGA_DRAW_LINE8D2,
1982	VGA_DRAW_LINE8,
1983	VGA_DRAW_LINE15,
1984	VGA_DRAW_LINE16,
1985	VGA_DRAW_LINE24,
1986	VGA_DRAW_LINE32,
1987	VGA_DRAW_LINE_NB
1988	};
1989
1990	static vga_draw_line_func vga_draw_line_table[4 VGA_DRAW_LINE_NB] = {
1991	vga_draw_line2_8,
1992	vga_draw_line2_16,
1993	vga_draw_line2_16,
1994	vga_draw_line2_32,
1995
1996	vga_draw_line2d2_8,
1997	vga_draw_line2d2_16,
1998	vga_draw_line2d2_16,
1999	vga_draw_line2d2_32,
2000
2001	vga_draw_line4_8,
2002	vga_draw_line4_16,
2003	vga_draw_line4_16,
2004	vga_draw_line4_32,
2005
2006	vga_draw_line4d2_8,
2007	vga_draw_line4d2_16,
2008	vga_draw_line4d2_16,
2009	vga_draw_line4d2_32,
2010
2011	vga_draw_line8d2_8,
2012	vga_draw_line8d2_16,
2013	vga_draw_line8d2_16,
2014	vga_draw_line8d2_32,
2015
2016	vga_draw_line8_8,
2017	vga_draw_line8_16,
2018	vga_draw_line8_16,
2019	vga_draw_line8_32,
2020
2021	vga_draw_line15_8,
2022	vga_draw_line15_15,
2023	vga_draw_line15_16,
2024	vga_draw_line15_32,
2025
2026	vga_draw_line16_8,
2027	vga_draw_line16_15,
2028	vga_draw_line16_16,
2029	vga_draw_line16_32,
2030
2031	vga_draw_line24_8,
2032	vga_draw_line24_15,
2033	vga_draw_line24_16,
2034	vga_draw_line24_32,
2035
2036	vga_draw_line32_8,
2037	vga_draw_line32_15,
2038	vga_draw_line32_16,
2039	vga_draw_line32_32,
2040	};
2041
2042	static int vga_get_bpp(PVGASTATE pThis)
2043	{
2044	int ret;
2045	#ifdef CONFIG_BOCHS_VBE
2046	if (pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED) {
2047	ret = pThis->vbe_regs[VBE_DISPI_INDEX_BPP];
2048	} else
2049	#endif
2050	{
2051	ret = 0;
2052	}
2053	return ret;
2054	}
2055
2056	static void vga_get_resolution(PVGASTATE pThis, int pwidth, int pheight)
2057	{
2058	int width, height;
2059	#ifdef CONFIG_BOCHS_VBE
2060	if (pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED) {
2061	width = pThis->vbe_regs[VBE_DISPI_INDEX_XRES];
2062	height = RT_MIN(pThis->vbe_regs[VBE_DISPI_INDEX_YRES],
2063	pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_HEIGHT]);
2064	} else
2065	#endif
2066	{
2067	width = (pThis->cr[0x01] + 1) * 8;
2068	height = pThis->cr[0x12] \|
2069	((pThis->cr[0x07] & 0x02) << 7) \|
2070	((pThis->cr[0x07] & 0x40) << 3);
2071	height = (height + 1);
2072	}
2073	*pwidth = width;
2074	*pheight = height;
2075	}
2076
2077	/**
2078	* Performs the display driver resizing when in graphics mode.
2079	*
2080	* This will recalc / update any status data depending on the driver
2081	* properties (bit depth mostly).
2082	*
2083	* @returns VINF_SUCCESS on success.
2084	* @returns VINF_VGA_RESIZE_IN_PROGRESS if the operation wasn't complete.
2085	* @param pThis Pointer to the vga state.
2086	* @param cx The width.
2087	* @param cy The height.
2088	*/
2089	static int vga_resize_graphic(PVGASTATE pThis, int cx, int cy,
2090	PDMIDISPLAYCONNECTOR *pDrv)
2091	{
2092	const unsigned cBits = pThis->get_bpp(pThis);
2093
2094	int rc;
2095	AssertReturn(cx, VERR_INVALID_PARAMETER);
2096	AssertReturn(cy, VERR_INVALID_PARAMETER);
2097	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2098
2099	if (!pThis->line_offset)
2100	return VERR_INTERNAL_ERROR;
2101
2102	#if 0 //def VBOX_WITH_VDMA
2103	/** @todo: we get a second resize here when VBVA is on, while we actually should not */
2104	/* do not do pfnResize in case VBVA is on since all mode changes are performed over VBVA
2105	* we are checking for VDMA state here to ensure this code works only for WDDM driver,
2106	* although we should avoid calling pfnResize for XPDM as well, since pfnResize is actually an extra resize
2107	* event and generally only pfnVBVAxxx calls should be used with HGSMI + VBVA
2108	*
2109	* The reason for doing this for WDDM driver only now is to avoid regressions of the current code */
2110	PVBOXVDMAHOST pVdma = pThis->pVdma;
2111	if (pVdma && vboxVDMAIsEnabled(pVdma))
2112	rc = VINF_SUCCESS;
2113	else
2114	#endif
2115	{
2116	/* Skip the resize if the values are not valid. */
2117	if (pThis->start_addr * 4 + pThis->line_offset * cy < pThis->vram_size)
2118	/* Take into account the programmed start address (in DWORDs) of the visible screen. */
2119	rc = pDrv->pfnResize(pDrv, cBits, pThis->CTX_SUFF(vram_ptr) + pThis->start_addr * 4, pThis->line_offset, cx, cy);
2120	else
2121	{
2122	/* Change nothing in the VGA state. Lets hope the guest will eventually programm correct values. */
2123	return VERR_TRY_AGAIN;
2124	}
2125	}
2126
2127	/* last stuff */
2128	pThis->last_bpp = cBits;
2129	pThis->last_scr_width = cx;
2130	pThis->last_scr_height = cy;
2131	pThis->last_width = cx;
2132	pThis->last_height = cy;
2133
2134	if (rc == VINF_VGA_RESIZE_IN_PROGRESS)
2135	return rc;
2136	AssertRC(rc);
2137
2138	/* update palette */
2139	switch (pDrv->cBits)
2140	{
2141	case 32: pThis->rgb_to_pixel = rgb_to_pixel32_dup; break;
2142	case 16:
2143	default: pThis->rgb_to_pixel = rgb_to_pixel16_dup; break;
2144	case 15: pThis->rgb_to_pixel = rgb_to_pixel15_dup; break;
2145	case 8: pThis->rgb_to_pixel = rgb_to_pixel8_dup; break;
2146	}
2147	if (pThis->shift_control == 0)
2148	update_palette16(pThis);
2149	else if (pThis->shift_control == 1)
2150	update_palette16(pThis);
2151	return VINF_SUCCESS;
2152	}
2153
2154	#ifdef VBOX_WITH_VMSVGA
2155	int vgaR3UpdateDisplay(VGAState *s, unsigned xStart, unsigned yStart, unsigned cx, unsigned cy)
2156	{
2157	uint32_t v;
2158	vga_draw_line_func *vga_draw_line;
2159
2160	if (!s->fRenderVRAM)
2161	{
2162	s->pDrv->pfnUpdateRect(s->pDrv, xStart, yStart, cx, cy);
2163	return VINF_SUCCESS;
2164	}
2165	/** @todo might crash if a blit follows a resolution change very quickly (seen this many times!) */
2166
2167	if ( s->svga.uWidth == VMSVGA_VAL_UNINITIALIZED
2168	\|\| s->svga.uHeight == VMSVGA_VAL_UNINITIALIZED
2169	\|\| s->svga.uBpp == VMSVGA_VAL_UNINITIALIZED)
2170	{
2171	/* Intermediate state; skip redraws. */
2172	AssertFailed();
2173	return VINF_SUCCESS;
2174	}
2175
2176	uint32_t cBits;
2177	switch (s->svga.uBpp) {
2178	default:
2179	case 0:
2180	case 8:
2181	AssertFailed();
2182	return VERR_NOT_IMPLEMENTED;
2183	case 15:
2184	v = VGA_DRAW_LINE15;
2185	cBits = 16;
2186	break;
2187	case 16:
2188	v = VGA_DRAW_LINE16;
2189	cBits = 16;
2190	break;
2191	case 24:
2192	v = VGA_DRAW_LINE24;
2193	cBits = 24;
2194	break;
2195	case 32:
2196	v = VGA_DRAW_LINE32;
2197	cBits = 32;
2198	break;
2199	}
2200	vga_draw_line = vga_draw_line_table[v * 4 + get_depth_index(s->pDrv->cBits)];
2201
2202	uint32_t offSrc = (xStart * cBits) / 8 + s->svga.cbScanline * yStart;
2203	uint32_t offDst = (xStart * RT_ALIGN(s->pDrv->cBits, 8)) / 8 + s->pDrv->cbScanline * yStart;
2204
2205	uint8_t *pbDst = s->pDrv->pbData + offDst;
2206	uint8_t const *pbSrc = s->CTX_SUFF(vram_ptr) + offSrc;
2207
2208	for (unsigned y = yStart; y < yStart + cy; y++)
2209	{
2210	vga_draw_line(s, pbDst, pbSrc, cx);
2211
2212	pbDst += s->pDrv->cbScanline;
2213	pbSrc += s->svga.cbScanline;
2214	}
2215	s->pDrv->pfnUpdateRect(s->pDrv, xStart, yStart, cx, cy);
2216
2217	return VINF_SUCCESS;
2218	}
2219
2220	/*
2221	* graphic modes
2222	*/
2223	static int vmsvga_draw_graphic(PVGASTATE pThis, bool full_update, bool fFailOnResize, bool reset_dirty,
2224	PDMIDISPLAYCONNECTOR *pDrv)
2225	{
2226	int y, page_min, page_max, linesize, y_start;
2227	int width, height, page0, page1, bwidth, bits;
2228	int disp_width;
2229	uint8_t *d;
2230	uint32_t v, addr1, addr;
2231	vga_draw_line_func *vga_draw_line;
2232
2233	if ( pThis->svga.uWidth == VMSVGA_VAL_UNINITIALIZED
2234	\|\| pThis->svga.uWidth == 0
2235	\|\| pThis->svga.uHeight == VMSVGA_VAL_UNINITIALIZED
2236	\|\| pThis->svga.uHeight == 0
2237	\|\| pThis->svga.uBpp == VMSVGA_VAL_UNINITIALIZED
2238	\|\| pThis->svga.uBpp == 0)
2239	{
2240	/* Intermediate state; skip redraws. */
2241	return VINF_SUCCESS;
2242	}
2243
2244	width = pThis->svga.uWidth;
2245	height = pThis->svga.uHeight;
2246
2247	disp_width = width;
2248
2249	switch(pThis->svga.uBpp) {
2250	default:
2251	case 0:
2252	case 8:
2253	AssertFailed();
2254	return VERR_NOT_IMPLEMENTED;
2255	case 15:
2256	v = VGA_DRAW_LINE15;
2257	bits = 16;
2258	break;
2259	case 16:
2260	v = VGA_DRAW_LINE16;
2261	bits = 16;
2262	break;
2263	case 24:
2264	v = VGA_DRAW_LINE24;
2265	bits = 24;
2266	break;
2267	case 32:
2268	v = VGA_DRAW_LINE32;
2269	bits = 32;
2270	break;
2271	}
2272	vga_draw_line = vga_draw_line_table[v * 4 + get_depth_index(pDrv->cBits)];
2273
2274	if (pThis->cursor_invalidate)
2275	pThis->cursor_invalidate(pThis);
2276
2277	addr1 = 0; /* always start at the beginning of the framebuffer */
2278	bwidth = (width * bits + 7) / 8; /* The visible width of a scanline. */
2279	y_start = -1;
2280	page_min = 0x7fffffff;
2281	page_max = -1;
2282	d = pDrv->pbData;
2283	linesize = pDrv->cbScanline;
2284
2285	for(y = 0; y < height; y++)
2286	{
2287	addr = addr1 + y * bwidth;
2288
2289	page0 = addr & ~PAGE_OFFSET_MASK;
2290	page1 = (addr + bwidth - 1) & ~PAGE_OFFSET_MASK;
2291	bool update = full_update \| vga_is_dirty(pThis, page0) \| vga_is_dirty(pThis, page1);
2292	if (page1 - page0 > PAGE_SIZE)
2293	/* if wide line, can use another page */
2294	update \|= vga_is_dirty(pThis, page0 + PAGE_SIZE);
2295	/* explicit invalidation for the hardware cursor */
2296	update \|= (pThis->invalidated_y_table[y >> 5] >> (y & 0x1f)) & 1;
2297	if (update)
2298	{
2299	if (y_start < 0)
2300	y_start = y;
2301	if (page0 < page_min)
2302	page_min = page0;
2303	if (page1 > page_max)
2304	page_max = page1;
2305	if (pThis->fRenderVRAM)
2306	vga_draw_line(pThis, d, pThis->CTX_SUFF(vram_ptr) + addr, width);
2307	if (pThis->cursor_draw_line)
2308	pThis->cursor_draw_line(pThis, d, y);
2309	} else
2310	{
2311	if (y_start >= 0)
2312	{
2313	/* flush to display */
2314	Log(("Flush to display (%d,%d)(%d,%d)\n", 0, y_start, disp_width, y - y_start));
2315	pDrv->pfnUpdateRect(pDrv, 0, y_start, disp_width, y - y_start);
2316	y_start = -1;
2317	}
2318	}
2319	d += linesize;
2320	}
2321	if (y_start >= 0)
2322	{
2323	/* flush to display */
2324	Log(("Flush to display (%d,%d)(%d,%d)\n", 0, y_start, disp_width, y - y_start));
2325	pDrv->pfnUpdateRect(pDrv, 0, y_start, disp_width, y - y_start);
2326	}
2327	/* reset modified pages */
2328	if (page_max != -1 && reset_dirty)
2329	vga_reset_dirty(pThis, page_min, page_max + PAGE_SIZE);
2330	memset(pThis->invalidated_y_table, 0, ((height + 31) >> 5) * 4);
2331	return VINF_SUCCESS;
2332	}
2333	#endif /* VBOX_WITH_VMSVGA */
2334
2335	/*
2336	* graphic modes
2337	*/
2338	static int vga_draw_graphic(PVGASTATE pThis, bool full_update, bool fFailOnResize, bool reset_dirty,
2339	PDMIDISPLAYCONNECTOR *pDrv)
2340	{
2341	int y1, y2, y, page_min, page_max, linesize, y_start, double_scan;
2342	int width, height, shift_control, line_offset, page0, page1, bwidth, bits;
2343	int disp_width, multi_run;
2344	uint8_t *d;
2345	uint32_t v, addr1, addr;
2346	vga_draw_line_func *vga_draw_line;
2347
2348	bool offsets_changed = update_basic_params(pThis);
2349
2350	full_update \|= offsets_changed;
2351
2352	pThis->get_resolution(pThis, &width, &height);
2353	disp_width = width;
2354
2355	shift_control = (pThis->gr[0x05] >> 5) & 3;
2356	double_scan = (pThis->cr[0x09] >> 7);
2357	multi_run = double_scan;
2358	if (shift_control != pThis->shift_control \|\|
2359	double_scan != pThis->double_scan) {
2360	full_update = true;
2361	pThis->shift_control = shift_control;
2362	pThis->double_scan = double_scan;
2363	}
2364
2365	if (shift_control == 0) {
2366	full_update \|= update_palette16(pThis);
2367	if (pThis->sr[0x01] & 8) {
2368	v = VGA_DRAW_LINE4D2;
2369	disp_width <<= 1;
2370	} else {
2371	v = VGA_DRAW_LINE4;
2372	}
2373	bits = 4;
2374	} else if (shift_control == 1) {
2375	full_update \|= update_palette16(pThis);
2376	if (pThis->sr[0x01] & 8) {
2377	v = VGA_DRAW_LINE2D2;
2378	disp_width <<= 1;
2379	} else {
2380	v = VGA_DRAW_LINE2;
2381	}
2382	bits = 4;
2383	} else {
2384	switch(pThis->get_bpp(pThis)) {
2385	default:
2386	case 0:
2387	full_update \|= update_palette256(pThis);
2388	v = VGA_DRAW_LINE8D2;
2389	bits = 4;
2390	break;
2391	case 8:
2392	full_update \|= update_palette256(pThis);
2393	v = VGA_DRAW_LINE8;
2394	bits = 8;
2395	break;
2396	case 15:
2397	v = VGA_DRAW_LINE15;
2398	bits = 16;
2399	break;
2400	case 16:
2401	v = VGA_DRAW_LINE16;
2402	bits = 16;
2403	break;
2404	case 24:
2405	v = VGA_DRAW_LINE24;
2406	bits = 24;
2407	break;
2408	case 32:
2409	v = VGA_DRAW_LINE32;
2410	bits = 32;
2411	break;
2412	}
2413	}
2414	if ( disp_width != (int)pThis->last_width
2415	\|\| height != (int)pThis->last_height
2416	\|\| pThis->get_bpp(pThis) != (int)pThis->last_bpp
2417	\|\| (offsets_changed && !pThis->fRenderVRAM))
2418	{
2419	if (fFailOnResize)
2420	{
2421	/* The caller does not want to call the pfnResize. */
2422	return VERR_TRY_AGAIN;
2423	}
2424	int rc = vga_resize_graphic(pThis, disp_width, height, pDrv);
2425	if (rc != VINF_SUCCESS) /* Return any rc, particularly VINF_VGA_RESIZE_IN_PROGRESS, to the caller. */
2426	return rc;
2427	full_update = true;
2428	}
2429
2430	if (pThis->fRenderVRAM)
2431	{
2432	/* Do not update the destination buffer if it is not big enough.
2433	* Can happen if the resize request was ignored by the driver.
2434	* Compare with 'disp_width', because it is what the framebuffer has been resized to.
2435	*/
2436	if ( pDrv->cx != (uint32_t)disp_width
2437	\|\| pDrv->cy != (uint32_t)height)
2438	{
2439	LogRel(("Framebuffer mismatch: vga %dx%d, drv %dx%d!!!\n",
2440	disp_width, height,
2441	pDrv->cx, pDrv->cy));
2442	return VINF_SUCCESS;
2443	}
2444	}
2445
2446	vga_draw_line = vga_draw_line_table[v * 4 + get_depth_index(pDrv->cBits)];
2447
2448	if (pThis->cursor_invalidate)
2449	pThis->cursor_invalidate(pThis);
2450
2451	line_offset = pThis->line_offset;
2452	#if 0
2453	Log(("w=%d h=%d v=%d line_offset=%d cr[0x09]=0x%02x cr[0x17]=0x%02x linecmp=%d sr[0x01]=0x%02x\n",
2454	width, height, v, line_offset, pThis->cr[9], pThis->cr[0x17], pThis->line_compare, pThis->sr[0x01]));
2455	#endif
2456	addr1 = (pThis->start_addr * 4);
2457	bwidth = (width * bits + 7) / 8; /* The visible width of a scanline. */
2458	y_start = -1;
2459	page_min = 0x7fffffff;
2460	page_max = -1;
2461	d = pDrv->pbData;
2462	linesize = pDrv->cbScanline;
2463
2464	y1 = 0;
2465	y2 = pThis->cr[0x09] & 0x1F; /* starting row scan count */
2466	for(y = 0; y < height; y++) {
2467	addr = addr1;
2468	/* CGA/MDA compatibility. Note that these addresses are all
2469	* shifted left by two compared to VGA specs.
2470	*/
2471	if (!(pThis->cr[0x17] & 1)) {
2472	addr = (addr & ~(1 << 15)) \| ((y1 & 1) << 15);
2473	}
2474	if (!(pThis->cr[0x17] & 2)) {
2475	addr = (addr & ~(1 << 16)) \| ((y1 & 2) << 15);
2476	}
2477	page0 = addr & ~PAGE_OFFSET_MASK;
2478	page1 = (addr + bwidth - 1) & ~PAGE_OFFSET_MASK;
2479	bool update = full_update \| vga_is_dirty(pThis, page0) \| vga_is_dirty(pThis, page1);
2480	if (page1 - page0 > PAGE_SIZE) {
2481	/* if wide line, can use another page */
2482	update \|= vga_is_dirty(pThis, page0 + PAGE_SIZE);
2483	}
2484	/* explicit invalidation for the hardware cursor */
2485	update \|= (pThis->invalidated_y_table[y >> 5] >> (y & 0x1f)) & 1;
2486	if (update) {
2487	if (y_start < 0)
2488	y_start = y;
2489	if (page0 < page_min)
2490	page_min = page0;
2491	if (page1 > page_max)
2492	page_max = page1;
2493	if (pThis->fRenderVRAM)
2494	vga_draw_line(pThis, d, pThis->CTX_SUFF(vram_ptr) + addr, width);
2495	if (pThis->cursor_draw_line)
2496	pThis->cursor_draw_line(pThis, d, y);
2497	} else {
2498	if (y_start >= 0) {
2499	/* flush to display */
2500	pDrv->pfnUpdateRect(pDrv, 0, y_start, disp_width, y - y_start);
2501	y_start = -1;
2502	}
2503	}
2504	if (!multi_run) {
2505	y1++;
2506	multi_run = double_scan;
2507
2508	if (y2 == 0) {
2509	y2 = pThis->cr[0x09] & 0x1F;
2510	addr1 += line_offset;
2511	} else {
2512	--y2;
2513	}
2514	} else {
2515	multi_run--;
2516	}
2517	/* line compare acts on the displayed lines */
2518	if ((uint32_t)y == pThis->line_compare)
2519	addr1 = 0;
2520	d += linesize;
2521	}
2522	if (y_start >= 0) {
2523	/* flush to display */
2524	pDrv->pfnUpdateRect(pDrv, 0, y_start, disp_width, y - y_start);
2525	}
2526	/* reset modified pages */
2527	if (page_max != -1 && reset_dirty) {
2528	vga_reset_dirty(pThis, page_min, page_max + PAGE_SIZE);
2529	}
2530	memset(pThis->invalidated_y_table, 0, ((height + 31) >> 5) * 4);
2531	return VINF_SUCCESS;
2532	}
2533
2534	static void vga_draw_blank(PVGASTATE pThis, int full_update, PDMIDISPLAYCONNECTOR *pDrv)
2535	{
2536	int i, w, val;
2537	uint8_t *d;
2538	uint32_t cbScanline = pDrv->cbScanline;
2539
2540	if (pDrv->pbData == pThis->vram_ptrR3) /* Do not clear the VRAM itself. */
2541	return;
2542	if (!full_update)
2543	return;
2544	if (pThis->last_scr_width <= 0 \|\| pThis->last_scr_height <= 0)
2545	return;
2546	if (pDrv->cBits == 8)
2547	val = pThis->rgb_to_pixel(0, 0, 0);
2548	else
2549	val = 0;
2550	w = pThis->last_scr_width * ((pDrv->cBits + 7) >> 3);
2551	d = pDrv->pbData;
2552	if (pThis->fRenderVRAM)
2553	{
2554	for(i = 0; i < (int)pThis->last_scr_height; i++) {
2555	memset(d, val, w);
2556	d += cbScanline;
2557	}
2558	}
2559	pDrv->pfnUpdateRect(pDrv, 0, 0, pThis->last_scr_width, pThis->last_scr_height);
2560	}
2561
2562	static DECLCALLBACK(void) voidUpdateRect(PPDMIDISPLAYCONNECTOR pInterface, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
2563	{
2564	NOREF(pInterface); NOREF(x); NOREF(y); NOREF(cx); NOREF(cy);
2565	}
2566
2567
2568	#define GMODE_TEXT 0
2569	#define GMODE_GRAPH 1
2570	#define GMODE_BLANK 2
2571	#ifdef VBOX_WITH_VMSVGA
2572	#define GMODE_SVGA 3
2573	#endif
2574
2575	static int vga_update_display(PVGASTATE pThis, bool fUpdateAll, bool fFailOnResize, bool reset_dirty,
2576	PDMIDISPLAYCONNECTOR pDrv, int32_t pcur_graphic_mode)
2577	{
2578	int rc = VINF_SUCCESS;
2579	int graphic_mode;
2580
2581	if (pDrv->cBits == 0) {
2582	/* nothing to do */
2583	} else {
2584	switch(pDrv->cBits) {
2585	case 8:
2586	pThis->rgb_to_pixel = rgb_to_pixel8_dup;
2587	break;
2588	case 15:
2589	pThis->rgb_to_pixel = rgb_to_pixel15_dup;
2590	break;
2591	default:
2592	case 16:
2593	pThis->rgb_to_pixel = rgb_to_pixel16_dup;
2594	break;
2595	case 32:
2596	pThis->rgb_to_pixel = rgb_to_pixel32_dup;
2597	break;
2598	}
2599
2600	if (fUpdateAll) {
2601	/* A full update is requested. Special processing for a "blank" mode is required, because
2602	* the request must process all pending resolution changes.
2603	*
2604	* Appropriate vga_draw_graphic or vga_draw_text function, which checks the resolution change,
2605	* must be called even if the screen has been blanked, but then the function should do no actual
2606	* screen update. To do this, pfnUpdateRect is replaced with a nop.
2607	*/
2608	typedef DECLCALLBACK(void) FNUPDATERECT(PPDMIDISPLAYCONNECTOR pInterface, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy);
2609	typedef FNUPDATERECT *PFNUPDATERECT;
2610
2611	PFNUPDATERECT pfnUpdateRect = NULL;
2612
2613	/* Detect the "screen blank" conditions. */
2614	int fBlank = 0;
2615	if (!(pThis->ar_index & 0x20) \|\| (pThis->sr[0x01] & 0x20)) {
2616	fBlank = 1;
2617	}
2618
2619	if (fBlank) {
2620	/* Provide a void pfnUpdateRect callback. */
2621	if (pDrv) {
2622	pfnUpdateRect = pDrv->pfnUpdateRect;
2623	pDrv->pfnUpdateRect = voidUpdateRect;
2624	}
2625	}
2626
2627	/* Do a complete redraw, which will pick up a new screen resolution. */
2628	#ifdef VBOX_WITH_VMSVGA
2629	if (pThis->svga.fEnabled) {
2630	*pcur_graphic_mode = GMODE_SVGA;
2631	rc = vmsvga_draw_graphic(pThis, 1, fFailOnResize, reset_dirty, pDrv);
2632	}
2633	else
2634	#endif
2635	if (pThis->gr[6] & 1) {
2636	*pcur_graphic_mode = GMODE_GRAPH;
2637	rc = vga_draw_graphic(pThis, 1, fFailOnResize, reset_dirty, pDrv);
2638	} else {
2639	*pcur_graphic_mode = GMODE_TEXT;
2640	rc = vga_draw_text(pThis, 1, fFailOnResize, reset_dirty, pDrv);
2641	}
2642
2643	if (fBlank) {
2644	/* Set the current mode and restore the callback. */
2645	*pcur_graphic_mode = GMODE_BLANK;
2646	if (pDrv) {
2647	pDrv->pfnUpdateRect = pfnUpdateRect;
2648	}
2649	}
2650	return rc;
2651	}
2652
2653	#ifdef VBOX_WITH_VMSVGA
2654	if (pThis->svga.fEnabled) {
2655	graphic_mode = GMODE_SVGA;
2656	}
2657	else
2658	#endif
2659	if (!(pThis->ar_index & 0x20) \|\| (pThis->sr[0x01] & 0x20)) {
2660	graphic_mode = GMODE_BLANK;
2661	} else {
2662	graphic_mode = pThis->gr[6] & 1;
2663	}
2664	bool full_update = graphic_mode != *pcur_graphic_mode;
2665	if (full_update) {
2666	*pcur_graphic_mode = graphic_mode;
2667	}
2668	switch(graphic_mode) {
2669	case GMODE_TEXT:
2670	rc = vga_draw_text(pThis, full_update, fFailOnResize, reset_dirty, pDrv);
2671	break;
2672	case GMODE_GRAPH:
2673	rc = vga_draw_graphic(pThis, full_update, fFailOnResize, reset_dirty, pDrv);
2674	break;
2675	#ifdef VBOX_WITH_VMSVGA
2676	case GMODE_SVGA:
2677	rc = vmsvga_draw_graphic(pThis, full_update, fFailOnResize, reset_dirty, pDrv);
2678	break;
2679	#endif
2680	case GMODE_BLANK:
2681	default:
2682	vga_draw_blank(pThis, full_update, pDrv);
2683	break;
2684	}
2685	}
2686	return rc;
2687	}
2688
2689	static void vga_save(PSSMHANDLE pSSM, PVGASTATE pThis)
2690	{
2691	int i;
2692
2693	SSMR3PutU32(pSSM, pThis->latch);
2694	SSMR3PutU8(pSSM, pThis->sr_index);
2695	SSMR3PutMem(pSSM, pThis->sr, 8);
2696	SSMR3PutU8(pSSM, pThis->gr_index);
2697	SSMR3PutMem(pSSM, pThis->gr, 16);
2698	SSMR3PutU8(pSSM, pThis->ar_index);
2699	SSMR3PutMem(pSSM, pThis->ar, 21);
2700	SSMR3PutU32(pSSM, pThis->ar_flip_flop);
2701	SSMR3PutU8(pSSM, pThis->cr_index);
2702	SSMR3PutMem(pSSM, pThis->cr, 256);
2703	SSMR3PutU8(pSSM, pThis->msr);
2704	SSMR3PutU8(pSSM, pThis->fcr);
2705	SSMR3PutU8(pSSM, pThis->st00);
2706	SSMR3PutU8(pSSM, pThis->st01);
2707
2708	SSMR3PutU8(pSSM, pThis->dac_state);
2709	SSMR3PutU8(pSSM, pThis->dac_sub_index);
2710	SSMR3PutU8(pSSM, pThis->dac_read_index);
2711	SSMR3PutU8(pSSM, pThis->dac_write_index);
2712	SSMR3PutMem(pSSM, pThis->dac_cache, 3);
2713	SSMR3PutMem(pSSM, pThis->palette, 768);
2714
2715	SSMR3PutU32(pSSM, pThis->bank_offset);
2716	#ifdef CONFIG_BOCHS_VBE
2717	SSMR3PutU8(pSSM, 1);
2718	SSMR3PutU16(pSSM, pThis->vbe_index);
2719	for(i = 0; i < VBE_DISPI_INDEX_NB_SAVED; i++)
2720	SSMR3PutU16(pSSM, pThis->vbe_regs[i]);
2721	SSMR3PutU32(pSSM, pThis->vbe_start_addr);
2722	SSMR3PutU32(pSSM, pThis->vbe_line_offset);
2723	#else
2724	SSMR3PutU8(pSSM, 0);
2725	#endif
2726	}
2727
2728	static int vga_load(PSSMHANDLE pSSM, PVGASTATE pThis, int version_id)
2729	{
2730	int is_vbe, i;
2731	uint32_t u32Dummy;
2732	uint8_t u8;
2733
2734	SSMR3GetU32(pSSM, &pThis->latch);
2735	SSMR3GetU8(pSSM, &pThis->sr_index);
2736	SSMR3GetMem(pSSM, pThis->sr, 8);
2737	SSMR3GetU8(pSSM, &pThis->gr_index);
2738	SSMR3GetMem(pSSM, pThis->gr, 16);
2739	SSMR3GetU8(pSSM, &pThis->ar_index);
2740	SSMR3GetMem(pSSM, pThis->ar, 21);
2741	SSMR3GetU32(pSSM, (uint32_t *)&pThis->ar_flip_flop);
2742	SSMR3GetU8(pSSM, &pThis->cr_index);
2743	SSMR3GetMem(pSSM, pThis->cr, 256);
2744	SSMR3GetU8(pSSM, &pThis->msr);
2745	SSMR3GetU8(pSSM, &pThis->fcr);
2746	SSMR3GetU8(pSSM, &pThis->st00);
2747	SSMR3GetU8(pSSM, &pThis->st01);
2748
2749	SSMR3GetU8(pSSM, &pThis->dac_state);
2750	SSMR3GetU8(pSSM, &pThis->dac_sub_index);
2751	SSMR3GetU8(pSSM, &pThis->dac_read_index);
2752	SSMR3GetU8(pSSM, &pThis->dac_write_index);
2753	SSMR3GetMem(pSSM, pThis->dac_cache, 3);
2754	SSMR3GetMem(pSSM, pThis->palette, 768);
2755
2756	SSMR3GetU32(pSSM, (uint32_t *)&pThis->bank_offset);
2757	SSMR3GetU8(pSSM, &u8);
2758	is_vbe = !!u8;
2759	#ifdef CONFIG_BOCHS_VBE
2760	if (!is_vbe)
2761	{
2762	Log(("vga_load: !is_vbe !!\n"));
2763	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
2764	}
2765	SSMR3GetU16(pSSM, &pThis->vbe_index);
2766	for(i = 0; i < VBE_DISPI_INDEX_NB_SAVED; i++)
2767	SSMR3GetU16(pSSM, &pThis->vbe_regs[i]);
2768	if (version_id <= VGA_SAVEDSTATE_VERSION_INV_VHEIGHT)
2769	recalculate_data(pThis, false); /* <- re-calculate the pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_HEIGHT] since it might be invalid */
2770	SSMR3GetU32(pSSM, &pThis->vbe_start_addr);
2771	SSMR3GetU32(pSSM, &pThis->vbe_line_offset);
2772	if (version_id < 2)
2773	SSMR3GetU32(pSSM, &u32Dummy);
2774	pThis->vbe_bank_max = (pThis->vram_size >> 16) - 1;
2775	#else
2776	if (is_vbe)
2777	{
2778	Log(("vga_load: is_vbe !!\n"));
2779	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
2780	}
2781	#endif
2782
2783	/* force refresh */
2784	pThis->graphic_mode = -1;
2785	return 0;
2786	}
2787
2788	/* see vgaR3Construct */
2789	static void vga_init_expand(void)
2790	{
2791	int i, j, v, b;
2792
2793	for(i = 0;i < 256; i++) {
2794	v = 0;
2795	for(j = 0; j < 8; j++) {
2796	v \|= ((i >> j) & 1) << (j * 4);
2797	}
2798	expand4[i] = v;
2799
2800	v = 0;
2801	for(j = 0; j < 4; j++) {
2802	v \|= ((i >> (2 * j)) & 3) << (j * 4);
2803	}
2804	expand2[i] = v;
2805	}
2806	for(i = 0; i < 16; i++) {
2807	v = 0;
2808	for(j = 0; j < 4; j++) {
2809	b = ((i >> j) & 1);
2810	v \|= b << (2 * j);
2811	v \|= b << (2 * j + 1);
2812	}
2813	expand4to8[i] = v;
2814	}
2815	}
2816
2817	#endif /* !IN_RING0 */
2818
2819
2820
2821	/* -=-=-=-=-=- all contexts -=-=-=-=-=- */
2822
2823	/**
2824	* @callback_method_impl{FNIOMIOPORTOUT,Generic VGA OUT dispatcher.}
2825	*/
2826	PDMBOTHCBDECL(int) vgaIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
2827	{
2828	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
2829	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
2830
2831	NOREF(pvUser);
2832	if (cb == 1)
2833	vga_ioport_write(pThis, Port, u32);
2834	else if (cb == 2)
2835	{
2836	vga_ioport_write(pThis, Port, u32 & 0xff);
2837	vga_ioport_write(pThis, Port + 1, u32 >> 8);
2838	}
2839	return VINF_SUCCESS;
2840	}
2841
2842
2843	/**
2844	* @callback_method_impl{FNIOMIOPORTOUT,Generic VGA IN dispatcher.}
2845	*/
2846	PDMBOTHCBDECL(int) vgaIOPortRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
2847	{
2848	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
2849	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
2850	NOREF(pvUser);
2851
2852	int rc = VINF_SUCCESS;
2853	if (cb == 1)
2854	*pu32 = vga_ioport_read(pThis, Port);
2855	else if (cb == 2)
2856	*pu32 = vga_ioport_read(pThis, Port)
2857	\| (vga_ioport_read(pThis, Port + 1) << 8);
2858	else
2859	rc = VERR_IOM_IOPORT_UNUSED;
2860	return rc;
2861	}
2862
2863
2864	/**
2865	* @callback_method_impl{FNIOMIOPORTOUT,VBE Data Port OUT handler.}
2866	*/
2867	PDMBOTHCBDECL(int) vgaIOPortWriteVBEData(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
2868	{
2869	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
2870	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
2871
2872	NOREF(pvUser);
2873
2874	#ifndef IN_RING3
2875	/*
2876	* This has to be done on the host in order to execute the connector callbacks.
2877	*/
2878	if ( pThis->vbe_index == VBE_DISPI_INDEX_ENABLE
2879	\|\| pThis->vbe_index == VBE_DISPI_INDEX_VBOX_VIDEO)
2880	{
2881	Log(("vgaIOPortWriteVBEData: VBE_DISPI_INDEX_ENABLE - Switching to host...\n"));
2882	return VINF_IOM_R3_IOPORT_WRITE;
2883	}
2884	#endif
2885	#ifdef VBE_BYTEWISE_IO
2886	if (cb == 1)
2887	{
2888	if (!pThis->fWriteVBEData)
2889	{
2890	if ( (pThis->vbe_index == VBE_DISPI_INDEX_ENABLE)
2891	&& (u32 & VBE_DISPI_ENABLED))
2892	{
2893	pThis->fWriteVBEData = false;
2894	return vbe_ioport_write_data(pThis, Port, u32 & 0xFF);
2895	}
2896
2897	pThis->cbWriteVBEData = u32 & 0xFF;
2898	pThis->fWriteVBEData = true;
2899	return VINF_SUCCESS;
2900	}
2901
2902	u32 = (pThis->cbWriteVBEData << 8) \| (u32 & 0xFF);
2903	pThis->fWriteVBEData = false;
2904	cb = 2;
2905	}
2906	#endif
2907	if (cb == 2 \|\| cb == 4)
2908	{
2909	//#ifdef IN_RC
2910	// /*
2911	// * The VBE_DISPI_INDEX_ENABLE memsets the entire frame buffer.
2912	// * Since we're not mapping the entire framebuffer any longer that
2913	// * has to be done on the host.
2914	// */
2915	// if ( (pThis->vbe_index == VBE_DISPI_INDEX_ENABLE)
2916	// && (u32 & VBE_DISPI_ENABLED))
2917	// {
2918	// Log(("vgaIOPortWriteVBEData: VBE_DISPI_INDEX_ENABLE & VBE_DISPI_ENABLED - Switching to host...\n"));
2919	// return VINF_IOM_R3_IOPORT_WRITE;
2920	// }
2921	//#endif
2922	return vbe_ioport_write_data(pThis, Port, u32);
2923	}
2924	AssertMsgFailed(("vgaIOPortWriteVBEData: Port=%#x cb=%d u32=%#x\n", Port, cb, u32));
2925
2926	return VINF_SUCCESS;
2927	}
2928
2929
2930	/**
2931	* @callback_method_impl{FNIOMIOPORTOUT,VBE Index Port OUT handler.}
2932	*/
2933	PDMBOTHCBDECL(int) vgaIOPortWriteVBEIndex(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
2934	{
2935	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE); NOREF(pvUser);
2936	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
2937
2938	#ifdef VBE_BYTEWISE_IO
2939	if (cb == 1)
2940	{
2941	if (!pThis->fWriteVBEIndex)
2942	{
2943	pThis->cbWriteVBEIndex = u32 & 0x00FF;
2944	pThis->fWriteVBEIndex = true;
2945	return VINF_SUCCESS;
2946	}
2947	pThis->fWriteVBEIndex = false;
2948	vbe_ioport_write_index(pThis, Port, (pThis->cbWriteVBEIndex << 8) \| (u32 & 0x00FF));
2949	return VINF_SUCCESS;
2950	}
2951	#endif
2952
2953	if (cb == 2)
2954	vbe_ioport_write_index(pThis, Port, u32);
2955	else
2956	AssertMsgFailed(("vgaIOPortWriteVBEIndex: Port=%#x cb=%d u32=%#x\n", Port, cb, u32));
2957	return VINF_SUCCESS;
2958	}
2959
2960
2961	/**
2962	* @callback_method_impl{FNIOMIOPORTOUT,VBE Data Port IN handler.}
2963	*/
2964	PDMBOTHCBDECL(int) vgaIOPortReadVBEData(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
2965	{
2966	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE); NOREF(pvUser);
2967	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
2968
2969
2970	#ifdef VBE_BYTEWISE_IO
2971	if (cb == 1)
2972	{
2973	if (!pThis->fReadVBEData)
2974	{
2975	*pu32 = (vbe_ioport_read_data(pThis, Port) >> 8) & 0xFF;
2976	pThis->fReadVBEData = true;
2977	return VINF_SUCCESS;
2978	}
2979	*pu32 = vbe_ioport_read_data(pThis, Port) & 0xFF;
2980	pThis->fReadVBEData = false;
2981	return VINF_SUCCESS;
2982	}
2983	#endif
2984	if (cb == 2)
2985	{
2986	*pu32 = vbe_ioport_read_data(pThis, Port);
2987	return VINF_SUCCESS;
2988	}
2989	if (cb == 4)
2990	{
2991	/* Quick hack for getting the vram size. */
2992	*pu32 = pThis->vram_size;
2993	return VINF_SUCCESS;
2994	}
2995	AssertMsgFailed(("vgaIOPortReadVBEData: Port=%#x cb=%d\n", Port, cb));
2996	return VERR_IOM_IOPORT_UNUSED;
2997	}
2998
2999
3000	/**
3001	* @callback_method_impl{FNIOMIOPORTOUT,VBE Index Port IN handler.}
3002	*/
3003	PDMBOTHCBDECL(int) vgaIOPortReadVBEIndex(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
3004	{
3005	NOREF(pvUser);
3006	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3007	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
3008
3009	#ifdef VBE_BYTEWISE_IO
3010	if (cb == 1)
3011	{
3012	if (!pThis->fReadVBEIndex)
3013	{
3014	*pu32 = (vbe_ioport_read_index(pThis, Port) >> 8) & 0xFF;
3015	pThis->fReadVBEIndex = true;
3016	return VINF_SUCCESS;
3017	}
3018	*pu32 = vbe_ioport_read_index(pThis, Port) & 0xFF;
3019	pThis->fReadVBEIndex = false;
3020	return VINF_SUCCESS;
3021	}
3022	#endif
3023	if (cb == 2)
3024	{
3025	*pu32 = vbe_ioport_read_index(pThis, Port);
3026	return VINF_SUCCESS;
3027	}
3028	AssertMsgFailed(("vgaIOPortReadVBEIndex: Port=%#x cb=%d\n", Port, cb));
3029	return VERR_IOM_IOPORT_UNUSED;
3030	}
3031
3032	#ifdef VBOX_WITH_HGSMI
3033	# ifdef IN_RING3
3034	/**
3035	* @callback_method_impl{FNIOMIOPORTOUT,HGSMI OUT handler.}
3036	*/
3037	static DECLCALLBACK(int) vgaR3IOPortHGSMIWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
3038	{
3039	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3040	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
3041	LogFlowFunc(("Port 0x%x, u32 0x%x, cb %d\n", Port, u32, cb));
3042
3043
3044	NOREF(pvUser);
3045
3046	if (cb == 4)
3047	{
3048	switch (Port)
3049	{
3050	case VGA_PORT_HGSMI_HOST: /* Host */
3051	{
3052	# if defined(VBOX_WITH_VIDEOHWACCEL) \|\| defined(VBOX_WITH_VDMA) \|\| defined(VBOX_WITH_WDDM)
3053	if (u32 == HGSMIOFFSET_VOID)
3054	{
3055	PDMDevHlpPCISetIrq(pDevIns, 0, PDM_IRQ_LEVEL_LOW);
3056	HGSMIClearHostGuestFlags(pThis->pHGSMI,
3057	HGSMIHOSTFLAGS_IRQ
3058	# ifdef VBOX_VDMA_WITH_WATCHDOG
3059	\| HGSMIHOSTFLAGS_WATCHDOG
3060	# endif
3061	\| HGSMIHOSTFLAGS_VSYNC
3062	\| HGSMIHOSTFLAGS_HOTPLUG
3063	\| HGSMIHOSTFLAGS_CURSOR_CAPABILITIES
3064	);
3065	}
3066	else
3067	# endif
3068	{
3069	HGSMIHostWrite(pThis->pHGSMI, u32);
3070	}
3071	break;
3072	}
3073
3074	case VGA_PORT_HGSMI_GUEST: /* Guest */
3075	HGSMIGuestWrite(pThis->pHGSMI, u32);
3076	break;
3077
3078	default:
3079	# ifdef DEBUG_sunlover
3080	AssertMsgFailed(("vgaR3IOPortHGSMIWrite: Port=%#x cb=%d u32=%#x\n", Port, cb, u32));
3081	# endif
3082	break;
3083	}
3084	}
3085	else
3086	{
3087	# ifdef DEBUG_sunlover
3088	AssertMsgFailed(("vgaR3IOPortHGSMIWrite: Port=%#x cb=%d u32=%#x\n", Port, cb, u32));
3089	# endif
3090	}
3091
3092	return VINF_SUCCESS;
3093	}
3094
3095
3096	/**
3097	* @callback_method_impl{FNIOMIOPORTOUT,HGSMI IN handler.}
3098	*/
3099	static DECLCALLBACK(int) vgaR3IOPortHGSMIRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
3100	{
3101	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3102	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
3103	LogFlowFunc(("Port 0x%x, cb %d\n", Port, cb));
3104
3105	NOREF(pvUser);
3106
3107	int rc = VINF_SUCCESS;
3108	if (cb == 4)
3109	{
3110	switch (Port)
3111	{
3112	case VGA_PORT_HGSMI_HOST: /* Host */
3113	*pu32 = HGSMIHostRead(pThis->pHGSMI);
3114	break;
3115	case VGA_PORT_HGSMI_GUEST: /* Guest */
3116	*pu32 = HGSMIGuestRead(pThis->pHGSMI);
3117	break;
3118	default:
3119	# ifdef DEBUG_sunlover
3120	AssertMsgFailed(("vgaR3IOPortHGSMIRead: Port=%#x cb=%d\n", Port, cb));
3121	# endif
3122	rc = VERR_IOM_IOPORT_UNUSED;
3123	break;
3124	}
3125	}
3126	else
3127	{
3128	# ifdef DEBUG_sunlover
3129	Log(("vgaR3IOPortHGSMIRead: Port=%#x cb=%d\n", Port, cb));
3130	# endif
3131	rc = VERR_IOM_IOPORT_UNUSED;
3132	}
3133
3134	return rc;
3135	}
3136	# endif /* IN_RING3 */
3137	#endif /* VBOX_WITH_HGSMI */
3138
3139
3140
3141
3142	/* -=-=-=-=-=- Guest Context -=-=-=-=-=- */
3143
3144	/**
3145	* @internal. For use inside VGAGCMemoryFillWrite only.
3146	* Macro for apply logical operation and bit mask.
3147	*/
3148	#define APPLY_LOGICAL_AND_MASK(pThis, val, bit_mask) \
3149	/* apply logical operation */ \
3150	switch (pThis->gr[3] >> 3) \
3151	{ \
3152	case 0: \
3153	default: \
3154	/* nothing to do */ \
3155	break; \
3156	case 1: \
3157	/* and */ \
3158	val &= pThis->latch; \
3159	break; \
3160	case 2: \
3161	/* or */ \
3162	val \|= pThis->latch; \
3163	break; \
3164	case 3: \
3165	/* xor */ \
3166	val ^= pThis->latch; \
3167	break; \
3168	} \
3169	/* apply bit mask */ \
3170	val = (val & bit_mask) \| (pThis->latch & ~bit_mask)
3171
3172	/**
3173	* Legacy VGA memory (0xa0000 - 0xbffff) write hook, to be called from IOM and from the inside of VGADeviceGC.cpp.
3174	* This is the advanced version of vga_mem_writeb function.
3175	*
3176	* @returns VBox status code.
3177	* @param pThis VGA device structure
3178	* @param pvUser User argument - ignored.
3179	* @param GCPhysAddr Physical address of memory to write.
3180	* @param u32Item Data to write, up to 4 bytes.
3181	* @param cbItem Size of data Item, only 1/2/4 bytes is allowed for now.
3182	* @param cItems Number of data items to write.
3183	*/
3184	static int vgaInternalMMIOFill(PVGASTATE pThis, void *pvUser, RTGCPHYS GCPhysAddr, uint32_t u32Item, unsigned cbItem, unsigned cItems)
3185	{
3186	uint32_t b;
3187	uint32_t write_mask, bit_mask, set_mask;
3188	uint32_t aVal[4];
3189	unsigned i;
3190	NOREF(pvUser);
3191
3192	for (i = 0; i < cbItem; i++)
3193	{
3194	aVal[i] = u32Item & 0xff;
3195	u32Item >>= 8;
3196	}
3197
3198	/* convert to VGA memory offset */
3199	/// @todo add check for the end of region
3200	GCPhysAddr &= 0x1ffff;
3201	switch((pThis->gr[6] >> 2) & 3) {
3202	case 0:
3203	break;
3204	case 1:
3205	if (GCPhysAddr >= 0x10000)
3206	return VINF_SUCCESS;
3207	GCPhysAddr += pThis->bank_offset;
3208	break;
3209	case 2:
3210	GCPhysAddr -= 0x10000;
3211	if (GCPhysAddr >= 0x8000)
3212	return VINF_SUCCESS;
3213	break;
3214	default:
3215	case 3:
3216	GCPhysAddr -= 0x18000;
3217	if (GCPhysAddr >= 0x8000)
3218	return VINF_SUCCESS;
3219	break;
3220	}
3221
3222	if (pThis->sr[4] & 0x08) {
3223	/* chain 4 mode : simplest access */
3224	VERIFY_VRAM_WRITE_OFF_RETURN(pThis, GCPhysAddr + cItems * cbItem - 1);
3225
3226	while (cItems-- > 0)
3227	for (i = 0; i < cbItem; i++)
3228	{
3229	if (pThis->sr[2] & (1 << (GCPhysAddr & 3)))
3230	{
3231	pThis->CTX_SUFF(vram_ptr)[GCPhysAddr] = aVal[i];
3232	vga_set_dirty(pThis, GCPhysAddr);
3233	}
3234	GCPhysAddr++;
3235	}
3236	} else if (pThis->gr[5] & 0x10) {
3237	/* odd/even mode (aka text mode mapping) */
3238	VERIFY_VRAM_WRITE_OFF_RETURN(pThis, (GCPhysAddr + cItems * cbItem) * 4 - 1);
3239	while (cItems-- > 0)
3240	for (i = 0; i < cbItem; i++)
3241	{
3242	unsigned plane = (pThis->gr[4] & 2) \| (GCPhysAddr & 1);
3243	if (pThis->sr[2] & (1 << plane)) {
3244	RTGCPHYS PhysAddr2 = ((GCPhysAddr & ~1) << 2) \| plane;
3245	pThis->CTX_SUFF(vram_ptr)[PhysAddr2] = aVal[i];
3246	vga_set_dirty(pThis, PhysAddr2);
3247	}
3248	GCPhysAddr++;
3249	}
3250	} else {
3251	/* standard VGA latched access */
3252	VERIFY_VRAM_WRITE_OFF_RETURN(pThis, (GCPhysAddr + cItems * cbItem) * 4 - 1);
3253
3254	switch(pThis->gr[5] & 3) {
3255	default:
3256	case 0:
3257	/* rotate */
3258	b = pThis->gr[3] & 7;
3259	bit_mask = pThis->gr[8];
3260	bit_mask \|= bit_mask << 8;
3261	bit_mask \|= bit_mask << 16;
3262	set_mask = mask16[pThis->gr[1]];
3263
3264	for (i = 0; i < cbItem; i++)
3265	{
3266	aVal[i] = ((aVal[i] >> b) \| (aVal[i] << (8 - b))) & 0xff;
3267	aVal[i] \|= aVal[i] << 8;
3268	aVal[i] \|= aVal[i] << 16;
3269
3270	/* apply set/reset mask */
3271	aVal[i] = (aVal[i] & ~set_mask) \| (mask16[pThis->gr[0]] & set_mask);
3272
3273	APPLY_LOGICAL_AND_MASK(pThis, aVal[i], bit_mask);
3274	}
3275	break;
3276	case 1:
3277	for (i = 0; i < cbItem; i++)
3278	aVal[i] = pThis->latch;
3279	break;
3280	case 2:
3281	bit_mask = pThis->gr[8];
3282	bit_mask \|= bit_mask << 8;
3283	bit_mask \|= bit_mask << 16;
3284	for (i = 0; i < cbItem; i++)
3285	{
3286	aVal[i] = mask16[aVal[i] & 0x0f];
3287
3288	APPLY_LOGICAL_AND_MASK(pThis, aVal[i], bit_mask);
3289	}
3290	break;
3291	case 3:
3292	/* rotate */
3293	b = pThis->gr[3] & 7;
3294
3295	for (i = 0; i < cbItem; i++)
3296	{
3297	aVal[i] = (aVal[i] >> b) \| (aVal[i] << (8 - b));
3298	bit_mask = pThis->gr[8] & aVal[i];
3299	bit_mask \|= bit_mask << 8;
3300	bit_mask \|= bit_mask << 16;
3301	aVal[i] = mask16[pThis->gr[0]];
3302
3303	APPLY_LOGICAL_AND_MASK(pThis, aVal[i], bit_mask);
3304	}
3305	break;
3306	}
3307
3308	/* mask data according to sr[2] */
3309	write_mask = mask16[pThis->sr[2]];
3310
3311	/* actually write data */
3312	if (cbItem == 1)
3313	{
3314	/* The most frequently case is 1 byte I/O. */
3315	while (cItems-- > 0)
3316	{
3317	((uint32_t )pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t )pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) \| (aVal[0] & write_mask);
3318	vga_set_dirty(pThis, GCPhysAddr << 2);
3319	GCPhysAddr++;
3320	}
3321	}
3322	else if (cbItem == 2)
3323	{
3324	/* The second case is 2 bytes I/O. */
3325	while (cItems-- > 0)
3326	{
3327	((uint32_t )pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t )pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) \| (aVal[0] & write_mask);
3328	vga_set_dirty(pThis, GCPhysAddr << 2);
3329	GCPhysAddr++;
3330
3331	((uint32_t )pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t )pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) \| (aVal[1] & write_mask);
3332	vga_set_dirty(pThis, GCPhysAddr << 2);
3333	GCPhysAddr++;
3334	}
3335	}
3336	else
3337	{
3338	/* And the rest is 4 bytes. */
3339	Assert(cbItem == 4);
3340	while (cItems-- > 0)
3341	for (i = 0; i < cbItem; i++)
3342	{
3343	((uint32_t )pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t )pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) \| (aVal[i] & write_mask);
3344	vga_set_dirty(pThis, GCPhysAddr << 2);
3345	GCPhysAddr++;
3346	}
3347	}
3348	}
3349	return VINF_SUCCESS;
3350	}
3351
3352
3353	/**
3354	* @callback_method_impl{FNIOMMMIOFILL,
3355	* Legacy VGA memory (0xa0000 - 0xbffff) write hook\, to be called from IOM and
3356	* from the inside of VGADeviceGC.cpp. This is the advanced version of
3357	* vga_mem_writeb function.}
3358	*/
3359	PDMBOTHCBDECL(int) vgaMMIOFill(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS GCPhysAddr, uint32_t u32Item, unsigned cbItem, unsigned cItems)
3360	{
3361	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3362	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
3363
3364	return vgaInternalMMIOFill(pThis, pvUser, GCPhysAddr, u32Item, cbItem, cItems);
3365	}
3366	#undef APPLY_LOGICAL_AND_MASK
3367
3368
3369	/**
3370	* @callback_method_impl{FNIOMMMIOREAD, Legacy VGA memory (0xa0000 - 0xbffff)
3371	* read hook\, to be called from IOM.}
3372	*/
3373	PDMBOTHCBDECL(int) vgaMMIORead(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb)
3374	{
3375	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3376	STAM_PROFILE_START(&pThis->CTX_MID_Z(Stat,MemoryRead), a);
3377	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
3378	NOREF(pvUser);
3379
3380	int rc = VINF_SUCCESS;
3381	switch (cb)
3382	{
3383	case 1:
3384	(uint8_t )pv = vga_mem_readb(pThis, GCPhysAddr, &rc);
3385	break;
3386	case 2:
3387	(uint16_t )pv = vga_mem_readb(pThis, GCPhysAddr, &rc)
3388	\| (vga_mem_readb(pThis, GCPhysAddr + 1, &rc) << 8);
3389	break;
3390	case 4:
3391	(uint32_t )pv = vga_mem_readb(pThis, GCPhysAddr, &rc)
3392	\| (vga_mem_readb(pThis, GCPhysAddr + 1, &rc) << 8)
3393	\| (vga_mem_readb(pThis, GCPhysAddr + 2, &rc) << 16)
3394	\| (vga_mem_readb(pThis, GCPhysAddr + 3, &rc) << 24);
3395	break;
3396
3397	case 8:
3398	(uint64_t )pv = (uint64_t)vga_mem_readb(pThis, GCPhysAddr, &rc)
3399	\| ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 1, &rc) << 8)
3400	\| ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 2, &rc) << 16)
3401	\| ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 3, &rc) << 24)
3402	\| ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 4, &rc) << 32)
3403	\| ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 5, &rc) << 40)
3404	\| ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 6, &rc) << 48)
3405	\| ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 7, &rc) << 56);
3406	break;
3407
3408	default:
3409	{
3410	uint8_t pbData = (uint8_t )pv;
3411	while (cb-- > 0)
3412	{
3413	*pbData++ = vga_mem_readb(pThis, GCPhysAddr++, &rc);
3414	if (RT_UNLIKELY(rc != VINF_SUCCESS))
3415	break;
3416	}
3417	}
3418	}
3419
3420	STAM_PROFILE_STOP(&pThis->CTX_MID_Z(Stat,MemoryRead), a);
3421	return rc;
3422	}
3423
3424	/**
3425	* @callback_method_impl{FNIOMMMIOWRITE, Legacy VGA memory (0xa0000 - 0xbffff)
3426	* write hook\, to be called from IOM.}
3427	*/
3428	PDMBOTHCBDECL(int) vgaMMIOWrite(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void const pv, unsigned cb)
3429	{
3430	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3431	uint8_t const pbSrc = (uint8_t const )pv;
3432	NOREF(pvUser);
3433	STAM_PROFILE_START(&pThis->CTX_MID_Z(Stat,MemoryWrite), a);
3434	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
3435
3436	int rc;
3437	switch (cb)
3438	{
3439	case 1:
3440	rc = vga_mem_writeb(pThis, GCPhysAddr, *pbSrc);
3441	break;
3442	#if 1
3443	case 2:
3444	rc = vga_mem_writeb(pThis, GCPhysAddr + 0, pbSrc[0]);
3445	if (RT_LIKELY(rc == VINF_SUCCESS))
3446	rc = vga_mem_writeb(pThis, GCPhysAddr + 1, pbSrc[1]);
3447	break;
3448	case 4:
3449	rc = vga_mem_writeb(pThis, GCPhysAddr + 0, pbSrc[0]);
3450	if (RT_LIKELY(rc == VINF_SUCCESS))
3451	rc = vga_mem_writeb(pThis, GCPhysAddr + 1, pbSrc[1]);
3452	if (RT_LIKELY(rc == VINF_SUCCESS))
3453	rc = vga_mem_writeb(pThis, GCPhysAddr + 2, pbSrc[2]);
3454	if (RT_LIKELY(rc == VINF_SUCCESS))
3455	rc = vga_mem_writeb(pThis, GCPhysAddr + 3, pbSrc[3]);
3456	break;
3457	case 8:
3458	rc = vga_mem_writeb(pThis, GCPhysAddr + 0, pbSrc[0]);
3459	if (RT_LIKELY(rc == VINF_SUCCESS))
3460	rc = vga_mem_writeb(pThis, GCPhysAddr + 1, pbSrc[1]);
3461	if (RT_LIKELY(rc == VINF_SUCCESS))
3462	rc = vga_mem_writeb(pThis, GCPhysAddr + 2, pbSrc[2]);
3463	if (RT_LIKELY(rc == VINF_SUCCESS))
3464	rc = vga_mem_writeb(pThis, GCPhysAddr + 3, pbSrc[3]);
3465	if (RT_LIKELY(rc == VINF_SUCCESS))
3466	rc = vga_mem_writeb(pThis, GCPhysAddr + 4, pbSrc[4]);
3467	if (RT_LIKELY(rc == VINF_SUCCESS))
3468	rc = vga_mem_writeb(pThis, GCPhysAddr + 5, pbSrc[5]);
3469	if (RT_LIKELY(rc == VINF_SUCCESS))
3470	rc = vga_mem_writeb(pThis, GCPhysAddr + 6, pbSrc[6]);
3471	if (RT_LIKELY(rc == VINF_SUCCESS))
3472	rc = vga_mem_writeb(pThis, GCPhysAddr + 7, pbSrc[7]);
3473	break;
3474	#else
3475	case 2:
3476	rc = vgaMMIOFill(pDevIns, GCPhysAddr, (uint16_t )pv, 2, 1);
3477	break;
3478	case 4:
3479	rc = vgaMMIOFill(pDevIns, GCPhysAddr, (uint32_t )pv, 4, 1);
3480	break;
3481	case 8:
3482	rc = vgaMMIOFill(pDevIns, GCPhysAddr, (uint64_t )pv, 8, 1);
3483	break;
3484	#endif
3485	default:
3486	rc = VINF_SUCCESS;
3487	while (cb-- > 0 && rc == VINF_SUCCESS)
3488	rc = vga_mem_writeb(pThis, GCPhysAddr++, *pbSrc++);
3489	break;
3490
3491	}
3492	STAM_PROFILE_STOP(&pThis->CTX_MID_Z(Stat,MemoryWrite), a);
3493	return rc;
3494	}
3495
3496
3497	/**
3498	* Handle LFB access.
3499	* @returns VBox status code.
3500	* @param pVM VM handle.
3501	* @param pThis VGA device instance data.
3502	* @param GCPhys The access physical address.
3503	* @param GCPtr The access virtual address (only GC).
3504	*/
3505	static int vgaLFBAccess(PVM pVM, PVGASTATE pThis, RTGCPHYS GCPhys, RTGCPTR GCPtr)
3506	{
3507	int rc = PDMCritSectEnter(&pThis->CritSect, VINF_EM_RAW_EMULATE_INSTR);
3508	if (rc != VINF_SUCCESS)
3509	return rc;
3510
3511	/*
3512	* Set page dirty bit.
3513	*/
3514	vga_set_dirty(pThis, GCPhys - pThis->GCPhysVRAM);
3515	pThis->fLFBUpdated = true;
3516
3517	/*
3518	* Turn of the write handler for this particular page and make it R/W.
3519	* Then return telling the caller to restart the guest instruction.
3520	* ASSUME: the guest always maps video memory RW.
3521	*/
3522	rc = PGMHandlerPhysicalPageTempOff(pVM, pThis->GCPhysVRAM, GCPhys);
3523	if (RT_SUCCESS(rc))
3524	{
3525	#ifndef IN_RING3
3526	rc = PGMShwMakePageWritable(PDMDevHlpGetVMCPU(pThis->CTX_SUFF(pDevIns)), GCPtr,
3527	PGM_MK_PG_IS_MMIO2 \| PGM_MK_PG_IS_WRITE_FAULT);
3528	PDMCritSectLeave(&pThis->CritSect);
3529	AssertMsgReturn( rc == VINF_SUCCESS
3530	/* In the SMP case the page table might be removed while we wait for the PGM lock in the trap handler. */
3531	\|\| rc == VERR_PAGE_TABLE_NOT_PRESENT
3532	\|\| rc == VERR_PAGE_NOT_PRESENT,
3533	("PGMShwModifyPage -> GCPtr=%RGv rc=%d\n", GCPtr, rc),
3534	rc);
3535	#else /* IN_RING3 : We don't have any virtual page address of the access here. */
3536	PDMCritSectLeave(&pThis->CritSect);
3537	Assert(GCPtr == 0);
3538	#endif
3539	return VINF_SUCCESS;
3540	}
3541
3542	PDMCritSectLeave(&pThis->CritSect);
3543	AssertMsgFailed(("PGMHandlerPhysicalPageTempOff -> rc=%d\n", rc));
3544	return rc;
3545	}
3546
3547
3548	#ifndef IN_RING3
3549	/**
3550	* @callback_method_impl{FNPGMRCPHYSHANDLER, \#PF Handler for VBE LFB access.}
3551	*/
3552	PDMBOTHCBDECL(VBOXSTRICTRC) vgaLbfAccessPfHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
3553	RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
3554	{
3555	PVGASTATE pThis = (PVGASTATE)pvUser;
3556	AssertPtr(pThis);
3557	Assert(GCPhysFault >= pThis->GCPhysVRAM);
3558	AssertMsg(uErrorCode & X86_TRAP_PF_RW, ("uErrorCode=%#x\n", uErrorCode));
3559	NOREF(pRegFrame);
3560
3561	return vgaLFBAccess(pVM, pThis, GCPhysFault, pvFault);
3562	}
3563	#endif /* !IN_RING3 */
3564
3565
3566	/**
3567	* @callback_method_impl{FNPGMPHYSHANDLER,
3568	* VBE LFB write access handler for the dirty tracking.}
3569	*/
3570	PGM_ALL_CB_DECL(VBOXSTRICTRC) vgaLFBAccessHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void pvPhys, void pvBuf, size_t cbBuf,
3571	PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
3572	{
3573	PVGASTATE pThis = (PVGASTATE)pvUser;
3574	int rc;
3575	Assert(pThis);
3576	Assert(GCPhys >= pThis->GCPhysVRAM);
3577	NOREF(pVCpu); NOREF(pvPhys); NOREF(pvBuf); NOREF(cbBuf); NOREF(enmAccessType); NOREF(enmOrigin);
3578
3579	rc = vgaLFBAccess(pVM, pThis, GCPhys, 0);
3580	if (RT_SUCCESS(rc))
3581	return VINF_PGM_HANDLER_DO_DEFAULT;
3582	AssertMsg(rc <= VINF_SUCCESS, ("rc=%Rrc\n", rc));
3583	return rc;
3584	}
3585
3586
3587	/* -=-=-=-=-=- All rings: VGA BIOS I/Os -=-=-=-=-=- */
3588
3589	/**
3590	* @callback_method_impl{FNIOMIOPORTIN,
3591	* Port I/O Handler for VGA BIOS IN operations.}
3592	*/
3593	PDMBOTHCBDECL(int) vgaIOPortReadBIOS(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
3594	{
3595	NOREF(pDevIns);
3596	NOREF(pvUser);
3597	NOREF(Port);
3598	NOREF(pu32);
3599	NOREF(cb);
3600	return VERR_IOM_IOPORT_UNUSED;
3601	}
3602
3603	/**
3604	* @callback_method_impl{FNIOMIOPORTOUT,
3605	* Port I/O Handler for VGA BIOS IN operations.}
3606	*/
3607	PDMBOTHCBDECL(int) vgaIOPortWriteBIOS(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
3608	{
3609	static int lastWasNotNewline = 0; /* We are only called in a single-threaded way */
3610	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3611	NOREF(pvUser);
3612	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
3613
3614	/*
3615	* VGA BIOS char printing.
3616	*/
3617	if ( cb == 1
3618	&& Port == VBE_PRINTF_PORT)
3619	{
3620	#if 0
3621	switch (u32)
3622	{
3623	case '\r': Log(("vgabios: <return>\n")); break;
3624	case '\n': Log(("vgabios: <newline>\n")); break;
3625	case '\t': Log(("vgabios: <tab>\n")); break;
3626	default:
3627	Log(("vgabios: %c\n", u32));
3628	}
3629	#else
3630	if (lastWasNotNewline == 0)
3631	Log(("vgabios: "));
3632	if (u32 != '\r') /* return - is only sent in conjunction with '\n' */
3633	Log(("%c", u32));
3634	if (u32 == '\n')
3635	lastWasNotNewline = 0;
3636	else
3637	lastWasNotNewline = 1;
3638	#endif
3639	return VINF_SUCCESS;
3640	}
3641
3642	/* not in use. */
3643	return VERR_IOM_IOPORT_UNUSED;
3644	}
3645
3646
3647	/* -=-=-=-=-=- Ring 3 -=-=-=-=-=- */
3648
3649	#ifdef IN_RING3
3650
3651	# ifdef VBE_NEW_DYN_LIST
3652	/**
3653	* @callback_method_impl{FNIOMIOPORTOUT,
3654	* Port I/O Handler for VBE Extra OUT operations.}
3655	*/
3656	PDMBOTHCBDECL(int) vbeIOPortWriteVBEExtra(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
3657	{
3658	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3659	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
3660	NOREF(pvUser); NOREF(Port);
3661
3662	if (cb == 2)
3663	{
3664	Log(("vbeIOPortWriteVBEExtra: addr=%#RX32\n", u32));
3665	pThis->u16VBEExtraAddress = u32;
3666	}
3667	else
3668	Log(("vbeIOPortWriteVBEExtra: Ignoring invalid cb=%d writes to the VBE Extra port!!!\n", cb));
3669
3670	return VINF_SUCCESS;
3671	}
3672
3673
3674	/**
3675	* @callback_method_impl{FNIOMIOPORTIN,
3676	* Port I/O Handler for VBE Extra IN operations.}
3677	*/
3678	PDMBOTHCBDECL(int) vbeIOPortReadVBEExtra(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
3679	{
3680	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3681	NOREF(pvUser); NOREF(Port);
3682	Assert(PDMCritSectIsOwner(pDevIns->CTX_SUFF(pCritSectRo)));
3683
3684	int rc = VINF_SUCCESS;
3685	if (pThis->u16VBEExtraAddress == 0xffff)
3686	{
3687	Log(("vbeIOPortReadVBEExtra: Requested number of 64k video banks\n"));
3688	*pu32 = pThis->vram_size / _64K;
3689	}
3690	else if ( pThis->u16VBEExtraAddress >= pThis->cbVBEExtraData
3691	\|\| pThis->u16VBEExtraAddress + cb > pThis->cbVBEExtraData)
3692	{
3693	*pu32 = 0;
3694	Log(("vbeIOPortReadVBEExtra: Requested address is out of VBE data!!! Address=%#x(%d) cbVBEExtraData=%#x(%d)\n",
3695	pThis->u16VBEExtraAddress, pThis->u16VBEExtraAddress, pThis->cbVBEExtraData, pThis->cbVBEExtraData));
3696	}
3697	else if (cb == 1)
3698	{
3699	*pu32 = pThis->pbVBEExtraData[pThis->u16VBEExtraAddress] & 0xFF;
3700
3701	Log(("vbeIOPortReadVBEExtra: cb=%#x %.*Rhxs\n", cb, cb, pu32));
3702	}
3703	else if (cb == 2)
3704	{
3705	*pu32 = pThis->pbVBEExtraData[pThis->u16VBEExtraAddress]
3706	\| (uint32_t)pThis->pbVBEExtraData[pThis->u16VBEExtraAddress + 1] << 8;
3707
3708	Log(("vbeIOPortReadVBEExtra: cb=%#x %.*Rhxs\n", cb, cb, pu32));
3709	}
3710	else
3711	{
3712	Log(("vbeIOPortReadVBEExtra: Invalid cb=%d read from the VBE Extra port!!!\n", cb));
3713	rc = VERR_IOM_IOPORT_UNUSED;
3714	}
3715
3716	return rc;
3717	}
3718	# endif /* VBE_NEW_DYN_LIST */
3719
3720
3721	/**
3722	* Parse the logo bitmap data at init time.
3723	*
3724	* @returns VBox status code.
3725	*
3726	* @param pThis The VGA instance data.
3727	*/
3728	static int vbeParseBitmap(PVGASTATE pThis)
3729	{
3730	uint16_t i;
3731	PBMPINFO bmpInfo;
3732	POS2HDR pOs2Hdr;
3733	POS22HDR pOs22Hdr;
3734	PWINHDR pWinHdr;
3735
3736	/*
3737	* Get bitmap header data
3738	*/
3739	bmpInfo = (PBMPINFO)(pThis->pbLogo + sizeof(LOGOHDR));
3740	pWinHdr = (PWINHDR)(pThis->pbLogo + sizeof(LOGOHDR) + sizeof(BMPINFO));
3741
3742	if (bmpInfo->Type == BMP_ID)
3743	{
3744	switch (pWinHdr->Size)
3745	{
3746	case BMP_HEADER_OS21:
3747	pOs2Hdr = (POS2HDR)pWinHdr;
3748	pThis->cxLogo = pOs2Hdr->Width;
3749	pThis->cyLogo = pOs2Hdr->Height;
3750	pThis->cLogoPlanes = pOs2Hdr->Planes;
3751	pThis->cLogoBits = pOs2Hdr->BitCount;
3752	pThis->LogoCompression = BMP_COMPRESS_NONE;
3753	pThis->cLogoUsedColors = 0;
3754	break;
3755
3756	case BMP_HEADER_OS22:
3757	pOs22Hdr = (POS22HDR)pWinHdr;
3758	pThis->cxLogo = pOs22Hdr->Width;
3759	pThis->cyLogo = pOs22Hdr->Height;
3760	pThis->cLogoPlanes = pOs22Hdr->Planes;
3761	pThis->cLogoBits = pOs22Hdr->BitCount;
3762	pThis->LogoCompression = pOs22Hdr->Compression;
3763	pThis->cLogoUsedColors = pOs22Hdr->ClrUsed;
3764	break;
3765
3766	case BMP_HEADER_WIN3:
3767	pThis->cxLogo = pWinHdr->Width;
3768	pThis->cyLogo = pWinHdr->Height;
3769	pThis->cLogoPlanes = pWinHdr->Planes;
3770	pThis->cLogoBits = pWinHdr->BitCount;
3771	pThis->LogoCompression = pWinHdr->Compression;
3772	pThis->cLogoUsedColors = pWinHdr->ClrUsed;
3773	break;
3774
3775	default:
3776	AssertLogRelMsgFailedReturn(("Unsupported bitmap header size %u.\n", pWinHdr->Size),
3777	VERR_INVALID_PARAMETER);
3778	break;
3779	}
3780
3781	AssertLogRelMsgReturn(pThis->cxLogo <= LOGO_MAX_WIDTH && pThis->cyLogo <= LOGO_MAX_HEIGHT,
3782	("Bitmap %ux%u is too big.\n", pThis->cxLogo, pThis->cyLogo),
3783	VERR_INVALID_PARAMETER);
3784
3785	AssertLogRelMsgReturn(pThis->cLogoPlanes == 1,
3786	("Bitmap planes %u != 1.\n", pThis->cLogoPlanes),
3787	VERR_INVALID_PARAMETER);
3788
3789	AssertLogRelMsgReturn(pThis->cLogoBits == 4 \|\| pThis->cLogoBits == 8 \|\| pThis->cLogoBits == 24,
3790	("Unsupported %u depth.\n", pThis->cLogoBits),
3791	VERR_INVALID_PARAMETER);
3792
3793	AssertLogRelMsgReturn(pThis->cLogoUsedColors <= 256,
3794	("Unsupported %u colors.\n", pThis->cLogoUsedColors),
3795	VERR_INVALID_PARAMETER);
3796
3797	AssertLogRelMsgReturn(pThis->LogoCompression == BMP_COMPRESS_NONE,
3798	("Unsupported %u compression.\n", pThis->LogoCompression),
3799	VERR_INVALID_PARAMETER);
3800
3801	/*
3802	* Read bitmap palette
3803	*/
3804	if (!pThis->cLogoUsedColors)
3805	pThis->cLogoPalEntries = 1 << (pThis->cLogoPlanes * pThis->cLogoBits);
3806	else
3807	pThis->cLogoPalEntries = pThis->cLogoUsedColors;
3808
3809	if (pThis->cLogoPalEntries)
3810	{
3811	const uint8_t pbPal = pThis->pbLogo + sizeof(LOGOHDR) + sizeof(BMPINFO) + pWinHdr->Size; / ASSUMES Size location (safe) */
3812
3813	for (i = 0; i < pThis->cLogoPalEntries; i++)
3814	{
3815	uint16_t j;
3816	uint32_t u32Pal = 0;
3817
3818	for (j = 0; j < 3; j++)
3819	{
3820	uint8_t b = *pbPal++;
3821	u32Pal <<= 8;
3822	u32Pal \|= b;
3823	}
3824
3825	pbPal++; /* skip unused byte */
3826	pThis->au32LogoPalette[i] = u32Pal;
3827	}
3828	}
3829
3830	/*
3831	* Bitmap data offset
3832	*/
3833	pThis->pbLogoBitmap = pThis->pbLogo + sizeof(LOGOHDR) + bmpInfo->Offset;
3834	}
3835	else
3836	AssertLogRelMsgFailedReturn(("Not a BMP file.\n"), VERR_INVALID_PARAMETER);
3837
3838	return VINF_SUCCESS;
3839	}
3840
3841
3842	/**
3843	* Show logo bitmap data.
3844	*
3845	* @returns VBox status code.
3846	*
3847	* @param cbDepth Logo depth.
3848	* @param xLogo Logo X position.
3849	* @param yLogo Logo Y position.
3850	* @param cxLogo Logo width.
3851	* @param cyLogo Logo height.
3852	* @param iStep Fade in/fade out step.
3853	* @param pu32Palette Palette data.
3854	* @param pbSrc Source buffer.
3855	* @param pbDst Destination buffer.
3856	*/
3857	static void vbeShowBitmap(uint16_t cBits, uint16_t xLogo, uint16_t yLogo, uint16_t cxLogo, uint16_t cyLogo, uint8_t iStep,
3858	const uint32_t pu32Palette, const uint8_t pbSrc, uint8_t *pbDst)
3859	{
3860	uint16_t i;
3861	size_t cbPadBytes = 0;
3862	size_t cbLineDst = LOGO_MAX_WIDTH * 4;
3863	uint16_t cyLeft = cyLogo;
3864
3865	pbDst += xLogo * 4 + yLogo * cbLineDst;
3866
3867	switch (cBits)
3868	{
3869	case 1:
3870	pbDst += cyLogo * cbLineDst;
3871	cbPadBytes = 0;
3872	break;
3873
3874	case 4:
3875	if (((cxLogo % 8) == 0) \|\| ((cxLogo % 8) > 6))
3876	cbPadBytes = 0;
3877	else if ((cxLogo % 8) <= 2)
3878	cbPadBytes = 3;
3879	else if ((cxLogo % 8) <= 4)
3880	cbPadBytes = 2;
3881	else
3882	cbPadBytes = 1;
3883	break;
3884
3885	case 8:
3886	cbPadBytes = ((cxLogo % 4) == 0) ? 0 : (4 - (cxLogo % 4));
3887	break;
3888
3889	case 24:
3890	cbPadBytes = cxLogo % 4;
3891	break;
3892	}
3893
3894	uint8_t j = 0, c = 0;
3895
3896	while (cyLeft-- > 0)
3897	{
3898	uint8_t *pbTmpDst = pbDst;
3899
3900	if (cBits != 1)
3901	j = 0;
3902
3903	for (i = 0; i < cxLogo; i++)
3904	{
3905	uint8_t pix;
3906
3907	switch (cBits)
3908	{
3909	case 1:
3910	{
3911	if (!j)
3912	c = *pbSrc++;
3913
3914	pix = (c & 1) ? 0xFF : 0;
3915	c >>= 1;
3916
3917	if (pix)
3918	{
3919	pbTmpDst++ = pix iStep / LOGO_SHOW_STEPS;
3920	pbTmpDst++ = pix iStep / LOGO_SHOW_STEPS;
3921	pbTmpDst++ = pix iStep / LOGO_SHOW_STEPS;
3922	pbTmpDst++;
3923	}
3924	else
3925	pbTmpDst += 4;
3926
3927	j = (j + 1) % 8;
3928	break;
3929	}
3930
3931	case 4:
3932	{
3933	if (!j)
3934	c = *pbSrc++;
3935
3936	pix = (c >> 4) & 0xF;
3937	c <<= 4;
3938
3939	uint32_t u32Pal = pu32Palette[pix];
3940
3941	pix = (u32Pal >> 16) & 0xFF;
3942	pbTmpDst++ = pix iStep / LOGO_SHOW_STEPS;
3943	pix = (u32Pal >> 8) & 0xFF;
3944	pbTmpDst++ = pix iStep / LOGO_SHOW_STEPS;
3945	pix = u32Pal & 0xFF;
3946	pbTmpDst++ = pix iStep / LOGO_SHOW_STEPS;
3947	pbTmpDst++;
3948
3949	j = (j + 1) % 2;
3950	break;
3951	}
3952
3953	case 8:
3954	{
3955	uint32_t u32Pal = pu32Palette[*pbSrc++];
3956
3957	pix = (u32Pal >> 16) & 0xFF;
3958	pbTmpDst++ = pix iStep / LOGO_SHOW_STEPS;
3959	pix = (u32Pal >> 8) & 0xFF;
3960	pbTmpDst++ = pix iStep / LOGO_SHOW_STEPS;
3961	pix = u32Pal & 0xFF;
3962	pbTmpDst++ = pix iStep / LOGO_SHOW_STEPS;
3963	pbTmpDst++;
3964	break;
3965	}
3966
3967	case 24:
3968	pbTmpDst++ = pbSrc++ * iStep / LOGO_SHOW_STEPS;
3969	pbTmpDst++ = pbSrc++ * iStep / LOGO_SHOW_STEPS;
3970	pbTmpDst++ = pbSrc++ * iStep / LOGO_SHOW_STEPS;
3971	pbTmpDst++;
3972	break;
3973	}
3974	}
3975
3976	pbDst -= cbLineDst;
3977	pbSrc += cbPadBytes;
3978	}
3979	}
3980
3981
3982	/**
3983	* @callback_method_impl{FNIOMIOPORTOUT,
3984	* Port I/O Handler for BIOS Logo OUT operations.}
3985	*/
3986	PDMBOTHCBDECL(int) vbeIOPortWriteCMDLogo(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
3987	{
3988	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
3989	NOREF(pvUser);
3990	NOREF(Port);
3991
3992	Log(("vbeIOPortWriteCMDLogo: cb=%d u32=%#04x(%#04d) (byte)\n", cb, u32, u32));
3993
3994	if (cb == 2)
3995	{
3996	/* Get the logo command */
3997	switch (u32 & 0xFF00)
3998	{
3999	case LOGO_CMD_SET_OFFSET:
4000	pThis->offLogoData = u32 & 0xFF;
4001	break;
4002
4003	case LOGO_CMD_SHOW_BMP:
4004	{
4005	uint8_t iStep = u32 & 0xFF;
4006	const uint8_t *pbSrc = pThis->pbLogoBitmap;
4007	uint8_t *pbDst;
4008	PCLOGOHDR pLogoHdr = (PCLOGOHDR)pThis->pbLogo;
4009	uint32_t offDirty = 0;
4010	uint16_t xLogo = (LOGO_MAX_WIDTH - pThis->cxLogo) / 2;
4011	uint16_t yLogo = LOGO_MAX_HEIGHT - (LOGO_MAX_HEIGHT - pThis->cyLogo) / 2;
4012
4013	/* Check VRAM size */
4014	if (pThis->vram_size < LOGO_MAX_SIZE)
4015	break;
4016
4017	if (pThis->vram_size >= LOGO_MAX_SIZE * 2)
4018	pbDst = pThis->vram_ptrR3 + LOGO_MAX_SIZE;
4019	else
4020	pbDst = pThis->vram_ptrR3;
4021
4022	/* Clear screen - except on power on... */
4023	if (!pThis->fLogoClearScreen)
4024	{
4025	/* Clear vram */
4026	uint32_t pu32Dst = (uint32_t )pbDst;
4027	for (int i = 0; i < LOGO_MAX_WIDTH; i++)
4028	for (int j = 0; j < LOGO_MAX_HEIGHT; j++)
4029	*pu32Dst++ = 0;
4030	pThis->fLogoClearScreen = true;
4031	}
4032
4033	/* Show the bitmap. */
4034	vbeShowBitmap(pThis->cLogoBits, xLogo, yLogo,
4035	pThis->cxLogo, pThis->cyLogo,
4036	iStep, &pThis->au32LogoPalette[0],
4037	pbSrc, pbDst);
4038
4039	/* Show the 'Press F12...' text. */
4040	if (pLogoHdr->fu8ShowBootMenu == 2)
4041	vbeShowBitmap(1, LOGO_F12TEXT_X, LOGO_F12TEXT_Y,
4042	LOGO_F12TEXT_WIDTH, LOGO_F12TEXT_HEIGHT,
4043	iStep, &pThis->au32LogoPalette[0],
4044	&g_abLogoF12BootText[0], pbDst);
4045
4046	/* Blit the offscreen buffer. */
4047	if (pThis->vram_size >= LOGO_MAX_SIZE * 2)
4048	{
4049	uint32_t pu32TmpDst = (uint32_t )pThis->vram_ptrR3;
4050	uint32_t pu32TmpSrc = (uint32_t )(pThis->vram_ptrR3 + LOGO_MAX_SIZE);
4051	for (int i = 0; i < LOGO_MAX_WIDTH; i++)
4052	{
4053	for (int j = 0; j < LOGO_MAX_HEIGHT; j++)
4054	pu32TmpDst++ = pu32TmpSrc++;
4055	}
4056	}
4057
4058	/* Set the dirty flags. */
4059	while (offDirty <= LOGO_MAX_SIZE)
4060	{
4061	vga_set_dirty(pThis, offDirty);
4062	offDirty += PAGE_SIZE;
4063	}
4064	break;
4065	}
4066
4067	default:
4068	Log(("vbeIOPortWriteCMDLogo: invalid command %d\n", u32));
4069	pThis->LogoCommand = LOGO_CMD_NOP;
4070	break;
4071	}
4072
4073	return VINF_SUCCESS;
4074	}
4075
4076	Log(("vbeIOPortWriteCMDLogo: Ignoring invalid cb=%d writes to the VBE Extra port!!!\n", cb));
4077	return VINF_SUCCESS;
4078	}
4079
4080
4081	/**
4082	* @callback_method_impl{FNIOMIOPORTIN,
4083	* Port I/O Handler for BIOS Logo IN operations.}
4084	*/
4085	PDMBOTHCBDECL(int) vbeIOPortReadCMDLogo(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
4086	{
4087	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4088	NOREF(pvUser);
4089	NOREF(Port);
4090
4091
4092	if (pThis->offLogoData + cb > pThis->cbLogo)
4093	{
4094	Log(("vbeIOPortReadCMDLogo: Requested address is out of Logo data!!! offLogoData=%#x(%d) cbLogo=%#x(%d)\n",
4095	pThis->offLogoData, pThis->offLogoData, pThis->cbLogo, pThis->cbLogo));
4096	return VINF_SUCCESS;
4097	}
4098
4099	PCRTUINT64U p = (PCRTUINT64U)&pThis->pbLogo[pThis->offLogoData];
4100	switch (cb)
4101	{
4102	case 1: *pu32 = p->au8[0]; break;
4103	case 2: *pu32 = p->au16[0]; break;
4104	case 4: *pu32 = p->au32[0]; break;
4105	//case 8: *pu32 = p->au64[0]; break;
4106	default: AssertFailed(); break;
4107	}
4108	Log(("vbeIOPortReadCMDLogo: LogoOffset=%#x(%d) cb=%#x %.*Rhxs\n", pThis->offLogoData, pThis->offLogoData, cb, cb, pu32));
4109
4110	pThis->LogoCommand = LOGO_CMD_NOP;
4111	pThis->offLogoData += cb;
4112
4113	return VINF_SUCCESS;
4114	}
4115
4116
4117	/* -=-=-=-=-=- Ring 3: Debug Info Handlers -=-=-=-=-=- */
4118
4119	/**
4120	* @callback_method_impl{FNDBGFHANDLERDEV,
4121	* Dumps several interesting bits of the VGA state that are difficult to
4122	* decode from the registers.}
4123	*/
4124	static DECLCALLBACK(void) vgaInfoState(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
4125	{
4126	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4127	int is_graph, double_scan;
4128	int w, h, char_height, char_dots;
4129	int val, vfreq_hz, hfreq_hz;
4130	vga_retrace_s *r = &pThis->retrace_state;
4131	const char *clocks[] = { "25.175 MHz", "28.322 MHz", "External", "Reserved?!" };
4132	NOREF(pszArgs);
4133
4134	is_graph = pThis->gr[6] & 1;
4135	char_dots = (pThis->sr[0x01] & 1) ? 8 : 9;
4136	double_scan = pThis->cr[9] >> 7;
4137	pHlp->pfnPrintf(pHlp, "pixel clock: %s\n", clocks[(pThis->msr >> 2) & 3]);
4138	pHlp->pfnPrintf(pHlp, "double scanning %s\n", double_scan ? "on" : "off");
4139	pHlp->pfnPrintf(pHlp, "double clocking %s\n", pThis->sr[1] & 0x08 ? "on" : "off");
4140	val = pThis->cr[0] + 5;
4141	pHlp->pfnPrintf(pHlp, "htotal: %d px (%d cclk)\n", val * char_dots, val);
4142	val = pThis->cr[6] + ((pThis->cr[7] & 1) << 8) + ((pThis->cr[7] & 0x20) << 4) + 2;
4143	pHlp->pfnPrintf(pHlp, "vtotal: %d px\n", val);
4144	val = pThis->cr[1] + 1;
4145	w = val * char_dots;
4146	pHlp->pfnPrintf(pHlp, "hdisp : %d px (%d cclk)\n", w, val);
4147	val = pThis->cr[0x12] + ((pThis->cr[7] & 2) << 7) + ((pThis->cr[7] & 0x40) << 4) + 1;
4148	h = val;
4149	pHlp->pfnPrintf(pHlp, "vdisp : %d px\n", val);
4150	val = ((pThis->cr[9] & 0x40) << 3) + ((pThis->cr[7] & 0x10) << 4) + pThis->cr[0x18];
4151	pHlp->pfnPrintf(pHlp, "split : %d ln\n", val);
4152	val = (pThis->cr[0xc] << 8) + pThis->cr[0xd];
4153	pHlp->pfnPrintf(pHlp, "start : %#x\n", val);
4154	if (!is_graph)
4155	{
4156	val = (pThis->cr[9] & 0x1f) + 1;
4157	char_height = val;
4158	pHlp->pfnPrintf(pHlp, "char height %d\n", val);
4159	pHlp->pfnPrintf(pHlp, "text mode %dx%d\n", w / char_dots, h / (char_height << double_scan));
4160
4161	uint32_t cbLine;
4162	uint32_t offStart;
4163	uint32_t uLineCompareIgn;
4164	vga_get_offsets(pThis, &cbLine, &offStart, &uLineCompareIgn);
4165	if (!cbLine)
4166	cbLine = 80 * 8;
4167	offStart *= 8;
4168	pHlp->pfnPrintf(pHlp, "cbLine: %#x\n", cbLine);
4169	pHlp->pfnPrintf(pHlp, "offStart: %#x (line %#x)\n", offStart, offStart / cbLine);
4170	}
4171	if (pThis->fRealRetrace)
4172	{
4173	val = r->hb_start;
4174	pHlp->pfnPrintf(pHlp, "hblank start: %d px (%d cclk)\n", val * char_dots, val);
4175	val = r->hb_end;
4176	pHlp->pfnPrintf(pHlp, "hblank end : %d px (%d cclk)\n", val * char_dots, val);
4177	pHlp->pfnPrintf(pHlp, "vblank start: %d px, end: %d px\n", r->vb_start, r->vb_end);
4178	pHlp->pfnPrintf(pHlp, "vsync start : %d px, end: %d px\n", r->vs_start, r->vs_end);
4179	pHlp->pfnPrintf(pHlp, "cclks per frame: %d\n", r->frame_cclks);
4180	pHlp->pfnPrintf(pHlp, "cclk time (ns) : %d\n", r->cclk_ns);
4181	if (r->frame_ns && r->h_total_ns) /* Careful in case state is temporarily invalid. */
4182	{
4183	vfreq_hz = 1000000000 / r->frame_ns;
4184	hfreq_hz = 1000000000 / r->h_total_ns;
4185	pHlp->pfnPrintf(pHlp, "vfreq: %d Hz, hfreq: %d.%03d kHz\n",
4186	vfreq_hz, hfreq_hz / 1000, hfreq_hz % 1000);
4187	}
4188	}
4189	pHlp->pfnPrintf(pHlp, "display refresh interval: %u ms\n", pThis->cMilliesRefreshInterval);
4190
4191	#ifdef VBOX_WITH_VMSVGA
4192	if (pThis->svga.fEnabled)
4193	pHlp->pfnPrintf(pHlp, pThis->svga.f3DEnabled ? "VMSVGA 3D enabled: %ux%ux%u\n" : "VMSVGA enabled: %ux%ux%u",
4194	pThis->svga.uWidth, pThis->svga.uHeight, pThis->svga.uBpp);
4195	#endif
4196	}
4197
4198
4199	/**
4200	* Prints a separator line.
4201	*
4202	* @param pHlp Callback functions for doing output.
4203	* @param cCols The number of columns.
4204	* @param pszTitle The title text, NULL if none.
4205	*/
4206	static void vgaInfoTextPrintSeparatorLine(PCDBGFINFOHLP pHlp, size_t cCols, const char *pszTitle)
4207	{
4208	if (pszTitle)
4209	{
4210	size_t cchTitle = strlen(pszTitle);
4211	if (cchTitle + 6 >= cCols)
4212	{
4213	pHlp->pfnPrintf(pHlp, "-- %s --", pszTitle);
4214	cCols = 0;
4215	}
4216	else
4217	{
4218	size_t cchLeft = (cCols - cchTitle - 2) / 2;
4219	cCols -= cchLeft + cchTitle + 2;
4220	while (cchLeft-- > 0)
4221	pHlp->pfnPrintf(pHlp, "-");
4222	pHlp->pfnPrintf(pHlp, " %s ", pszTitle);
4223	}
4224	}
4225
4226	while (cCols-- > 0)
4227	pHlp->pfnPrintf(pHlp, "-");
4228	pHlp->pfnPrintf(pHlp, "\n");
4229	}
4230
4231
4232	/**
4233	* Worker for vgaInfoText.
4234	*
4235	* @param pThis The vga state.
4236	* @param pHlp Callback functions for doing output.
4237	* @param offStart Where to start dumping (relative to the VRAM).
4238	* @param cbLine The source line length (aka line_offset).
4239	* @param cCols The number of columns on the screen.
4240	* @param cRows The number of rows to dump.
4241	* @param iScrBegin The row at which the current screen output starts.
4242	* @param iScrEnd The row at which the current screen output end
4243	* (exclusive).
4244	*/
4245	static void vgaInfoTextWorker(PVGASTATE pThis, PCDBGFINFOHLP pHlp,
4246	uint32_t offStart, uint32_t cbLine,
4247	uint32_t cCols, uint32_t cRows,
4248	uint32_t iScrBegin, uint32_t iScrEnd)
4249	{
4250	/* Title, */
4251	char szTitle[32];
4252	if (iScrBegin \|\| iScrEnd < cRows)
4253	RTStrPrintf(szTitle, sizeof(szTitle), "%ux%u (+%u before, +%u after)",
4254	cCols, iScrEnd - iScrBegin, iScrBegin, cRows - iScrEnd);
4255	else
4256	RTStrPrintf(szTitle, sizeof(szTitle), "%ux%u", cCols, iScrEnd - iScrBegin);
4257
4258	/* Do the dumping. */
4259	uint8_t const *pbSrcOuter = pThis->CTX_SUFF(vram_ptr) + offStart;
4260	uint32_t iRow;
4261	for (iRow = 0; iRow < cRows; iRow++, pbSrcOuter += cbLine)
4262	{
4263	if ((uintptr_t)(pbSrcOuter + cbLine - pThis->CTX_SUFF(vram_ptr)) > pThis->vram_size) {
4264	pHlp->pfnPrintf(pHlp, "The last %u row/rows is/are outside the VRAM.\n", cRows - iRow);
4265	break;
4266	}
4267
4268	if (iRow == 0)
4269	vgaInfoTextPrintSeparatorLine(pHlp, cCols, szTitle);
4270	else if (iRow == iScrBegin)
4271	vgaInfoTextPrintSeparatorLine(pHlp, cCols, "screen start");
4272	else if (iRow == iScrEnd)
4273	vgaInfoTextPrintSeparatorLine(pHlp, cCols, "screen end");
4274
4275	uint8_t const *pbSrc = pbSrcOuter;
4276	for (uint32_t iCol = 0; iCol < cCols; ++iCol)
4277	{
4278	if (RT_C_IS_PRINT(*pbSrc))
4279	pHlp->pfnPrintf(pHlp, "%c", *pbSrc);
4280	else
4281	pHlp->pfnPrintf(pHlp, ".");
4282	pbSrc += 8; /* chars are spaced 8 bytes apart */
4283	}
4284	pHlp->pfnPrintf(pHlp, "\n");
4285	}
4286
4287	/* Final separator. */
4288	vgaInfoTextPrintSeparatorLine(pHlp, cCols, NULL);
4289	}
4290
4291
4292	/**
4293	* @callback_method_impl{FNDBGFHANDLERDEV,
4294	* Dumps VGA memory formatted as ASCII text\, no attributes. Only looks at
4295	* the first page.}
4296	*/
4297	static DECLCALLBACK(void) vgaInfoText(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
4298	{
4299	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4300
4301	/*
4302	* Parse args.
4303	*/
4304	bool fAll = true;
4305	if (pszArgs && *pszArgs)
4306	{
4307	if (!strcmp(pszArgs, "all"))
4308	fAll = true;
4309	else if (!strcmp(pszArgs, "scr") \|\| !strcmp(pszArgs, "screen"))
4310	fAll = false;
4311	else
4312	{
4313	pHlp->pfnPrintf(pHlp, "Invalid argument: '%s'\n", pszArgs);
4314	return;
4315	}
4316	}
4317
4318	/*
4319	* Check that we're in text mode and that the VRAM is accessible.
4320	*/
4321	if (!(pThis->gr[6] & 1))
4322	{
4323	uint8_t *pbSrc = pThis->vram_ptrR3;
4324	if (pbSrc)
4325	{
4326	/*
4327	* Figure out the display size and where the text is.
4328	*
4329	* Note! We're cutting quite a few corners here and this code could
4330	* do with some brushing up. Dumping from the start of the
4331	* frame buffer is done intentionally so that we're more
4332	* likely to obtain the full scrollback of a linux panic.
4333	* windbg> .printf "------ start -----\n"; .for (r $t0 = 0; @$t0 < 25; r $t0 = @$t0 + 1) { .for (r $t1 = 0; @$t1 < 80; r $t1 = @$t1 + 1) { .printf "%c", by( (@$t0 * 80 + @$t1) * 8 + 100f0000) }; .printf "\n" }; .printf "------ end -----\n";
4334	*/
4335	uint32_t cbLine;
4336	uint32_t offStart;
4337	uint32_t uLineCompareIgn;
4338	vga_get_offsets(pThis, &cbLine, &offStart, &uLineCompareIgn);
4339	if (!cbLine)
4340	cbLine = 80 * 8;
4341	offStart *= 8;
4342
4343	uint32_t uVDisp = pThis->cr[0x12] + ((pThis->cr[7] & 2) << 7) + ((pThis->cr[7] & 0x40) << 4) + 1;
4344	uint32_t uCharHeight = (pThis->cr[9] & 0x1f) + 1;
4345	uint32_t uDblScan = pThis->cr[9] >> 7;
4346	uint32_t cScrRows = uVDisp / (uCharHeight << uDblScan);
4347	if (cScrRows < 25)
4348	cScrRows = 25;
4349	uint32_t iScrBegin = offStart / cbLine;
4350	uint32_t cRows = iScrBegin + cScrRows;
4351	uint32_t cCols = cbLine / 8;
4352
4353	if (fAll) {
4354	vgaInfoTextWorker(pThis, pHlp, offStart - iScrBegin * cbLine, cbLine,
4355	cCols, cRows, iScrBegin, iScrBegin + cScrRows);
4356	} else {
4357	vgaInfoTextWorker(pThis, pHlp, offStart, cbLine, cCols, cScrRows, 0, cScrRows);
4358	}
4359	}
4360	else
4361	pHlp->pfnPrintf(pHlp, "VGA memory not available!\n");
4362	}
4363	else
4364	pHlp->pfnPrintf(pHlp, "Not in text mode!\n");
4365	}
4366
4367
4368	/**
4369	* @callback_method_impl{FNDBGFHANDLERDEV, Dumps VGA Sequencer registers.}
4370	*/
4371	static DECLCALLBACK(void) vgaInfoSR(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
4372	{
4373	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4374	unsigned i;
4375	NOREF(pszArgs);
4376
4377	pHlp->pfnPrintf(pHlp, "VGA Sequencer (3C5): SR index 3C4:%02X\n", pThis->sr_index);
4378	Assert(sizeof(pThis->sr) >= 8);
4379	for (i = 0; i < 5; ++i)
4380	pHlp->pfnPrintf(pHlp, " SR%02X:%02X", i, pThis->sr[i]);
4381	pHlp->pfnPrintf(pHlp, "\n");
4382	}
4383
4384
4385	/**
4386	* @callback_method_impl{FNDBGFHANDLERDEV, Dumps VGA CRTC registers.}
4387	*/
4388	static DECLCALLBACK(void) vgaInfoCR(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
4389	{
4390	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4391	unsigned i;
4392	NOREF(pszArgs);
4393
4394	pHlp->pfnPrintf(pHlp, "VGA CRTC (3D5): CRTC index 3D4:%02X\n", pThis->cr_index);
4395	Assert(sizeof(pThis->cr) >= 24);
4396	for (i = 0; i < 10; ++i)
4397	pHlp->pfnPrintf(pHlp, " CR%02X:%02X", i, pThis->cr[i]);
4398	pHlp->pfnPrintf(pHlp, "\n");
4399	for (i = 10; i < 20; ++i)
4400	pHlp->pfnPrintf(pHlp, " CR%02X:%02X", i, pThis->cr[i]);
4401	pHlp->pfnPrintf(pHlp, "\n");
4402	for (i = 20; i < 25; ++i)
4403	pHlp->pfnPrintf(pHlp, " CR%02X:%02X", i, pThis->cr[i]);
4404	pHlp->pfnPrintf(pHlp, "\n");
4405	}
4406
4407
4408	/**
4409	* @callback_method_impl{FNDBGFHANDLERDEV,
4410	* Dumps VGA Graphics Controller registers.}
4411	*/
4412	static DECLCALLBACK(void) vgaInfoGR(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
4413	{
4414	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4415	unsigned i;
4416	NOREF(pszArgs);
4417
4418	pHlp->pfnPrintf(pHlp, "VGA Graphics Controller (3CF): GR index 3CE:%02X\n", pThis->gr_index);
4419	Assert(sizeof(pThis->gr) >= 9);
4420	for (i = 0; i < 9; ++i)
4421	{
4422	pHlp->pfnPrintf(pHlp, " GR%02X:%02X", i, pThis->gr[i]);
4423	}
4424	pHlp->pfnPrintf(pHlp, "\n");
4425	}
4426
4427
4428	/**
4429	* @callback_method_impl{FNDBGFHANDLERDEV,
4430	* Dumps VGA Attribute Controller registers.}
4431	*/
4432	static DECLCALLBACK(void) vgaInfoAR(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
4433	{
4434	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4435	unsigned i;
4436	NOREF(pszArgs);
4437
4438	pHlp->pfnPrintf(pHlp, "VGA Attribute Controller (3C0): index reg %02X, flip-flop: %d (%s)\n",
4439	pThis->ar_index, pThis->ar_flip_flop, pThis->ar_flip_flop ? "data" : "index" );
4440	Assert(sizeof(pThis->ar) >= 0x14);
4441	pHlp->pfnPrintf(pHlp, " Palette:");
4442	for (i = 0; i < 0x10; ++i)
4443	pHlp->pfnPrintf(pHlp, " %02X", pThis->ar[i]);
4444	pHlp->pfnPrintf(pHlp, "\n");
4445	for (i = 0x10; i <= 0x14; ++i)
4446	pHlp->pfnPrintf(pHlp, " AR%02X:%02X", i, pThis->ar[i]);
4447	pHlp->pfnPrintf(pHlp, "\n");
4448	}
4449
4450
4451	/**
4452	* @callback_method_impl{FNDBGFHANDLERDEV, Dumps VGA DAC registers.}
4453	*/
4454	static DECLCALLBACK(void) vgaInfoDAC(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
4455	{
4456	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4457	unsigned i;
4458	NOREF(pszArgs);
4459
4460	pHlp->pfnPrintf(pHlp, "VGA DAC contents:\n");
4461	for (i = 0; i < 0x100; ++i)
4462	pHlp->pfnPrintf(pHlp, " %02X: %02X %02X %02X\n",
4463	i, pThis->palette[i3+0], pThis->palette[i3+1], pThis->palette[i*3+2]);
4464	}
4465
4466
4467	/**
4468	* @callback_method_impl{FNDBGFHANDLERDEV, Dumps VBE registers.}
4469	*/
4470	static DECLCALLBACK(void) vgaInfoVBE(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
4471	{
4472	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4473	NOREF(pszArgs);
4474
4475	pHlp->pfnPrintf(pHlp, "LFB at %RGp\n", pThis->GCPhysVRAM);
4476
4477	if (!(pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED))
4478	{
4479	pHlp->pfnPrintf(pHlp, "VBE disabled\n");
4480	return;
4481	}
4482
4483	pHlp->pfnPrintf(pHlp, "VBE state (chip ID 0x%04x):\n", pThis->vbe_regs[VBE_DISPI_INDEX_ID]);
4484	pHlp->pfnPrintf(pHlp, " Display resolution: %d x %d @ %dbpp\n",
4485	pThis->vbe_regs[VBE_DISPI_INDEX_XRES], pThis->vbe_regs[VBE_DISPI_INDEX_YRES],
4486	pThis->vbe_regs[VBE_DISPI_INDEX_BPP]);
4487	pHlp->pfnPrintf(pHlp, " Virtual resolution: %d x %d\n",
4488	pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_WIDTH], pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_HEIGHT]);
4489	pHlp->pfnPrintf(pHlp, " Display start addr: %d, %d\n",
4490	pThis->vbe_regs[VBE_DISPI_INDEX_X_OFFSET], pThis->vbe_regs[VBE_DISPI_INDEX_Y_OFFSET]);
4491	pHlp->pfnPrintf(pHlp, " Linear scanline pitch: 0x%04x\n", pThis->vbe_line_offset);
4492	pHlp->pfnPrintf(pHlp, " Linear display start : 0x%04x\n", pThis->vbe_start_addr);
4493	pHlp->pfnPrintf(pHlp, " Selected bank: 0x%04x\n", pThis->vbe_regs[VBE_DISPI_INDEX_BANK]);
4494	}
4495
4496
4497	/**
4498	* @callback_method_impl{FNDBGFHANDLERDEV,
4499	* Dumps register state relevant to 16-color planar graphics modes (GR/SR)
4500	* in human-readable form.}
4501	*/
4502	static DECLCALLBACK(void) vgaInfoPlanar(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
4503	{
4504	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
4505	int val1, val2;
4506	NOREF(pszArgs);
4507
4508	val1 = (pThis->gr[5] >> 3) & 1;
4509	val2 = pThis->gr[5] & 3;
4510	pHlp->pfnPrintf(pHlp, "read mode : %d write mode: %d\n", val1, val2);
4511	val1 = pThis->gr[0];
4512	val2 = pThis->gr[1];
4513	pHlp->pfnPrintf(pHlp, "set/reset data: %02X S/R enable: %02X\n", val1, val2);
4514	val1 = pThis->gr[2];
4515	val2 = pThis->gr[4] & 3;
4516	pHlp->pfnPrintf(pHlp, "color compare : %02X read map : %d\n", val1, val2);
4517	val1 = pThis->gr[3] & 7;
4518	val2 = (pThis->gr[3] >> 3) & 3;
4519	pHlp->pfnPrintf(pHlp, "rotate : %d function : %d\n", val1, val2);
4520	val1 = pThis->gr[7];
4521	val2 = pThis->gr[8];
4522	pHlp->pfnPrintf(pHlp, "don't care : %02X bit mask : %02X\n", val1, val2);
4523	val1 = pThis->sr[2];
4524	val2 = pThis->sr[4] & 8;
4525	pHlp->pfnPrintf(pHlp, "seq plane mask: %02X chain-4 : %s\n", val1, val2 ? "on" : "off");
4526	}
4527
4528
4529	/* -=-=-=-=-=- Ring 3: IBase -=-=-=-=-=- */
4530
4531	/**
4532	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
4533	*/
4534	static DECLCALLBACK(void ) vgaPortQueryInterface(PPDMIBASE pInterface, const char pszIID)
4535	{
4536	PVGASTATE pThis = RT_FROM_MEMBER(pInterface, VGASTATE, IBase);
4537	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
4538	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYPORT, &pThis->IPort);
4539	#if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) \|\| defined(VBOX_WITH_CRHGSMI))
4540	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYVBVACALLBACKS, &pThis->IVBVACallbacks);
4541	#endif
4542	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->ILeds);
4543	return NULL;
4544	}
4545
4546	/* -=-=-=-=-=- Ring 3: ILeds -=-=-=-=-=- */
4547	#define ILEDPORTS_2_VGASTATE(pInterface) ( (PVGASTATE)((uintptr_t)pInterface - RT_OFFSETOF(VGASTATE, ILeds)) )
4548
4549	/**
4550	* Gets the pointer to the status LED of a unit.
4551	*
4552	* @returns VBox status code.
4553	* @param pInterface Pointer to the interface structure containing the called function pointer.
4554	* @param iLUN The unit which status LED we desire.
4555	* @param ppLed Where to store the LED pointer.
4556	*/
4557	static DECLCALLBACK(int) vgaPortQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
4558	{
4559	PVGASTATE pThis = ILEDPORTS_2_VGASTATE(pInterface);
4560	switch (iLUN)
4561	{
4562	/* LUN #0: Display port. */
4563	case 0:
4564	{
4565	*ppLed = &pThis->Led3D;
4566	Assert((*ppLed)->u32Magic == PDMLED_MAGIC);
4567	return VINF_SUCCESS;
4568	}
4569
4570	default:
4571	AssertMsgFailed(("Invalid LUN #%d\n", iLUN));
4572	return VERR_PDM_NO_SUCH_LUN;
4573	}
4574
4575	return VERR_PDM_LUN_NOT_FOUND;
4576	}
4577
4578	/* -=-=-=-=-=- Ring 3: Dummy IDisplayConnector -=-=-=-=-=- */
4579
4580	/**
4581	* Resize the display.
4582	* This is called when the resolution changes. This usually happens on
4583	* request from the guest os, but may also happen as the result of a reset.
4584	*
4585	* @param pInterface Pointer to this interface.
4586	* @param cx New display width.
4587	* @param cy New display height
4588	* @thread The emulation thread.
4589	*/
4590	static DECLCALLBACK(int) vgaDummyResize(PPDMIDISPLAYCONNECTOR pInterface, uint32_t bpp, void *pvVRAM,
4591	uint32_t cbLine, uint32_t cx, uint32_t cy)
4592	{
4593	NOREF(pInterface); NOREF(bpp); NOREF(pvVRAM); NOREF(cbLine); NOREF(cx); NOREF(cy);
4594	return VINF_SUCCESS;
4595	}
4596
4597
4598	/**
4599	* Update a rectangle of the display.
4600	* PDMIDISPLAYPORT::pfnUpdateDisplay is the caller.
4601	*
4602	* @param pInterface Pointer to this interface.
4603	* @param x The upper left corner x coordinate of the rectangle.
4604	* @param y The upper left corner y coordinate of the rectangle.
4605	* @param cx The width of the rectangle.
4606	* @param cy The height of the rectangle.
4607	* @thread The emulation thread.
4608	*/
4609	static DECLCALLBACK(void) vgaDummyUpdateRect(PPDMIDISPLAYCONNECTOR pInterface, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
4610	{
4611	NOREF(pInterface); NOREF(x); NOREF(y); NOREF(cx); NOREF(cy);
4612	}
4613
4614
4615	/**
4616	* Refresh the display.
4617	*
4618	* The interval between these calls is set by
4619	* PDMIDISPLAYPORT::pfnSetRefreshRate(). The driver should call
4620	* PDMIDISPLAYPORT::pfnUpdateDisplay() if it wishes to refresh the
4621	* display. PDMIDISPLAYPORT::pfnUpdateDisplay calls pfnUpdateRect with
4622	* the changed rectangles.
4623	*
4624	* @param pInterface Pointer to this interface.
4625	* @thread The emulation thread.
4626	*/
4627	static DECLCALLBACK(void) vgaDummyRefresh(PPDMIDISPLAYCONNECTOR pInterface)
4628	{
4629	NOREF(pInterface);
4630	}
4631
4632
4633	/* -=-=-=-=-=- Ring 3: IDisplayPort -=-=-=-=-=- */
4634
4635	/** Converts a display port interface pointer to a vga state pointer. */
4636	#define IDISPLAYPORT_2_VGASTATE(pInterface) ( (PVGASTATE)((uintptr_t)pInterface - RT_OFFSETOF(VGASTATE, IPort)) )
4637
4638
4639	/**
4640	* Update the display with any changed regions.
4641	*
4642	* @param pInterface Pointer to this interface.
4643	* @see PDMIKEYBOARDPORT::pfnUpdateDisplay() for details.
4644	*/
4645	static DECLCALLBACK(int) vgaPortUpdateDisplay(PPDMIDISPLAYPORT pInterface)
4646	{
4647	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
4648	PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pThis));
4649	PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
4650
4651	int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
4652	AssertRC(rc);
4653
4654	#ifdef VBOX_WITH_VMSVGA
4655	if ( pThis->svga.fEnabled
4656	&& !pThis->svga.fTraces)
4657	{
4658	/* Nothing to do as the guest will explicitely update us about frame buffer changes. */
4659	PDMCritSectLeave(&pThis->CritSect);
4660	return VINF_SUCCESS;
4661	}
4662	#endif
4663
4664	#ifndef VBOX_WITH_HGSMI
4665	/* This should be called only in non VBVA mode. */
4666	#else
4667	if (VBVAUpdateDisplay (pThis) == VINF_SUCCESS)
4668	{
4669	PDMCritSectLeave(&pThis->CritSect);
4670	return VINF_SUCCESS;
4671	}
4672	#endif /* VBOX_WITH_HGSMI */
4673
4674	STAM_COUNTER_INC(&pThis->StatUpdateDisp);
4675	if (pThis->fHasDirtyBits && pThis->GCPhysVRAM && pThis->GCPhysVRAM != NIL_RTGCPHYS)
4676	{
4677	PGMHandlerPhysicalReset(PDMDevHlpGetVM(pDevIns), pThis->GCPhysVRAM);
4678	pThis->fHasDirtyBits = false;
4679	}
4680	if (pThis->fRemappedVGA)
4681	{
4682	IOMMMIOResetRegion(PDMDevHlpGetVM(pDevIns), 0x000a0000);
4683	pThis->fRemappedVGA = false;
4684	}
4685
4686	rc = vga_update_display(pThis, false, false, true,
4687	pThis->pDrv, &pThis->graphic_mode);
4688	PDMCritSectLeave(&pThis->CritSect);
4689	return rc;
4690	}
4691
4692
4693	/**
4694	* Internal vgaPortUpdateDisplayAll worker called under pThis->CritSect.
4695	*/
4696	static int updateDisplayAll(PVGASTATE pThis, bool fFailOnResize)
4697	{
4698	PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
4699
4700	#ifdef VBOX_WITH_VMSVGA
4701	if ( !pThis->svga.fEnabled
4702	\|\| pThis->svga.fTraces)
4703	{
4704	#endif
4705	/* The dirty bits array has been just cleared, reset handlers as well. */
4706	if (pThis->GCPhysVRAM && pThis->GCPhysVRAM != NIL_RTGCPHYS)
4707	PGMHandlerPhysicalReset(PDMDevHlpGetVM(pDevIns), pThis->GCPhysVRAM);
4708	#ifdef VBOX_WITH_VMSVGA
4709	}
4710	#endif
4711	if (pThis->fRemappedVGA)
4712	{
4713	IOMMMIOResetRegion(PDMDevHlpGetVM(pDevIns), 0x000a0000);
4714	pThis->fRemappedVGA = false;
4715	}
4716
4717	pThis->graphic_mode = -1; /* force full update */
4718
4719	return vga_update_display(pThis, true, fFailOnResize, true,
4720	pThis->pDrv, &pThis->graphic_mode);
4721	}
4722
4723
4724	DECLCALLBACK(int) vgaUpdateDisplayAll(PVGASTATE pThis, bool fFailOnResize)
4725	{
4726	#ifdef DEBUG_sunlover
4727	LogFlow(("vgaPortUpdateDisplayAll\n"));
4728	#endif /* DEBUG_sunlover */
4729
4730	int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
4731	AssertRC(rc);
4732
4733	rc = updateDisplayAll(pThis, fFailOnResize);
4734
4735	PDMCritSectLeave(&pThis->CritSect);
4736	return rc;
4737	}
4738
4739	/**
4740	* Update the entire display.
4741	*
4742	* @param pInterface Pointer to this interface.
4743	* @see PDMIKEYBOARDPORT::pfnUpdateDisplayAll() for details.
4744	*/
4745	static DECLCALLBACK(int) vgaPortUpdateDisplayAll(PPDMIDISPLAYPORT pInterface, bool fFailOnResize)
4746	{
4747	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
4748	PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pThis));
4749
4750	/* This is called both in VBVA mode and normal modes. */
4751
4752	return vgaUpdateDisplayAll(pThis, fFailOnResize);
4753	}
4754
4755
4756	/**
4757	* Sets the refresh rate and restart the timer.
4758	*
4759	* @returns VBox status code.
4760	* @param pInterface Pointer to this interface.
4761	* @param cMilliesInterval Number of millis between two refreshes.
4762	* @see PDMIKEYBOARDPORT::pfnSetRefreshRate() for details.
4763	*/
4764	static DECLCALLBACK(int) vgaPortSetRefreshRate(PPDMIDISPLAYPORT pInterface, uint32_t cMilliesInterval)
4765	{
4766	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
4767
4768	pThis->cMilliesRefreshInterval = cMilliesInterval;
4769	if (cMilliesInterval)
4770	return TMTimerSetMillies(pThis->RefreshTimer, cMilliesInterval);
4771	return TMTimerStop(pThis->RefreshTimer);
4772	}
4773
4774
4775	/** @copydoc PDMIDISPLAYPORT::pfnQueryVideoMode */
4776	static DECLCALLBACK(int) vgaPortQueryVideoMode(PPDMIDISPLAYPORT pInterface, uint32_t pcBits, uint32_t pcx, uint32_t *pcy)
4777	{
4778	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
4779
4780	if (!pcBits)
4781	return VERR_INVALID_PARAMETER;
4782	*pcBits = vga_get_bpp(pThis);
4783	if (pcx)
4784	*pcx = pThis->last_scr_width;
4785	if (pcy)
4786	*pcy = pThis->last_scr_height;
4787	return VINF_SUCCESS;
4788	}
4789
4790
4791	/**
4792	* Create a 32-bbp screenshot of the display. Size of the bitmap scanline in bytes is 4*width.
4793	*
4794	* @param pInterface Pointer to this interface.
4795	* @param ppbData Where to store the pointer to the allocated
4796	* buffer.
4797	* @param pcbData Where to store the actual size of the bitmap.
4798	* @param pcx Where to store the width of the bitmap.
4799	* @param pcy Where to store the height of the bitmap.
4800	* @see PDMIDISPLAYPORT::pfnTakeScreenshot() for details.
4801	*/
4802	static DECLCALLBACK(int) vgaPortTakeScreenshot(PPDMIDISPLAYPORT pInterface, uint8_t *ppbData, size_t pcbData, uint32_t pcx, uint32_t pcy)
4803	{
4804	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
4805	PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pThis));
4806
4807	LogFlow(("vgaPortTakeScreenshot: ppbData=%p pcbData=%p pcx=%p pcy=%p\n", ppbData, pcbData, pcx, pcy));
4808
4809	/*
4810	* Validate input.
4811	*/
4812	if (!RT_VALID_PTR(ppbData) \|\| !RT_VALID_PTR(pcbData) \|\| !RT_VALID_PTR(pcx) \|\| !RT_VALID_PTR(pcy))
4813	return VERR_INVALID_PARAMETER;
4814
4815	int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
4816	AssertRCReturn(rc, rc);
4817
4818	/*
4819	* Get screenshot. This function will fail if a resize is required.
4820	* So there is not need to do a 'updateDisplayAll' before taking screenshot.
4821	*/
4822
4823	/*
4824	* Allocate the buffer for 32 bits per pixel bitmap
4825	*
4826	* Note! The size can't be zero or greater than the size of the VRAM.
4827	* Inconsistent VGA device state can cause the incorrect size values.
4828	*/
4829	size_t cbRequired = pThis->last_scr_width * 4 * pThis->last_scr_height;
4830	if (cbRequired && cbRequired <= pThis->vram_size)
4831	{
4832	uint8_t pbData = (uint8_t )RTMemAlloc(cbRequired);
4833	if (pbData != NULL)
4834	{
4835	/*
4836	* Only 3 methods, assigned below, will be called during the screenshot update.
4837	* All other are already set to NULL.
4838	*/
4839	/* The display connector interface is temporarily replaced with the fake one. */
4840	PDMIDISPLAYCONNECTOR Connector;
4841	RT_ZERO(Connector);
4842	Connector.pbData = pbData;
4843	Connector.cBits = 32;
4844	Connector.cx = pThis->last_scr_width;
4845	Connector.cy = pThis->last_scr_height;
4846	Connector.cbScanline = Connector.cx * 4;
4847	Connector.pfnRefresh = vgaDummyRefresh;
4848	Connector.pfnResize = vgaDummyResize;
4849	Connector.pfnUpdateRect = vgaDummyUpdateRect;
4850
4851	int32_t cur_graphic_mode = -1;
4852
4853	bool fSavedRenderVRAM = pThis->fRenderVRAM;
4854	pThis->fRenderVRAM = true;
4855
4856	/*
4857	* Take the screenshot.
4858	*
4859	* The second parameter is 'false' because the current display state is being rendered to an
4860	* external buffer using a fake connector. That is if display is blanked, we expect a black
4861	* screen in the external buffer.
4862	* If there is a pending resize, the function will fail.
4863	*/
4864	rc = vga_update_display(pThis, false, true, false, &Connector, &cur_graphic_mode);
4865
4866	pThis->fRenderVRAM = fSavedRenderVRAM;
4867
4868	if (rc == VINF_SUCCESS)
4869	{
4870	/*
4871	* Return the result.
4872	*/
4873	*ppbData = pbData;
4874	*pcbData = cbRequired;
4875	*pcx = Connector.cx;
4876	*pcy = Connector.cy;
4877	}
4878	else
4879	{
4880	/* If we do not return a success, then the data buffer must be freed. */
4881	RTMemFree(pbData);
4882	if (RT_SUCCESS_NP(rc))
4883	{
4884	AssertMsgFailed(("%Rrc\n", rc));
4885	rc = VERR_INTERNAL_ERROR_5;
4886	}
4887	}
4888	}
4889	else
4890	rc = VERR_NO_MEMORY;
4891	}
4892	else
4893	rc = VERR_NOT_SUPPORTED;
4894
4895	PDMCritSectLeave(&pThis->CritSect);
4896
4897	LogFlow(("vgaPortTakeScreenshot: returns %Rrc (cbData=%d cx=%d cy=%d)\n", rc, pcbData, pcx, *pcy));
4898	return rc;
4899	}
4900
4901	/**
4902	* Free a screenshot buffer allocated in vgaPortTakeScreenshot.
4903	*
4904	* @param pInterface Pointer to this interface.
4905	* @param pbData Pointer returned by vgaPortTakeScreenshot.
4906	* @see PDMIDISPLAYPORT::pfnFreeScreenshot() for details.
4907	*/
4908	static DECLCALLBACK(void) vgaPortFreeScreenshot(PPDMIDISPLAYPORT pInterface, uint8_t *pbData)
4909	{
4910	NOREF(pInterface);
4911
4912	LogFlow(("vgaPortFreeScreenshot: pbData=%p\n", pbData));
4913
4914	RTMemFree(pbData);
4915	}
4916
4917	/**
4918	* Copy bitmap to the display.
4919	*
4920	* @param pInterface Pointer to this interface.
4921	* @param pvData Pointer to the bitmap bits.
4922	* @param x The upper left corner x coordinate of the destination rectangle.
4923	* @param y The upper left corner y coordinate of the destination rectangle.
4924	* @param cx The width of the source and destination rectangles.
4925	* @param cy The height of the source and destination rectangles.
4926	* @see PDMIDISPLAYPORT::pfnDisplayBlt() for details.
4927	*/
4928	static DECLCALLBACK(int) vgaPortDisplayBlt(PPDMIDISPLAYPORT pInterface, const void *pvData, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
4929	{
4930	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
4931	int rc = VINF_SUCCESS;
4932	PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pThis));
4933	LogFlow(("vgaPortDisplayBlt: pvData=%p x=%d y=%d cx=%d cy=%d\n", pvData, x, y, cx, cy));
4934
4935	rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
4936	AssertRC(rc);
4937
4938	/*
4939	* Validate input.
4940	*/
4941	if ( pvData
4942	&& x < pThis->pDrv->cx
4943	&& cx <= pThis->pDrv->cx
4944	&& cx + x <= pThis->pDrv->cx
4945	&& y < pThis->pDrv->cy
4946	&& cy <= pThis->pDrv->cy
4947	&& cy + y <= pThis->pDrv->cy)
4948	{
4949	/*
4950	* Determine bytes per pixel in the destination buffer.
4951	*/
4952	size_t cbPixelDst = 0;
4953	switch (pThis->pDrv->cBits)
4954	{
4955	case 8:
4956	cbPixelDst = 1;
4957	break;
4958	case 15:
4959	case 16:
4960	cbPixelDst = 2;
4961	break;
4962	case 24:
4963	cbPixelDst = 3;
4964	break;
4965	case 32:
4966	cbPixelDst = 4;
4967	break;
4968	default:
4969	rc = VERR_INVALID_PARAMETER;
4970	break;
4971	}
4972	if (RT_SUCCESS(rc))
4973	{
4974	/*
4975	* The blitting loop.
4976	*/
4977	size_t cbLineSrc = cx * 4; /* 32 bits per pixel. */
4978	uint8_t pbSrc = (uint8_t )pvData;
4979	size_t cbLineDst = pThis->pDrv->cbScanline;
4980	uint8_t pbDst = pThis->pDrv->pbData + y cbLineDst + x * cbPixelDst;
4981	uint32_t cyLeft = cy;
4982	vga_draw_line_func pfnVgaDrawLine = vga_draw_line_table[VGA_DRAW_LINE32 4 + get_depth_index(pThis->pDrv->cBits)];
4983	Assert(pfnVgaDrawLine);
4984	while (cyLeft-- > 0)
4985	{
4986	pfnVgaDrawLine(pThis, pbDst, pbSrc, cx);
4987	pbDst += cbLineDst;
4988	pbSrc += cbLineSrc;
4989	}
4990
4991	/*
4992	* Invalidate the area.
4993	*/
4994	pThis->pDrv->pfnUpdateRect(pThis->pDrv, x, y, cx, cy);
4995	}
4996	}
4997	else
4998	rc = VERR_INVALID_PARAMETER;
4999
5000	PDMCritSectLeave(&pThis->CritSect);
5001
5002	LogFlow(("vgaPortDisplayBlt: returns %Rrc\n", rc));
5003	return rc;
5004	}
5005
5006	static DECLCALLBACK(void) vgaPortUpdateDisplayRect(PPDMIDISPLAYPORT pInterface, int32_t x, int32_t y, uint32_t w, uint32_t h)
5007	{
5008	uint32_t v;
5009	vga_draw_line_func *vga_draw_line;
5010
5011	uint32_t cbPixelDst;
5012	uint32_t cbLineDst;
5013	uint8_t *pbDst;
5014
5015	uint32_t cbPixelSrc;
5016	uint32_t cbLineSrc;
5017	uint8_t *pbSrc;
5018
5019	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
5020
5021	#ifdef DEBUG_sunlover
5022	LogFlow(("vgaPortUpdateDisplayRect: %d,%d %dx%d\n", x, y, w, h));
5023	#endif /* DEBUG_sunlover */
5024
5025	Assert(pInterface);
5026
5027	int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
5028	AssertRC(rc);
5029
5030	/* Check if there is something to do at all. */
5031	if (!pThis->fRenderVRAM)
5032	{
5033	/* The framebuffer uses the guest VRAM directly. */
5034	#ifdef DEBUG_sunlover
5035	LogFlow(("vgaPortUpdateDisplayRect: nothing to do fRender is false.\n"));
5036	#endif /* DEBUG_sunlover */
5037	PDMCritSectLeave(&pThis->CritSect);
5038	return;
5039	}
5040
5041	Assert(pThis->pDrv);
5042	Assert(pThis->pDrv->pbData);
5043
5044	/* Correct negative x and y coordinates. */
5045	if (x < 0)
5046	{
5047	x += w; /* Compute xRight which is also the new width. */
5048	w = (x < 0) ? 0 : x;
5049	x = 0;
5050	}
5051
5052	if (y < 0)
5053	{
5054	y += h; /* Compute yBottom, which is also the new height. */
5055	h = (y < 0) ? 0 : y;
5056	y = 0;
5057	}
5058
5059	/* Also check if coords are greater than the display resolution. */
5060	if (x + w > pThis->pDrv->cx)
5061	{
5062	// x < 0 is not possible here
5063	w = pThis->pDrv->cx > (uint32_t)x? pThis->pDrv->cx - x: 0;
5064	}
5065
5066	if (y + h > pThis->pDrv->cy)
5067	{
5068	// y < 0 is not possible here
5069	h = pThis->pDrv->cy > (uint32_t)y? pThis->pDrv->cy - y: 0;
5070	}
5071
5072	#ifdef DEBUG_sunlover
5073	LogFlow(("vgaPortUpdateDisplayRect: %d,%d %dx%d (corrected coords)\n", x, y, w, h));
5074	#endif /* DEBUG_sunlover */
5075
5076	/* Check if there is something to do at all. */
5077	if (w == 0 \|\| h == 0)
5078	{
5079	/* Empty rectangle. */
5080	#ifdef DEBUG_sunlover
5081	LogFlow(("vgaPortUpdateDisplayRect: nothing to do: %dx%d\n", w, h));
5082	#endif /* DEBUG_sunlover */
5083	PDMCritSectLeave(&pThis->CritSect);
5084	return;
5085	}
5086
5087	/** @todo This method should be made universal and not only for VBVA.
5088	* VGA_DRAW_LINE* must be selected and src/dst address calculation
5089	* changed.
5090	*/
5091
5092	/* Choose the rendering function. */
5093	switch(pThis->get_bpp(pThis))
5094	{
5095	default:
5096	case 0:
5097	/* A LFB mode is already disabled, but the callback is still called
5098	* by Display because VBVA buffer is being flushed.
5099	* Nothing to do, just return.
5100	*/
5101	PDMCritSectLeave(&pThis->CritSect);
5102	return;
5103	case 8:
5104	v = VGA_DRAW_LINE8;
5105	break;
5106	case 15:
5107	v = VGA_DRAW_LINE15;
5108	break;
5109	case 16:
5110	v = VGA_DRAW_LINE16;
5111	break;
5112	case 24:
5113	v = VGA_DRAW_LINE24;
5114	break;
5115	case 32:
5116	v = VGA_DRAW_LINE32;
5117	break;
5118	}
5119
5120	vga_draw_line = vga_draw_line_table[v * 4 + get_depth_index(pThis->pDrv->cBits)];
5121
5122	/* Compute source and destination addresses and pitches. */
5123	cbPixelDst = (pThis->pDrv->cBits + 7) / 8;
5124	cbLineDst = pThis->pDrv->cbScanline;
5125	pbDst = pThis->pDrv->pbData + y * cbLineDst + x * cbPixelDst;
5126
5127	cbPixelSrc = (pThis->get_bpp(pThis) + 7) / 8;
5128	uint32_t offSrc, u32Dummy;
5129	pThis->get_offsets(pThis, &cbLineSrc, &offSrc, &u32Dummy);
5130
5131	/* Assume that rendering is performed only on visible part of VRAM.
5132	* This is true because coordinates were verified.
5133	*/
5134	pbSrc = pThis->vram_ptrR3;
5135	pbSrc += offSrc * 4 + y * cbLineSrc + x * cbPixelSrc;
5136
5137	/* Render VRAM to framebuffer. */
5138
5139	#ifdef DEBUG_sunlover
5140	LogFlow(("vgaPortUpdateDisplayRect: dst: %p, %d, %d. src: %p, %d, %d\n", pbDst, cbLineDst, cbPixelDst, pbSrc, cbLineSrc, cbPixelSrc));
5141	#endif /* DEBUG_sunlover */
5142
5143	while (h-- > 0)
5144	{
5145	vga_draw_line (pThis, pbDst, pbSrc, w);
5146	pbDst += cbLineDst;
5147	pbSrc += cbLineSrc;
5148	}
5149
5150	PDMCritSectLeave(&pThis->CritSect);
5151	#ifdef DEBUG_sunlover
5152	LogFlow(("vgaPortUpdateDisplayRect: completed.\n"));
5153	#endif /* DEBUG_sunlover */
5154	}
5155
5156
5157	static DECLCALLBACK(int)
5158	vgaPortCopyRect(PPDMIDISPLAYPORT pInterface,
5159	uint32_t cx,
5160	uint32_t cy,
5161	const uint8_t *pbSrc, int32_t xSrc, int32_t ySrc, uint32_t cxSrc, uint32_t cySrc,
5162	uint32_t cbSrcLine, uint32_t cSrcBitsPerPixel,
5163	uint8_t *pbDst, int32_t xDst, int32_t yDst, uint32_t cxDst, uint32_t cyDst,
5164	uint32_t cbDstLine, uint32_t cDstBitsPerPixel)
5165	{
5166	uint32_t v;
5167	vga_draw_line_func *vga_draw_line;
5168
5169	#ifdef DEBUG_sunlover
5170	LogFlow(("vgaPortCopyRect: %d,%d %dx%d -> %d,%d\n", xSrc, ySrc, cx, cy, xDst, yDst));
5171	#endif /* DEBUG_sunlover */
5172
5173	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
5174
5175	Assert(pInterface);
5176	Assert(pThis->pDrv);
5177
5178	int32_t xSrcCorrected = xSrc;
5179	int32_t ySrcCorrected = ySrc;
5180	uint32_t cxCorrected = cx;
5181	uint32_t cyCorrected = cy;
5182
5183	/* Correct source coordinates to be within the source bitmap. */
5184	if (xSrcCorrected < 0)
5185	{
5186	xSrcCorrected += cxCorrected; /* Compute xRight which is also the new width. */
5187	cxCorrected = (xSrcCorrected < 0) ? 0 : xSrcCorrected;
5188	xSrcCorrected = 0;
5189	}
5190
5191	if (ySrcCorrected < 0)
5192	{
5193	ySrcCorrected += cyCorrected; /* Compute yBottom, which is also the new height. */
5194	cyCorrected = (ySrcCorrected < 0) ? 0 : ySrcCorrected;
5195	ySrcCorrected = 0;
5196	}
5197
5198	/* Also check if coords are greater than the display resolution. */
5199	if (xSrcCorrected + cxCorrected > cxSrc)
5200	{
5201	/* xSrcCorrected < 0 is not possible here */
5202	cxCorrected = cxSrc > (uint32_t)xSrcCorrected ? cxSrc - xSrcCorrected : 0;
5203	}
5204
5205	if (ySrcCorrected + cyCorrected > cySrc)
5206	{
5207	/* y < 0 is not possible here */
5208	cyCorrected = cySrc > (uint32_t)ySrcCorrected ? cySrc - ySrcCorrected : 0;
5209	}
5210
5211	#ifdef DEBUG_sunlover
5212	LogFlow(("vgaPortCopyRect: %d,%d %dx%d (corrected coords)\n", xSrcCorrected, ySrcCorrected, cxCorrected, cyCorrected));
5213	#endif /* DEBUG_sunlover */
5214
5215	/* Check if there is something to do at all. */
5216	if (cxCorrected == 0 \|\| cyCorrected == 0)
5217	{
5218	/* Empty rectangle. */
5219	#ifdef DEBUG_sunlover
5220	LogFlow(("vgaPortUpdateDisplayRectEx: nothing to do: %dx%d\n", cxCorrected, cyCorrected));
5221	#endif /* DEBUG_sunlover */
5222	return VINF_SUCCESS;
5223	}
5224
5225	/* Check that the corrected source rectangle is within the destination.
5226	* Note: source rectangle is adjusted, but the target must be large enough.
5227	*/
5228	if ( xDst < 0
5229	\|\| yDst < 0
5230	\|\| xDst + cxCorrected > cxDst
5231	\|\| yDst + cyCorrected > cyDst)
5232	{
5233	return VERR_INVALID_PARAMETER;
5234	}
5235
5236	int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
5237	AssertRC(rc);
5238
5239	/* This method only works if the VGA device is in a VBE mode or not paused VBVA mode.
5240	* VGA modes are reported to the caller by returning VERR_INVALID_STATE.
5241	*
5242	* If VBE_DISPI_ENABLED is set, then it is a VBE or VBE compatible VBVA mode. Both of them can be handled.
5243	*
5244	* If VBE_DISPI_ENABLED is clear, then it is either a VGA mode or a VBVA mode set by guest additions
5245	* which have VBVACAPS_USE_VBVA_ONLY capability.
5246	* When VBE_DISPI_ENABLED is being cleared and VBVACAPS_USE_VBVA_ONLY is not set (i.e. guest wants a VGA mode),
5247	* then VBVAOnVBEChanged makes sure that VBVA is paused.
5248	* That is a not paused VBVA means that the video mode can be handled even if VBE_DISPI_ENABLED is clear.
5249	*/
5250	if ( (pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED) == 0
5251	&& VBVAIsPaused(pThis))
5252	{
5253	PDMCritSectLeave(&pThis->CritSect);
5254	return VERR_INVALID_STATE;
5255	}
5256
5257	/* Choose the rendering function. */
5258	switch (cSrcBitsPerPixel)
5259	{
5260	default:
5261	case 0:
5262	/* Nothing to do, just return. */
5263	PDMCritSectLeave(&pThis->CritSect);
5264	return VINF_SUCCESS;
5265	case 8:
5266	v = VGA_DRAW_LINE8;
5267	break;
5268	case 15:
5269	v = VGA_DRAW_LINE15;
5270	break;
5271	case 16:
5272	v = VGA_DRAW_LINE16;
5273	break;
5274	case 24:
5275	v = VGA_DRAW_LINE24;
5276	break;
5277	case 32:
5278	v = VGA_DRAW_LINE32;
5279	break;
5280	}
5281
5282	vga_draw_line = vga_draw_line_table[v * 4 + get_depth_index(cDstBitsPerPixel)];
5283
5284	/* Compute source and destination addresses and pitches. */
5285	uint32_t cbPixelDst = (cDstBitsPerPixel + 7) / 8;
5286	uint32_t cbLineDst = cbDstLine;
5287	uint8_t pbDstCur = pbDst + yDst cbLineDst + xDst * cbPixelDst;
5288
5289	uint32_t cbPixelSrc = (cSrcBitsPerPixel + 7) / 8;
5290	uint32_t cbLineSrc = cbSrcLine;
5291	const uint8_t pbSrcCur = pbSrc + ySrcCorrected cbLineSrc + xSrcCorrected * cbPixelSrc;
5292
5293	#ifdef DEBUG_sunlover
5294	LogFlow(("vgaPortCopyRect: dst: %p, %d, %d. src: %p, %d, %d\n", pbDstCur, cbLineDst, cbPixelDst, pbSrcCur, cbLineSrc, cbPixelSrc));
5295	#endif /* DEBUG_sunlover */
5296
5297	while (cyCorrected-- > 0)
5298	{
5299	vga_draw_line(pThis, pbDstCur, pbSrcCur, cxCorrected);
5300	pbDstCur += cbLineDst;
5301	pbSrcCur += cbLineSrc;
5302	}
5303
5304	PDMCritSectLeave(&pThis->CritSect);
5305	#ifdef DEBUG_sunlover
5306	LogFlow(("vgaPortCopyRect: completed.\n"));
5307	#endif /* DEBUG_sunlover */
5308
5309	return VINF_SUCCESS;
5310	}
5311
5312	static DECLCALLBACK(void) vgaPortSetRenderVRAM(PPDMIDISPLAYPORT pInterface, bool fRender)
5313	{
5314	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
5315
5316	LogFlow(("vgaPortSetRenderVRAM: fRender = %d\n", fRender));
5317
5318	int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
5319	AssertRC(rc);
5320
5321	pThis->fRenderVRAM = fRender;
5322
5323	PDMCritSectLeave(&pThis->CritSect);
5324	}
5325
5326
5327	static DECLCALLBACK(void) vgaTimerRefresh(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
5328	{
5329	PVGASTATE pThis = (PVGASTATE)pvUser;
5330	NOREF(pDevIns);
5331
5332	if (pThis->fScanLineCfg & VBVASCANLINECFG_ENABLE_VSYNC_IRQ)
5333	{
5334	VBVARaiseIrq(pThis, HGSMIHOSTFLAGS_VSYNC);
5335	}
5336
5337	if (pThis->pDrv)
5338	pThis->pDrv->pfnRefresh(pThis->pDrv);
5339
5340	if (pThis->cMilliesRefreshInterval)
5341	TMTimerSetMillies(pTimer, pThis->cMilliesRefreshInterval);
5342
5343	#ifdef VBOX_WITH_VIDEOHWACCEL
5344	vbvaTimerCb(pThis);
5345	#endif
5346
5347	#ifdef VBOX_WITH_CRHGSMI
5348	vboxCmdVBVACmdTimer(pThis);
5349	#endif
5350	}
5351
5352	#ifdef VBOX_WITH_VMSVGA
5353	int vgaR3RegisterVRAMHandler(PVGASTATE pVGAState, uint64_t cbFrameBuffer)
5354	{
5355	PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
5356	Assert(pVGAState->GCPhysVRAM);
5357
5358	int rc = PGMHandlerPhysicalRegister(PDMDevHlpGetVM(pDevIns),
5359	pVGAState->GCPhysVRAM, pVGAState->GCPhysVRAM + (cbFrameBuffer - 1),
5360	pVGAState->hLfbAccessHandlerType, pVGAState, pDevIns->pvInstanceDataR0,
5361	pDevIns->pvInstanceDataRC, "VGA LFB");
5362
5363	AssertRC(rc);
5364	return rc;
5365	}
5366
5367	int vgaR3UnregisterVRAMHandler(PVGASTATE pVGAState)
5368	{
5369	PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
5370
5371	Assert(pVGAState->GCPhysVRAM);
5372	int rc = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pDevIns), pVGAState->GCPhysVRAM);
5373	AssertRC(rc);
5374	return rc;
5375	}
5376	#endif
5377
5378	/* -=-=-=-=-=- Ring 3: PCI Device -=-=-=-=-=- */
5379
5380	/**
5381	* Callback function for unmapping and/or mapping the VRAM MMIO2 region (called by the PCI bus).
5382	*
5383	* @return VBox status code.
5384	* @param pPciDev Pointer to PCI device. Use pPciDev->pDevIns to get the device instance.
5385	* @param iRegion The region number.
5386	* @param GCPhysAddress Physical address of the region. If iType is PCI_ADDRESS_SPACE_IO, this is an
5387	* I/O port, else it's a physical address.
5388	* This address is NOT relative to pci_mem_base like earlier!
5389	* @param enmType One of the PCI_ADDRESS_SPACE_* values.
5390	*/
5391	static DECLCALLBACK(int) vgaR3IORegionMap(PPCIDEVICE pPciDev, /unsigned/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
5392	{
5393	int rc;
5394	PPDMDEVINS pDevIns = pPciDev->pDevIns;
5395	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
5396	Log(("vgaR3IORegionMap: iRegion=%d GCPhysAddress=%RGp cb=%#x enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
5397	#ifdef VBOX_WITH_VMSVGA
5398	AssertReturn((iRegion == ((pThis->fVMSVGAEnabled) ? 1 : 0)) && (enmType == ((pThis->fVMSVGAEnabled) ? PCI_ADDRESS_SPACE_MEM : PCI_ADDRESS_SPACE_MEM_PREFETCH)), VERR_INTERNAL_ERROR);
5399	#else
5400	AssertReturn(iRegion == 0 && enmType == PCI_ADDRESS_SPACE_MEM_PREFETCH, VERR_INTERNAL_ERROR);
5401	#endif
5402
5403	rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
5404	AssertRC(rc);
5405
5406	if (GCPhysAddress != NIL_RTGCPHYS)
5407	{
5408	/*
5409	* Mapping the VRAM.
5410	*/
5411	rc = PDMDevHlpMMIO2Map(pDevIns, iRegion, GCPhysAddress);
5412	AssertRC(rc);
5413	if (RT_SUCCESS(rc))
5414	{
5415	rc = PGMHandlerPhysicalRegister(PDMDevHlpGetVM(pDevIns), GCPhysAddress, GCPhysAddress + (pThis->vram_size - 1),
5416	pThis->hLfbAccessHandlerType, pThis, pDevIns->pvInstanceDataR0,
5417	pDevIns->pvInstanceDataRC, "VGA LFB");
5418	AssertRC(rc);
5419	if (RT_SUCCESS(rc))
5420	{
5421	pThis->GCPhysVRAM = GCPhysAddress;
5422	pThis->vbe_regs[VBE_DISPI_INDEX_FB_BASE_HI] = GCPhysAddress >> 16;
5423	}
5424	}
5425	}
5426	else
5427	{
5428	/*
5429	* Unmapping of the VRAM in progress.
5430	* Deregister the access handler so PGM doesn't get upset.
5431	*/
5432	Assert(pThis->GCPhysVRAM);
5433	#ifdef VBOX_WITH_VMSVGA
5434	Assert(!pThis->svga.fEnabled \|\| !pThis->svga.fVRAMTracking);
5435	if ( !pThis->svga.fEnabled
5436	\|\| ( pThis->svga.fEnabled
5437	&& pThis->svga.fVRAMTracking
5438	)
5439	)
5440	{
5441	#endif
5442	rc = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pDevIns), pThis->GCPhysVRAM);
5443	AssertRC(rc);
5444	#ifdef VBOX_WITH_VMSVGA
5445	}
5446	else
5447	rc = VINF_SUCCESS;
5448	#endif
5449	pThis->GCPhysVRAM = 0;
5450	/* NB: VBE_DISPI_INDEX_FB_BASE_HI is left unchanged here. */
5451	}
5452	PDMCritSectLeave(&pThis->CritSect);
5453	return rc;
5454	}
5455
5456
5457	/* -=-=-=-=-=- Ring3: Misc Wrappers & Sidekicks -=-=-=-=-=- */
5458
5459	/**
5460	* Saves a important bits of the VGA device config.
5461	*
5462	* @param pThis The VGA instance data.
5463	* @param pSSM The saved state handle.
5464	*/
5465	static void vgaR3SaveConfig(PVGASTATE pThis, PSSMHANDLE pSSM)
5466	{
5467	SSMR3PutU32(pSSM, pThis->vram_size);
5468	SSMR3PutU32(pSSM, pThis->cMonitors);
5469	}
5470
5471
5472	/**
5473	* @copydoc FNSSMDEVLIVEEXEC
5474	*/
5475	static DECLCALLBACK(int) vgaR3LiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
5476	{
5477	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
5478	Assert(uPass == 0); NOREF(uPass);
5479	vgaR3SaveConfig(pThis, pSSM);
5480	return VINF_SSM_DONT_CALL_AGAIN;
5481	}
5482
5483
5484	/**
5485	* @copydoc FNSSMDEVSAVEPREP
5486	*/
5487	static DECLCALLBACK(int) vgaR3SavePrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
5488	{
5489	#ifdef VBOX_WITH_VIDEOHWACCEL
5490	return vboxVBVASaveStatePrep(pDevIns, pSSM);
5491	#else
5492	return VINF_SUCCESS;
5493	#endif
5494	}
5495
5496	static DECLCALLBACK(int) vgaR3SaveDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
5497	{
5498	#ifdef VBOX_WITH_VIDEOHWACCEL
5499	return vboxVBVASaveStateDone(pDevIns, pSSM);
5500	#else
5501	return VINF_SUCCESS;
5502	#endif
5503	}
5504
5505	/**
5506	* @copydoc FNSSMDEVSAVEEXEC
5507	*/
5508	static DECLCALLBACK(int) vgaR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
5509	{
5510	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
5511
5512	#ifdef VBOX_WITH_VDMA
5513	vboxVDMASaveStateExecPrep(pThis->pVdma, pSSM);
5514	#endif
5515
5516	vgaR3SaveConfig(pThis, pSSM);
5517	vga_save(pSSM, PDMINS_2_DATA(pDevIns, PVGASTATE));
5518
5519	VGA_SAVED_STATE_PUT_MARKER(pSSM, 1);
5520	#ifdef VBOX_WITH_HGSMI
5521	SSMR3PutBool(pSSM, true);
5522	int rc = vboxVBVASaveStateExec(pDevIns, pSSM);
5523	#else
5524	int rc = SSMR3PutBool(pSSM, false);
5525	#endif
5526
5527	AssertRCReturn(rc, rc);
5528
5529	VGA_SAVED_STATE_PUT_MARKER(pSSM, 3);
5530	#ifdef VBOX_WITH_VDMA
5531	rc = SSMR3PutU32(pSSM, 1);
5532	AssertRCReturn(rc, rc);
5533	rc = vboxVDMASaveStateExecPerform(pThis->pVdma, pSSM);
5534	#else
5535	rc = SSMR3PutU32(pSSM, 0);
5536	#endif
5537	AssertRCReturn(rc, rc);
5538
5539	#ifdef VBOX_WITH_VDMA
5540	vboxVDMASaveStateExecDone(pThis->pVdma, pSSM);
5541	#endif
5542
5543	VGA_SAVED_STATE_PUT_MARKER(pSSM, 5);
5544	#ifdef VBOX_WITH_VMSVGA
5545	if (pThis->fVMSVGAEnabled)
5546	{
5547	rc = vmsvgaSaveExec(pDevIns, pSSM);
5548	AssertRCReturn(rc, rc);
5549	}
5550	#endif
5551	VGA_SAVED_STATE_PUT_MARKER(pSSM, 6);
5552
5553	return rc;
5554	}
5555
5556
5557	/**
5558	* @copydoc FNSSMDEVSAVEEXEC
5559	*/
5560	static DECLCALLBACK(int) vgaR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
5561	{
5562	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
5563	int rc;
5564
5565	if (uVersion < VGA_SAVEDSTATE_VERSION_ANCIENT \|\| uVersion > VGA_SAVEDSTATE_VERSION)
5566	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
5567
5568	if (uVersion > VGA_SAVEDSTATE_VERSION_HGSMI)
5569	{
5570	/* Check the config */
5571	uint32_t cbVRam;
5572	rc = SSMR3GetU32(pSSM, &cbVRam);
5573	AssertRCReturn(rc, rc);
5574	if (pThis->vram_size != cbVRam)
5575	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("VRAM size changed: config=%#x state=%#x"), pThis->vram_size, cbVRam);
5576
5577	uint32_t cMonitors;
5578	rc = SSMR3GetU32(pSSM, &cMonitors);
5579	AssertRCReturn(rc, rc);
5580	if (pThis->cMonitors != cMonitors)
5581	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Monitor count changed: config=%u state=%u"), pThis->cMonitors, cMonitors);
5582	}
5583
5584	if (uPass == SSM_PASS_FINAL)
5585	{
5586	rc = vga_load(pSSM, pThis, uVersion);
5587	if (RT_FAILURE(rc))
5588	return rc;
5589
5590	/*
5591	* Restore the HGSMI state, if present.
5592	*/
5593	VGA_SAVED_STATE_GET_MARKER_RETURN_ON_MISMATCH(pSSM, uVersion, 1);
5594	bool fWithHgsmi = uVersion == VGA_SAVEDSTATE_VERSION_HGSMI;
5595	if (uVersion > VGA_SAVEDSTATE_VERSION_HGSMI)
5596	{
5597	rc = SSMR3GetBool(pSSM, &fWithHgsmi);
5598	AssertRCReturn(rc, rc);
5599	}
5600	if (fWithHgsmi)
5601	{
5602	#ifdef VBOX_WITH_HGSMI
5603	rc = vboxVBVALoadStateExec(pDevIns, pSSM, uVersion);
5604	AssertRCReturn(rc, rc);
5605	#else
5606	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("HGSMI is not compiled in, but it is present in the saved state"));
5607	#endif
5608	}
5609
5610	VGA_SAVED_STATE_GET_MARKER_RETURN_ON_MISMATCH(pSSM, uVersion, 3);
5611	if (uVersion >= VGA_SAVEDSTATE_VERSION_3D)
5612	{
5613	uint32_t u32;
5614	rc = SSMR3GetU32(pSSM, &u32);
5615	if (u32)
5616	{
5617	#ifdef VBOX_WITH_VDMA
5618	if (u32 == 1)
5619	{
5620	rc = vboxVDMASaveLoadExecPerform(pThis->pVdma, pSSM, uVersion);
5621	AssertRCReturn(rc, rc);
5622	}
5623	else
5624	#endif
5625	{
5626	LogRel(("invalid CmdVbva version info\n"));
5627	return VERR_VERSION_MISMATCH;
5628	}
5629	}
5630	}
5631
5632	VGA_SAVED_STATE_GET_MARKER_RETURN_ON_MISMATCH(pSSM, uVersion, 5);
5633	#ifdef VBOX_WITH_VMSVGA
5634	if (pThis->fVMSVGAEnabled)
5635	{
5636	rc = vmsvgaLoadExec(pDevIns, pSSM, uVersion, uPass);
5637	AssertRCReturn(rc, rc);
5638	}
5639	#endif
5640	VGA_SAVED_STATE_GET_MARKER_RETURN_ON_MISMATCH(pSSM, uVersion, 6);
5641	}
5642	return VINF_SUCCESS;
5643	}
5644
5645
5646	/**
5647	* @copydoc FNSSMDEVLOADDONE
5648	*/
5649	static DECLCALLBACK(int) vgaR3LoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
5650	{
5651	int rc = VINF_SUCCESS;
5652
5653	#ifdef VBOX_WITH_HGSMI
5654	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
5655	rc = vboxVBVALoadStateDone(pDevIns, pSSM);
5656	AssertRCReturn(rc, rc);
5657	# ifdef VBOX_WITH_VDMA
5658	rc = vboxVDMASaveLoadDone(pThis->pVdma);
5659	AssertRCReturn(rc, rc);
5660	# endif
5661	/* Now update the current VBVA state which depends on VBE registers. vboxVBVALoadStateDone cleared the state. */
5662	VBVAOnVBEChanged(pThis);
5663	#endif
5664	#ifdef VBOX_WITH_VMSVGA
5665	if (pThis->fVMSVGAEnabled)
5666	{
5667	rc = vmsvgaLoadDone(pDevIns);
5668	AssertRCReturn(rc, rc);
5669	}
5670	#endif
5671	return rc;
5672	}
5673
5674
5675	/* -=-=-=-=-=- Ring 3: Device callbacks -=-=-=-=-=- */
5676
5677	/**
5678	* @interface_method_impl{PDMDEVREG,pfnReset}
5679	*/
5680	static DECLCALLBACK(void) vgaR3Reset(PPDMDEVINS pDevIns)
5681	{
5682	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
5683	char *pchStart;
5684	char *pchEnd;
5685	LogFlow(("vgaReset\n"));
5686
5687	if (pThis->pVdma)
5688	vboxVDMAReset(pThis->pVdma);
5689
5690	#ifdef VBOX_WITH_VMSVGA
5691	if (pThis->fVMSVGAEnabled)
5692	vmsvgaReset(pDevIns);
5693	#endif
5694
5695	#ifdef VBOX_WITH_HGSMI
5696	VBVAReset(pThis);
5697	#endif /* VBOX_WITH_HGSMI */
5698
5699
5700	/* Clear the VRAM ourselves. */
5701	if (pThis->vram_ptrR3 && pThis->vram_size)
5702	memset(pThis->vram_ptrR3, 0, pThis->vram_size);
5703
5704	/*
5705	* Zero most of it.
5706	*
5707	* Unlike vga_reset we're leaving out a few members which we believe
5708	* must remain unchanged....
5709	*/
5710	/* 1st part. */
5711	pchStart = (char *)&pThis->latch;
5712	pchEnd = (char *)&pThis->invalidated_y_table;
5713	memset(pchStart, 0, pchEnd - pchStart);
5714
5715	/* 2nd part. */
5716	pchStart = (char *)&pThis->last_palette;
5717	pchEnd = (char *)&pThis->u32Marker;
5718	memset(pchStart, 0, pchEnd - pchStart);
5719
5720
5721	/*
5722	* Restore and re-init some bits.
5723	*/
5724	pThis->get_bpp = vga_get_bpp;
5725	pThis->get_offsets = vga_get_offsets;
5726	pThis->get_resolution = vga_get_resolution;
5727	pThis->graphic_mode = -1; /* Force full update. */
5728	#ifdef CONFIG_BOCHS_VBE
5729	pThis->vbe_regs[VBE_DISPI_INDEX_ID] = VBE_DISPI_ID0;
5730	pThis->vbe_regs[VBE_DISPI_INDEX_VBOX_VIDEO] = 0;
5731	pThis->vbe_regs[VBE_DISPI_INDEX_FB_BASE_HI] = pThis->GCPhysVRAM >> 16;
5732	pThis->vbe_bank_max = (pThis->vram_size >> 16) - 1;
5733	#endif /* CONFIG_BOCHS_VBE */
5734
5735	/*
5736	* Reset the LBF mapping.
5737	*/
5738	pThis->fLFBUpdated = false;
5739	if ( ( pThis->fGCEnabled
5740	\|\| pThis->fR0Enabled)
5741	&& pThis->GCPhysVRAM
5742	&& pThis->GCPhysVRAM != NIL_RTGCPHYS)
5743	{
5744	int rc = PGMHandlerPhysicalReset(PDMDevHlpGetVM(pDevIns), pThis->GCPhysVRAM);
5745	AssertRC(rc);
5746	}
5747	if (pThis->fRemappedVGA)
5748	{
5749	IOMMMIOResetRegion(PDMDevHlpGetVM(pDevIns), 0x000a0000);
5750	pThis->fRemappedVGA = false;
5751	}
5752
5753	/*
5754	* Reset the logo data.
5755	*/
5756	pThis->LogoCommand = LOGO_CMD_NOP;
5757	pThis->offLogoData = 0;
5758
5759	/* notify port handler */
5760	if (pThis->pDrv)
5761	{
5762	PDMCritSectLeave(&pThis->CritSect); /* hack around lock order issue. */
5763	pThis->pDrv->pfnReset(pThis->pDrv);
5764	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
5765	}
5766
5767	/* Reset latched access mask. */
5768	pThis->uMaskLatchAccess = 0x3ff;
5769	pThis->cLatchAccesses = 0;
5770	pThis->u64LastLatchedAccess = 0;
5771	pThis->iMask = 0;
5772
5773	/* Reset retrace emulation. */
5774	memset(&pThis->retrace_state, 0, sizeof(pThis->retrace_state));
5775	}
5776
5777
5778	/**
5779	* @interface_method_impl{PDMDEVREG,pfnRelocate}
5780	*/
5781	static DECLCALLBACK(void) vgaR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
5782	{
5783	if (offDelta)
5784	{
5785	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
5786	LogFlow(("vgaRelocate: offDelta = %08X\n", offDelta));
5787
5788	pThis->vram_ptrRC += offDelta;
5789	pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
5790	}
5791	}
5792
5793
5794	/**
5795	* @interface_method_impl{PDMDEVREG,pfnAttach}
5796	*
5797	* This is like plugging in the monitor after turning on the PC.
5798	*/
5799	static DECLCALLBACK(int) vgaAttach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
5800	{
5801	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
5802
5803	AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
5804	("VGA device does not support hotplugging\n"),
5805	VERR_INVALID_PARAMETER);
5806
5807	switch (iLUN)
5808	{
5809	/* LUN #0: Display port. */
5810	case 0:
5811	{
5812	int rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->IBase, &pThis->pDrvBase, "Display Port");
5813	if (RT_SUCCESS(rc))
5814	{
5815	pThis->pDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIDISPLAYCONNECTOR);
5816	if (pThis->pDrv)
5817	{
5818	/* pThis->pDrv->pbData can be NULL when there is no framebuffer. */
5819	if ( pThis->pDrv->pfnRefresh
5820	&& pThis->pDrv->pfnResize
5821	&& pThis->pDrv->pfnUpdateRect)
5822	rc = VINF_SUCCESS;
5823	else
5824	{
5825	Assert(pThis->pDrv->pfnRefresh);
5826	Assert(pThis->pDrv->pfnResize);
5827	Assert(pThis->pDrv->pfnUpdateRect);
5828	pThis->pDrv = NULL;
5829	pThis->pDrvBase = NULL;
5830	rc = VERR_INTERNAL_ERROR;
5831	}
5832	#ifdef VBOX_WITH_VIDEOHWACCEL
5833	if(rc == VINF_SUCCESS)
5834	{
5835	rc = vbvaVHWAConstruct(pThis);
5836	if (rc != VERR_NOT_IMPLEMENTED)
5837	AssertRC(rc);
5838	}
5839	#endif
5840	}
5841	else
5842	{
5843	AssertMsgFailed(("LUN #0 doesn't have a display connector interface! rc=%Rrc\n", rc));
5844	pThis->pDrvBase = NULL;
5845	rc = VERR_PDM_MISSING_INTERFACE;
5846	}
5847	}
5848	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
5849	{
5850	Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
5851	rc = VINF_SUCCESS;
5852	}
5853	else
5854	AssertLogRelMsgFailed(("Failed to attach LUN #0! rc=%Rrc\n", rc));
5855	return rc;
5856	}
5857
5858	default:
5859	AssertMsgFailed(("Invalid LUN #%d\n", iLUN));
5860	return VERR_PDM_NO_SUCH_LUN;
5861	}
5862	}
5863
5864
5865	/**
5866	* @interface_method_impl{PDMDEVREG,pfnDetach}
5867	*
5868	* This is like unplugging the monitor while the PC is still running.
5869	*/
5870	static DECLCALLBACK(void) vgaDetach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
5871	{
5872	/*
5873	* Reset the interfaces and update the controller state.
5874	*/
5875	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
5876
5877	AssertMsg(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
5878	("VGA device does not support hotplugging\n"));
5879
5880	switch (iLUN)
5881	{
5882	/* LUN #0: Display port. */
5883	case 0:
5884	pThis->pDrv = NULL;
5885	pThis->pDrvBase = NULL;
5886	break;
5887
5888	default:
5889	AssertMsgFailed(("Invalid LUN #%d\n", iLUN));
5890	break;
5891	}
5892	}
5893
5894
5895	/**
5896	* @interface_method_impl{PDMDEVREG,pfnDestruct}
5897	*/
5898	static DECLCALLBACK(int) vgaR3Destruct(PPDMDEVINS pDevIns)
5899	{
5900	PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
5901
5902	#ifdef VBE_NEW_DYN_LIST
5903	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
5904	LogFlow(("vgaR3Destruct:\n"));
5905
5906	# ifdef VBOX_WITH_VDMA
5907	if (pThis->pVdma)
5908	vboxVDMADestruct(pThis->pVdma);
5909	# endif
5910
5911	#ifdef VBOX_WITH_VMSVGA
5912	if (pThis->fVMSVGAEnabled)
5913	vmsvgaDestruct(pDevIns);
5914	#endif
5915
5916	/*
5917	* Free MM heap pointers.
5918	*/
5919	if (pThis->pbVBEExtraData)
5920	{
5921	MMR3HeapFree(pThis->pbVBEExtraData);
5922	pThis->pbVBEExtraData = NULL;
5923	}
5924	#endif /* VBE_NEW_DYN_LIST */
5925	if (pThis->pbVgaBios)
5926	{
5927	MMR3HeapFree(pThis->pbVgaBios);
5928	pThis->pbVgaBios = NULL;
5929	}
5930
5931	if (pThis->pszVgaBiosFile)
5932	{
5933	MMR3HeapFree(pThis->pszVgaBiosFile);
5934	pThis->pszVgaBiosFile = NULL;
5935	}
5936
5937	if (pThis->pszLogoFile)
5938	{
5939	MMR3HeapFree(pThis->pszLogoFile);
5940	pThis->pszLogoFile = NULL;
5941	}
5942
5943	PDMR3CritSectDelete(&pThis->CritSect);
5944	return VINF_SUCCESS;
5945	}
5946
5947
5948	/**
5949	* Adjust VBE mode information
5950	*
5951	* Depending on the configured VRAM size, certain parts of VBE mode
5952	* information must be updated.
5953	*
5954	* @param pThis The device instance data.
5955	* @param pMode The mode information structure.
5956	*/
5957	static void vgaAdjustModeInfo(PVGASTATE pThis, ModeInfoListItem *pMode)
5958	{
5959	int maxPage;
5960	int bpl;
5961
5962
5963	/* For 4bpp modes, the planes are "stacked" on top of each other. */
5964	bpl = pMode->info.BytesPerScanLine * pMode->info.NumberOfPlanes;
5965	/* The "number of image pages" is really the max page index... */
5966	maxPage = pThis->vram_size / (pMode->info.YResolution * bpl) - 1;
5967	Assert(maxPage >= 0);
5968	if (maxPage > 255)
5969	maxPage = 255; /* 8-bit value. */
5970	pMode->info.NumberOfImagePages = maxPage;
5971	pMode->info.LinNumberOfPages = maxPage;
5972	}
5973
5974
5975	/**
5976	* @interface_method_impl{PDMDEVREG,pfnConstruct}
5977	*/
5978	static DECLCALLBACK(int) vgaR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
5979	{
5980
5981	static bool s_fExpandDone = false;
5982	int rc;
5983	unsigned i;
5984	#ifdef VBE_NEW_DYN_LIST
5985	uint32_t cCustomModes;
5986	uint32_t cyReduction;
5987	uint32_t cbPitch;
5988	PVBEHEADER pVBEDataHdr;
5989	ModeInfoListItem *pCurMode;
5990	unsigned cb;
5991	#endif
5992	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
5993	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
5994	PVM pVM = PDMDevHlpGetVM(pDevIns);
5995
5996	Assert(iInstance == 0);
5997	Assert(pVM);
5998
5999	/*
6000	* Init static data.
6001	*/
6002	if (!s_fExpandDone)
6003	{
6004	s_fExpandDone = true;
6005	vga_init_expand();
6006	}
6007
6008	/*
6009	* Validate configuration.
6010	*/
6011	if (!CFGMR3AreValuesValid(pCfg, "VRamSize\0"
6012	"MonitorCount\0"
6013	"GCEnabled\0"
6014	"R0Enabled\0"
6015	"FadeIn\0"
6016	"FadeOut\0"
6017	"LogoTime\0"
6018	"LogoFile\0"
6019	"ShowBootMenu\0"
6020	"BiosRom\0"
6021	"RealRetrace\0"
6022	"CustomVideoModes\0"
6023	"HeightReduction\0"
6024	"CustomVideoMode1\0"
6025	"CustomVideoMode2\0"
6026	"CustomVideoMode3\0"
6027	"CustomVideoMode4\0"
6028	"CustomVideoMode5\0"
6029	"CustomVideoMode6\0"
6030	"CustomVideoMode7\0"
6031	"CustomVideoMode8\0"
6032	"CustomVideoMode9\0"
6033	"CustomVideoMode10\0"
6034	"CustomVideoMode11\0"
6035	"CustomVideoMode12\0"
6036	"CustomVideoMode13\0"
6037	"CustomVideoMode14\0"
6038	"CustomVideoMode15\0"
6039	"CustomVideoMode16\0"
6040	"MaxBiosXRes\0"
6041	"MaxBiosYRes\0"
6042	#ifdef VBOX_WITH_VMSVGA
6043	"VMSVGAEnabled\0"
6044	#endif
6045	#ifdef VBOX_WITH_VMSVGA3D
6046	"VMSVGA3dEnabled\0"
6047	"HostWindowId\0"
6048	#endif
6049	))
6050	return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
6051	N_("Invalid configuration for vga device"));
6052
6053	/*
6054	* Init state data.
6055	*/
6056	rc = CFGMR3QueryU32Def(pCfg, "VRamSize", &pThis->vram_size, VGA_VRAM_DEFAULT);
6057	AssertLogRelRCReturn(rc, rc);
6058	if (pThis->vram_size > VGA_VRAM_MAX)
6059	return PDMDevHlpVMSetError(pDevIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
6060	"VRamSize is too large, %#x, max %#x", pThis->vram_size, VGA_VRAM_MAX);
6061	if (pThis->vram_size < VGA_VRAM_MIN)
6062	return PDMDevHlpVMSetError(pDevIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
6063	"VRamSize is too small, %#x, max %#x", pThis->vram_size, VGA_VRAM_MIN);
6064	if (pThis->vram_size & (_256K - 1)) /* Make sure there are no partial banks even in planar modes. */
6065	return PDMDevHlpVMSetError(pDevIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
6066	"VRamSize is not a multiple of 256K (%#x)", pThis->vram_size);
6067
6068	rc = CFGMR3QueryU32Def(pCfg, "MonitorCount", &pThis->cMonitors, 1);
6069	AssertLogRelRCReturn(rc, rc);
6070
6071	rc = CFGMR3QueryBoolDef(pCfg, "GCEnabled", &pThis->fGCEnabled, true);
6072	AssertLogRelRCReturn(rc, rc);
6073
6074	rc = CFGMR3QueryBoolDef(pCfg, "R0Enabled", &pThis->fR0Enabled, true);
6075	AssertLogRelRCReturn(rc, rc);
6076	Log(("VGA: VRamSize=%#x fGCenabled=%RTbool fR0Enabled=%RTbool\n", pThis->vram_size, pThis->fGCEnabled, pThis->fR0Enabled));
6077
6078	#ifdef VBOX_WITH_VMSVGA
6079	rc = CFGMR3QueryBoolDef(pCfg, "VMSVGAEnabled", &pThis->fVMSVGAEnabled, false);
6080	AssertLogRelRCReturn(rc, rc);
6081	Log(("VMSVGA: VMSVGAEnabled = %d\n", pThis->fVMSVGAEnabled));
6082	#endif
6083	#ifdef VBOX_WITH_VMSVGA3D
6084	rc = CFGMR3QueryBoolDef(pCfg, "VMSVGA3dEnabled", &pThis->svga.f3DEnabled, false);
6085	AssertLogRelRCReturn(rc, rc);
6086	rc = CFGMR3QueryU64Def(pCfg, "HostWindowId", &pThis->svga.u64HostWindowId, 0);
6087	AssertLogRelRCReturn(rc, rc);
6088	Log(("VMSVGA: VMSVGA3dEnabled = %d\n", pThis->svga.f3DEnabled));
6089	Log(("VMSVGA: HostWindowId = 0x%x\n", pThis->svga.u64HostWindowId));
6090	#endif
6091
6092	pThis->pDevInsR3 = pDevIns;
6093	pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
6094	pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
6095
6096	vgaR3Reset(pDevIns);
6097
6098	/* The PCI devices configuration. */
6099	#ifdef VBOX_WITH_VMSVGA
6100	if (pThis->fVMSVGAEnabled)
6101	{
6102	/* Extend our VGA device with VMWare SVGA functionality. */
6103	PCIDevSetVendorId(&pThis->Dev, PCI_VENDOR_ID_VMWARE);
6104	PCIDevSetDeviceId(&pThis->Dev, PCI_DEVICE_ID_VMWARE_SVGA2);
6105	PCIDevSetSubSystemVendorId(&pThis->Dev, PCI_VENDOR_ID_VMWARE);
6106	PCIDevSetSubSystemId(&pThis->Dev, PCI_DEVICE_ID_VMWARE_SVGA2);
6107	}
6108	else
6109	{
6110	#endif /* VBOX_WITH_VMSVGA */
6111	PCIDevSetVendorId( &pThis->Dev, 0x80ee); /* PCI vendor, just a free bogus value */
6112	PCIDevSetDeviceId( &pThis->Dev, 0xbeef);
6113	#ifdef VBOX_WITH_VMSVGA
6114	}
6115	#endif
6116	PCIDevSetClassSub( &pThis->Dev, 0x00); /* VGA controller */
6117	PCIDevSetClassBase( &pThis->Dev, 0x03);
6118	PCIDevSetHeaderType(&pThis->Dev, 0x00);
6119	#if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) \|\| defined(VBOX_WITH_VDMA) \|\| defined(VBOX_WITH_WDDM))
6120	PCIDevSetInterruptPin(&pThis->Dev, 1);
6121	#endif
6122
6123	/* the interfaces. */
6124	pThis->IBase.pfnQueryInterface = vgaPortQueryInterface;
6125
6126	pThis->IPort.pfnUpdateDisplay = vgaPortUpdateDisplay;
6127	pThis->IPort.pfnUpdateDisplayAll = vgaPortUpdateDisplayAll;
6128	pThis->IPort.pfnQueryVideoMode = vgaPortQueryVideoMode;
6129	pThis->IPort.pfnSetRefreshRate = vgaPortSetRefreshRate;
6130	pThis->IPort.pfnTakeScreenshot = vgaPortTakeScreenshot;
6131	pThis->IPort.pfnFreeScreenshot = vgaPortFreeScreenshot;
6132	pThis->IPort.pfnDisplayBlt = vgaPortDisplayBlt;
6133	pThis->IPort.pfnUpdateDisplayRect = vgaPortUpdateDisplayRect;
6134	pThis->IPort.pfnCopyRect = vgaPortCopyRect;
6135	pThis->IPort.pfnSetRenderVRAM = vgaPortSetRenderVRAM;
6136	#ifdef VBOX_WITH_VMSVGA
6137	pThis->IPort.pfnSetViewport = vmsvgaPortSetViewport;
6138	#else
6139	pThis->IPort.pfnSetViewport = NULL;
6140	#endif
6141	pThis->IPort.pfnSendModeHint = vbvaPortSendModeHint;
6142	pThis->IPort.pfnReportHostCursorCapabilities
6143	= vbvaPortReportHostCursorCapabilities;
6144	pThis->IPort.pfnReportHostCursorPosition
6145	= vbvaPortReportHostCursorPosition;
6146
6147	#if defined(VBOX_WITH_HGSMI)
6148	# if defined(VBOX_WITH_VIDEOHWACCEL)
6149	pThis->IVBVACallbacks.pfnVHWACommandCompleteAsync = vbvaVHWACommandCompleteAsync;
6150	# endif
6151	#if defined(VBOX_WITH_CRHGSMI)
6152	pThis->IVBVACallbacks.pfnCrHgsmiCommandCompleteAsync = vboxVDMACrHgsmiCommandCompleteAsync;
6153	pThis->IVBVACallbacks.pfnCrHgsmiControlCompleteAsync = vboxVDMACrHgsmiControlCompleteAsync;
6154
6155	pThis->IVBVACallbacks.pfnCrCtlSubmit = vboxCmdVBVACmdHostCtl;
6156	pThis->IVBVACallbacks.pfnCrCtlSubmitSync = vboxCmdVBVACmdHostCtlSync;
6157	# endif
6158	#endif
6159
6160	pThis->ILeds.pfnQueryStatusLed = vgaPortQueryStatusLed;
6161
6162	RT_ZERO(pThis->Led3D);
6163	pThis->Led3D.u32Magic = PDMLED_MAGIC;
6164
6165	/*
6166	* We use our own critical section to avoid unncessary pointer indirections
6167	* in interface methods (as well as for historical reasons).
6168	*/
6169	rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, RT_SRC_POS, "VGA#%u", iInstance);
6170	AssertRCReturn(rc, rc);
6171	rc = PDMDevHlpSetDeviceCritSect(pDevIns, &pThis->CritSect);
6172	AssertRCReturn(rc, rc);
6173
6174	/*
6175	* Allocate the VRAM and map the first 512KB of it into GC so we can speed up VGA support.
6176	*/
6177	#ifdef VBOX_WITH_VMSVGA
6178	int iPCIRegionVRAM = (pThis->fVMSVGAEnabled) ? 1 : 0;
6179
6180	if (pThis->fVMSVGAEnabled)
6181	{
6182	/*
6183	* Allocate and initialize the FIFO MMIO2 memory.
6184	*/
6185	rc = PDMDevHlpMMIO2Register(pDevIns, 2 /iRegion/, VMSVGA_FIFO_SIZE, 0 /fFlags/, (void **)&pThis->svga.pFIFOR3, "VMSVGA-FIFO");
6186	if (RT_FAILURE(rc))
6187	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
6188	N_("Failed to allocate %u bytes of memory for the VMSVGA device"), VMSVGA_FIFO_SIZE);
6189	pThis->svga.pFIFOR0 = (RTR0PTR)pThis->svga.pFIFOR3;
6190	pThis->svga.cbFIFO = VMSVGA_FIFO_SIZE;
6191	}
6192	#else
6193	int iPCIRegionVRAM = 0;
6194	#endif
6195	rc = PDMDevHlpMMIO2Register(pDevIns, iPCIRegionVRAM, pThis->vram_size, 0, (void **)&pThis->vram_ptrR3, "VRam");
6196	AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMMIO2Register(%#x,) -> %Rrc\n", pThis->vram_size, rc), rc);
6197	pThis->vram_ptrR0 = (RTR0PTR)pThis->vram_ptrR3; /** @todo @bugref{1865} Map parts into R0 or just use PGM access (Mac only). */
6198
6199	if (pThis->fGCEnabled)
6200	{
6201	RTRCPTR pRCMapping = 0;
6202	rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, iPCIRegionVRAM, 0 /* off */, VGA_MAPPING_SIZE, "VGA VRam", &pRCMapping);
6203	AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMMHyperMapMMIO2(%#x,) -> %Rrc\n", VGA_MAPPING_SIZE, rc), rc);
6204	pThis->vram_ptrRC = pRCMapping;
6205	# ifdef VBOX_WITH_VMSVGA
6206	/* Don't need a mapping in RC */
6207	# endif
6208	}
6209
6210	#if defined(VBOX_WITH_2X_4GB_ADDR_SPACE)
6211	if (pThis->fR0Enabled)
6212	{
6213	RTR0PTR pR0Mapping = 0;
6214	rc = PDMDevHlpMMIO2MapKernel(pDevIns, iPCIRegionVRAM, 0 /* off */, VGA_MAPPING_SIZE, "VGA VRam", &pR0Mapping);
6215	AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMapMMIO2IntoR0(%#x,) -> %Rrc\n", VGA_MAPPING_SIZE, rc), rc);
6216	pThis->vram_ptrR0 = pR0Mapping;
6217	# ifdef VBOX_WITH_VMSVGA
6218	if (pThis->fVMSVGAEnabled)
6219	{
6220	RTR0PTR pR0Mapping = 0;
6221	rc = PDMDevHlpMMIO2MapKernel(pDevIns, 2 /* iRegion /, 0 / off */, VMSVGA_FIFO_SIZE, "VMSVGA-FIFO", &pR0Mapping);
6222	AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMapMMIO2IntoR0(%#x,) -> %Rrc\n", VMSVGA_FIFO_SIZE, rc), rc);
6223	pThis->svga.pFIFOR0 = pR0Mapping;
6224	}
6225	# endif
6226	}
6227	#endif
6228
6229	/*
6230	* Register access handler types.
6231	*/
6232	rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE,
6233	vgaLFBAccessHandler,
6234	g_DeviceVga.szR0Mod, "vgaLFBAccessHandler", "vgaLbfAccessPfHandler",
6235	g_DeviceVga.szRCMod, "vgaLFBAccessHandler", "vgaLbfAccessPfHandler",
6236	"VGA LFB", &pThis->hLfbAccessHandlerType);
6237	AssertRCReturn(rc, rc);
6238
6239
6240	/*
6241	* Register I/O ports.
6242	*/
6243	rc = PDMDevHlpIOPortRegister(pDevIns, 0x3c0, 16, NULL, vgaIOPortWrite, vgaIOPortRead, NULL, NULL, "VGA - 3c0");
6244	if (RT_FAILURE(rc))
6245	return rc;
6246	rc = PDMDevHlpIOPortRegister(pDevIns, 0x3b4, 2, NULL, vgaIOPortWrite, vgaIOPortRead, NULL, NULL, "VGA - 3b4");
6247	if (RT_FAILURE(rc))
6248	return rc;
6249	rc = PDMDevHlpIOPortRegister(pDevIns, 0x3ba, 1, NULL, vgaIOPortWrite, vgaIOPortRead, NULL, NULL, "VGA - 3ba");
6250	if (RT_FAILURE(rc))
6251	return rc;
6252	rc = PDMDevHlpIOPortRegister(pDevIns, 0x3d4, 2, NULL, vgaIOPortWrite, vgaIOPortRead, NULL, NULL, "VGA - 3d4");
6253	if (RT_FAILURE(rc))
6254	return rc;
6255	rc = PDMDevHlpIOPortRegister(pDevIns, 0x3da, 1, NULL, vgaIOPortWrite, vgaIOPortRead, NULL, NULL, "VGA - 3da");
6256	if (RT_FAILURE(rc))
6257	return rc;
6258	#ifdef VBOX_WITH_HGSMI
6259	/* Use reserved VGA IO ports for HGSMI. */
6260	rc = PDMDevHlpIOPortRegister(pDevIns, VGA_PORT_HGSMI_HOST, 4, NULL, vgaR3IOPortHGSMIWrite, vgaR3IOPortHGSMIRead, NULL, NULL, "VGA - 3b0 (HGSMI host)");
6261	if (RT_FAILURE(rc))
6262	return rc;
6263	rc = PDMDevHlpIOPortRegister(pDevIns, VGA_PORT_HGSMI_GUEST, 4, NULL, vgaR3IOPortHGSMIWrite, vgaR3IOPortHGSMIRead, NULL, NULL, "VGA - 3d0 (HGSMI guest)");
6264	if (RT_FAILURE(rc))
6265	return rc;
6266	#endif /* VBOX_WITH_HGSMI */
6267
6268	#ifdef CONFIG_BOCHS_VBE
6269	rc = PDMDevHlpIOPortRegister(pDevIns, 0x1ce, 1, NULL, vgaIOPortWriteVBEIndex, vgaIOPortReadVBEIndex, NULL, NULL, "VGA/VBE - Index");
6270	if (RT_FAILURE(rc))
6271	return rc;
6272	rc = PDMDevHlpIOPortRegister(pDevIns, 0x1cf, 1, NULL, vgaIOPortWriteVBEData, vgaIOPortReadVBEData, NULL, NULL, "VGA/VBE - Data");
6273	if (RT_FAILURE(rc))
6274	return rc;
6275	#endif /* CONFIG_BOCHS_VBE */
6276
6277	/* guest context extension */
6278	if (pThis->fGCEnabled)
6279	{
6280	rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0x3c0, 16, 0, "vgaIOPortWrite", "vgaIOPortRead", NULL, NULL, "VGA - 3c0 (GC)");
6281	if (RT_FAILURE(rc))
6282	return rc;
6283	rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0x3b4, 2, 0, "vgaIOPortWrite", "vgaIOPortRead", NULL, NULL, "VGA - 3b4 (GC)");
6284	if (RT_FAILURE(rc))
6285	return rc;
6286	rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0x3ba, 1, 0, "vgaIOPortWrite", "vgaIOPortRead", NULL, NULL, "VGA - 3ba (GC)");
6287	if (RT_FAILURE(rc))
6288	return rc;
6289	rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0x3d4, 2, 0, "vgaIOPortWrite", "vgaIOPortRead", NULL, NULL, "VGA - 3d4 (GC)");
6290	if (RT_FAILURE(rc))
6291	return rc;
6292	rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0x3da, 1, 0, "vgaIOPortWrite", "vgaIOPortRead", NULL, NULL, "VGA - 3da (GC)");
6293	if (RT_FAILURE(rc))
6294	return rc;
6295	#ifdef CONFIG_BOCHS_VBE
6296	rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0x1ce, 1, 0, "vgaIOPortWriteVBEIndex", "vgaIOPortReadVBEIndex", NULL, NULL, "VGA/VBE - Index (GC)");
6297	if (RT_FAILURE(rc))
6298	return rc;
6299	rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0x1cf, 1, 0, "vgaIOPortWriteVBEData", "vgaIOPortReadVBEData", NULL, NULL, "VGA/VBE - Data (GC)");
6300	if (RT_FAILURE(rc))
6301	return rc;
6302	#endif /* CONFIG_BOCHS_VBE */
6303	}
6304
6305	/* R0 context extension */
6306	if (pThis->fR0Enabled)
6307	{
6308	rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0x3c0, 16, 0, "vgaIOPortWrite", "vgaIOPortRead", NULL, NULL, "VGA - 3c0 (GC)");
6309	if (RT_FAILURE(rc))
6310	return rc;
6311	rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0x3b4, 2, 0, "vgaIOPortWrite", "vgaIOPortRead", NULL, NULL, "VGA - 3b4 (GC)");
6312	if (RT_FAILURE(rc))
6313	return rc;
6314	rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0x3ba, 1, 0, "vgaIOPortWrite", "vgaIOPortRead", NULL, NULL, "VGA - 3ba (GC)");
6315	if (RT_FAILURE(rc))
6316	return rc;
6317	rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0x3d4, 2, 0, "vgaIOPortWrite", "vgaIOPortRead", NULL, NULL, "VGA - 3d4 (GC)");
6318	if (RT_FAILURE(rc))
6319	return rc;
6320	rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0x3da, 1, 0, "vgaIOPortWrite", "vgaIOPortRead", NULL, NULL, "VGA - 3da (GC)");
6321	if (RT_FAILURE(rc))
6322	return rc;
6323	#ifdef CONFIG_BOCHS_VBE
6324	rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0x1ce, 1, 0, "vgaIOPortWriteVBEIndex", "vgaIOPortReadVBEIndex", NULL, NULL, "VGA/VBE - Index (GC)");
6325	if (RT_FAILURE(rc))
6326	return rc;
6327	rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0x1cf, 1, 0, "vgaIOPortWriteVBEData", "vgaIOPortReadVBEData", NULL, NULL, "VGA/VBE - Data (GC)");
6328	if (RT_FAILURE(rc))
6329	return rc;
6330	#endif /* CONFIG_BOCHS_VBE */
6331	}
6332
6333	/* vga mmio */
6334	rc = PDMDevHlpMMIORegisterEx(pDevIns, 0x000a0000, 0x00020000, NULL /pvUser/,
6335	IOMMMIO_FLAGS_READ_PASSTHRU \| IOMMMIO_FLAGS_WRITE_PASSTHRU,
6336	vgaMMIOWrite, vgaMMIORead, vgaMMIOFill, "VGA - VGA Video Buffer");
6337	if (RT_FAILURE(rc))
6338	return rc;
6339	if (pThis->fGCEnabled)
6340	{
6341	rc = PDMDevHlpMMIORegisterRCEx(pDevIns, 0x000a0000, 0x00020000, NIL_RTRCPTR /pvUser/,
6342	"vgaMMIOWrite", "vgaMMIORead", "vgaMMIOFill");
6343	if (RT_FAILURE(rc))
6344	return rc;
6345	}
6346	if (pThis->fR0Enabled)
6347	{
6348	rc = PDMDevHlpMMIORegisterR0Ex(pDevIns, 0x000a0000, 0x00020000, NIL_RTR0PTR /pvUser/,
6349	"vgaMMIOWrite", "vgaMMIORead", "vgaMMIOFill");
6350	if (RT_FAILURE(rc))
6351	return rc;
6352	}
6353
6354	/* vga bios */
6355	rc = PDMDevHlpIOPortRegister(pDevIns, VBE_PRINTF_PORT, 1, NULL, vgaIOPortWriteBIOS, vgaIOPortReadBIOS, NULL, NULL, "VGA BIOS debug/panic");
6356	if (RT_FAILURE(rc))
6357	return rc;
6358	if (pThis->fR0Enabled)
6359	{
6360	rc = PDMDevHlpIOPortRegisterR0(pDevIns, VBE_PRINTF_PORT, 1, 0, "vgaIOPortWriteBIOS", "vgaIOPortReadBIOS", NULL, NULL, "VGA BIOS debug/panic");
6361	if (RT_FAILURE(rc))
6362	return rc;
6363	}
6364
6365	/*
6366	* Get the VGA BIOS ROM file name.
6367	*/
6368	rc = CFGMR3QueryStringAlloc(pCfg, "BiosRom", &pThis->pszVgaBiosFile);
6369	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
6370	{
6371	pThis->pszVgaBiosFile = NULL;
6372	rc = VINF_SUCCESS;
6373	}
6374	else if (RT_FAILURE(rc))
6375	return PDMDEV_SET_ERROR(pDevIns, rc,
6376	N_("Configuration error: Querying \"BiosRom\" as a string failed"));
6377	else if (!*pThis->pszVgaBiosFile)
6378	{
6379	MMR3HeapFree(pThis->pszVgaBiosFile);
6380	pThis->pszVgaBiosFile = NULL;
6381	}
6382
6383	/*
6384	* Determine the VGA BIOS ROM size, open specified ROM file in the process.
6385	*/
6386	RTFILE FileVgaBios = NIL_RTFILE;
6387	if (pThis->pszVgaBiosFile)
6388	{
6389	rc = RTFileOpen(&FileVgaBios, pThis->pszVgaBiosFile,
6390	RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
6391	if (RT_SUCCESS(rc))
6392	{
6393	rc = RTFileGetSize(FileVgaBios, &pThis->cbVgaBios);
6394	if (RT_SUCCESS(rc))
6395	{
6396	if ( RT_ALIGN(pThis->cbVgaBios, _4K) != pThis->cbVgaBios
6397	\|\| pThis->cbVgaBios > _64K
6398	\|\| pThis->cbVgaBios < 16 * _1K)
6399	rc = VERR_TOO_MUCH_DATA;
6400	}
6401	}
6402	if (RT_FAILURE(rc))
6403	{
6404	/*
6405	* In case of failure simply fall back to the built-in VGA BIOS ROM.
6406	*/
6407	Log(("vgaConstruct: Failed to open VGA BIOS ROM file '%s', rc=%Rrc!\n", pThis->pszVgaBiosFile, rc));
6408	RTFileClose(FileVgaBios);
6409	FileVgaBios = NIL_RTFILE;
6410	MMR3HeapFree(pThis->pszVgaBiosFile);
6411	pThis->pszVgaBiosFile = NULL;
6412	}
6413	}
6414
6415	/*
6416	* Attempt to get the VGA BIOS ROM data from file.
6417	*/
6418	if (pThis->pszVgaBiosFile)
6419	{
6420	/*
6421	* Allocate buffer for the VGA BIOS ROM data.
6422	*/
6423	pThis->pbVgaBios = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, pThis->cbVgaBios);
6424	if (pThis->pbVgaBios)
6425	{
6426	rc = RTFileRead(FileVgaBios, pThis->pbVgaBios, pThis->cbVgaBios, NULL);
6427	if (RT_FAILURE(rc))
6428	{
6429	AssertMsgFailed(("RTFileRead(,,%d,NULL) -> %Rrc\n", pThis->cbVgaBios, rc));
6430	MMR3HeapFree(pThis->pbVgaBios);
6431	pThis->pbVgaBios = NULL;
6432	}
6433	rc = VINF_SUCCESS;
6434	}
6435	else
6436	rc = VERR_NO_MEMORY;
6437	}
6438	else
6439	pThis->pbVgaBios = NULL;
6440
6441	/* cleanup */
6442	if (FileVgaBios != NIL_RTFILE)
6443	RTFileClose(FileVgaBios);
6444
6445	/* If we were unable to get the data from file for whatever reason, fall
6446	back to the built-in ROM image. */
6447	const uint8_t *pbVgaBiosBinary;
6448	uint64_t cbVgaBiosBinary;
6449	uint32_t fFlags = 0;
6450	if (pThis->pbVgaBios == NULL)
6451	{
6452	CPUMMICROARCH enmMicroarch = pVM ? pVM->cpum.ro.GuestFeatures.enmMicroarch : kCpumMicroarch_Intel_P6;
6453	if ( enmMicroarch == kCpumMicroarch_Intel_8086
6454	\|\| enmMicroarch == kCpumMicroarch_Intel_80186
6455	\|\| enmMicroarch == kCpumMicroarch_NEC_V20
6456	\|\| enmMicroarch == kCpumMicroarch_NEC_V30)
6457	{
6458	pbVgaBiosBinary = g_abVgaBiosBinary8086;
6459	cbVgaBiosBinary = g_cbVgaBiosBinary8086;
6460	LogRel(("VGA: Using the 8086 BIOS image!\n"));
6461	}
6462	else if (enmMicroarch == kCpumMicroarch_Intel_80286)
6463	{
6464	pbVgaBiosBinary = g_abVgaBiosBinary286;
6465	cbVgaBiosBinary = g_cbVgaBiosBinary286;
6466	LogRel(("VGA: Using the 286 BIOS image!\n"));
6467	}
6468	else
6469	{
6470	pbVgaBiosBinary = g_abVgaBiosBinary386;
6471	cbVgaBiosBinary = g_cbVgaBiosBinary386;
6472	LogRel(("VGA: Using the 386+ BIOS image.\n"));
6473	}
6474	fFlags = PGMPHYS_ROM_FLAGS_PERMANENT_BINARY;
6475	}
6476	else
6477	{
6478	pbVgaBiosBinary = pThis->pbVgaBios;
6479	cbVgaBiosBinary = pThis->cbVgaBios;
6480	}
6481
6482	AssertReleaseMsg(cbVgaBiosBinary <= _64K && cbVgaBiosBinary >= 32*_1K, ("cbVgaBiosBinary=%#x\n", cbVgaBiosBinary));
6483	AssertReleaseMsg(RT_ALIGN_Z(cbVgaBiosBinary, PAGE_SIZE) == cbVgaBiosBinary, ("cbVgaBiosBinary=%#x\n", cbVgaBiosBinary));
6484	/* Note! Because of old saved states we'll always register at least 36KB of ROM. */
6485	rc = PDMDevHlpROMRegister(pDevIns, 0x000c0000, RT_MAX(cbVgaBiosBinary, 36*_1K), pbVgaBiosBinary, cbVgaBiosBinary,
6486	fFlags, "VGA BIOS");
6487	if (RT_FAILURE(rc))
6488	return rc;
6489
6490	/*
6491	* Saved state.
6492	*/
6493	rc = PDMDevHlpSSMRegisterEx(pDevIns, VGA_SAVEDSTATE_VERSION, sizeof(*pThis), NULL,
6494	NULL, vgaR3LiveExec, NULL,
6495	vgaR3SavePrep, vgaR3SaveExec, vgaR3SaveDone,
6496	NULL, vgaR3LoadExec, vgaR3LoadDone);
6497	if (RT_FAILURE(rc))
6498	return rc;
6499
6500	/*
6501	* PCI device registration.
6502	*/
6503	rc = PDMDevHlpPCIRegister(pDevIns, &pThis->Dev);
6504	if (RT_FAILURE(rc))
6505	return rc;
6506	/AssertMsg(pThis->Dev.devfn == 16 \|\| iInstance != 0, ("pThis->Dev.devfn=%d\n", pThis->Dev.devfn));/
6507	if (pThis->Dev.devfn != 16 && iInstance == 0)
6508	Log(("!!WARNING!!: pThis->dev.devfn=%d (ignore if testcase or not started by Main)\n", pThis->Dev.devfn));
6509
6510	#ifdef VBOX_WITH_VMSVGA
6511	if (pThis->fVMSVGAEnabled)
6512	{
6513	/* Register the io command ports. */
6514	rc = PDMDevHlpPCIIORegionRegister (pDevIns, 0 /* iRegion */, 0x10, PCI_ADDRESS_SPACE_IO, vmsvgaR3IORegionMap);
6515	if (RT_FAILURE (rc))
6516	return rc;
6517	/* VMware's MetalKit doesn't like PCI_ADDRESS_SPACE_MEM_PREFETCH */
6518	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 1 /* iRegion /, pThis->vram_size, PCI_ADDRESS_SPACE_MEM / PCI_ADDRESS_SPACE_MEM_PREFETCH */, vgaR3IORegionMap);
6519	if (RT_FAILURE(rc))
6520	return rc;
6521	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2 /* iRegion /, VMSVGA_FIFO_SIZE, PCI_ADDRESS_SPACE_MEM / PCI_ADDRESS_SPACE_MEM_PREFETCH */, vmsvgaR3IORegionMap);
6522	if (RT_FAILURE(rc))
6523	return rc;
6524	}
6525	else
6526	#endif /* VBOX_WITH_VMSVGA */
6527	rc = PDMDevHlpPCIIORegionRegister(pDevIns, iPCIRegionVRAM, pThis->vram_size, PCI_ADDRESS_SPACE_MEM_PREFETCH, vgaR3IORegionMap);
6528	if (RT_FAILURE(rc))
6529	return rc;
6530
6531	/*
6532	* Create the refresh timer.
6533	*/
6534	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_REAL, vgaTimerRefresh,
6535	pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
6536	"VGA Refresh Timer", &pThis->RefreshTimer);
6537	if (RT_FAILURE(rc))
6538	return rc;
6539
6540	/*
6541	* Attach to the display.
6542	*/
6543	rc = vgaAttach(pDevIns, 0 /* display LUN # */, PDM_TACH_FLAGS_NOT_HOT_PLUG);
6544	if (RT_FAILURE(rc))
6545	return rc;
6546
6547	/*
6548	* Initialize the retrace flag.
6549	*/
6550	rc = CFGMR3QueryBoolDef(pCfg, "RealRetrace", &pThis->fRealRetrace, false);
6551	AssertLogRelRCReturn(rc, rc);
6552
6553	#ifdef VBE_NEW_DYN_LIST
6554
6555	uint16_t maxBiosXRes;
6556	rc = CFGMR3QueryU16Def(pCfg, "MaxBiosXRes", &maxBiosXRes, UINT16_MAX);
6557	AssertLogRelRCReturn(rc, rc);
6558	uint16_t maxBiosYRes;
6559	rc = CFGMR3QueryU16Def(pCfg, "MaxBiosYRes", &maxBiosYRes, UINT16_MAX);
6560	AssertLogRelRCReturn(rc, rc);
6561
6562	/*
6563	* Compute buffer size for the VBE BIOS Extra Data.
6564	*/
6565	cb = sizeof(mode_info_list) + sizeof(ModeInfoListItem);
6566
6567	rc = CFGMR3QueryU32(pCfg, "HeightReduction", &cyReduction);
6568	if (RT_SUCCESS(rc) && cyReduction)
6569	cb = 2; / Default mode list will be twice long */
6570	else
6571	cyReduction = 0;
6572
6573	rc = CFGMR3QueryU32(pCfg, "CustomVideoModes", &cCustomModes);
6574	if (RT_SUCCESS(rc) && cCustomModes)
6575	cb += sizeof(ModeInfoListItem) * cCustomModes;
6576	else
6577	cCustomModes = 0;
6578
6579	/*
6580	* Allocate and initialize buffer for the VBE BIOS Extra Data.
6581	*/
6582	AssertRelease(sizeof(VBEHEADER) + cb < 65536);
6583	pThis->cbVBEExtraData = (uint16_t)(sizeof(VBEHEADER) + cb);
6584	pThis->pbVBEExtraData = (uint8_t *)PDMDevHlpMMHeapAllocZ(pDevIns, pThis->cbVBEExtraData);
6585	if (!pThis->pbVBEExtraData)
6586	return VERR_NO_MEMORY;
6587
6588	pVBEDataHdr = (PVBEHEADER)pThis->pbVBEExtraData;
6589	pVBEDataHdr->u16Signature = VBEHEADER_MAGIC;
6590	pVBEDataHdr->cbData = cb;
6591
6592	# ifndef VRAM_SIZE_FIX
6593	pCurMode = memcpy(pVBEDataHdr + 1, &mode_info_list, sizeof(mode_info_list));
6594	pCurMode = (ModeInfoListItem *)((uintptr_t)pCurMode + sizeof(mode_info_list));
6595	# else /* VRAM_SIZE_FIX defined */
6596	pCurMode = (ModeInfoListItem *)(pVBEDataHdr + 1);
6597	for (i = 0; i < MODE_INFO_SIZE; i++)
6598	{
6599	uint32_t pixelWidth, reqSize;
6600	if (mode_info_list[i].info.MemoryModel == VBE_MEMORYMODEL_TEXT_MODE)
6601	pixelWidth = 2;
6602	else
6603	pixelWidth = (mode_info_list[i].info.BitsPerPixel +7) / 8;
6604	reqSize = mode_info_list[i].info.XResolution
6605	* mode_info_list[i].info.YResolution
6606	* pixelWidth;
6607	if (reqSize >= pThis->vram_size)
6608	continue;
6609	if ( mode_info_list[i].info.XResolution > maxBiosXRes
6610	\|\| mode_info_list[i].info.YResolution > maxBiosYRes)
6611	continue;
6612	*pCurMode = mode_info_list[i];
6613	vgaAdjustModeInfo(pThis, pCurMode);
6614	pCurMode++;
6615	}
6616	# endif /* VRAM_SIZE_FIX defined */
6617
6618	/*
6619	* Copy default modes with subtracted YResolution.
6620	*/
6621	if (cyReduction)
6622	{
6623	ModeInfoListItem *pDefMode = mode_info_list;
6624	Log(("vgaR3Construct: cyReduction=%u\n", cyReduction));
6625	# ifndef VRAM_SIZE_FIX
6626	for (i = 0; i < MODE_INFO_SIZE; i++, pCurMode++, pDefMode++)
6627	{
6628	pCurMode = pDefMode;
6629	pCurMode->mode += 0x30;
6630	pCurMode->info.YResolution -= cyReduction;
6631	}
6632	# else /* VRAM_SIZE_FIX defined */
6633	for (i = 0; i < MODE_INFO_SIZE; i++, pDefMode++)
6634	{
6635	uint32_t pixelWidth, reqSize;
6636	if (pDefMode->info.MemoryModel == VBE_MEMORYMODEL_TEXT_MODE)
6637	pixelWidth = 2;
6638	else
6639	pixelWidth = (pDefMode->info.BitsPerPixel + 7) / 8;
6640	reqSize = pDefMode->info.XResolution * pDefMode->info.YResolution * pixelWidth;
6641	if (reqSize >= pThis->vram_size)
6642	continue;
6643	if ( pDefMode->info.XResolution > maxBiosXRes
6644	\|\| pDefMode->info.YResolution - cyReduction > maxBiosYRes)
6645	continue;
6646	pCurMode = pDefMode;
6647	pCurMode->mode += 0x30;
6648	pCurMode->info.YResolution -= cyReduction;
6649	pCurMode++;
6650	}
6651	# endif /* VRAM_SIZE_FIX defined */
6652	}
6653
6654
6655	/*
6656	* Add custom modes.
6657	*/
6658	if (cCustomModes)
6659	{
6660	uint16_t u16CurMode = 0x160;
6661	for (i = 1; i <= cCustomModes; i++)
6662	{
6663	char szExtraDataKey[sizeof("CustomVideoModeXX")];
6664	char *pszExtraData = NULL;
6665
6666	/* query and decode the custom mode string. */
6667	RTStrPrintf(szExtraDataKey, sizeof(szExtraDataKey), "CustomVideoMode%d", i);
6668	rc = CFGMR3QueryStringAlloc(pCfg, szExtraDataKey, &pszExtraData);
6669	if (RT_SUCCESS(rc))
6670	{
6671	ModeInfoListItem *pDefMode = mode_info_list;
6672	unsigned int cx, cy, cBits, cParams, j;
6673	uint16_t u16DefMode;
6674
6675	cParams = sscanf(pszExtraData, "%ux%ux%u", &cx, &cy, &cBits);
6676	if ( cParams != 3
6677	\|\| (cBits != 8 && cBits != 16 && cBits != 24 && cBits != 32))
6678	{
6679	AssertMsgFailed(("Configuration error: Invalid mode data '%s' for '%s'! cBits=%d\n", pszExtraData, szExtraDataKey, cBits));
6680	return VERR_VGA_INVALID_CUSTOM_MODE;
6681	}
6682	cbPitch = calc_line_pitch(cBits, cx);
6683	# ifdef VRAM_SIZE_FIX
6684	if (cy * cbPitch >= pThis->vram_size)
6685	{
6686	AssertMsgFailed(("Configuration error: custom video mode %dx%dx%dbits is too large for the virtual video memory of %dMb. Please increase the video memory size.\n",
6687	cx, cy, cBits, pThis->vram_size / _1M));
6688	return VERR_VGA_INVALID_CUSTOM_MODE;
6689	}
6690	# endif /* VRAM_SIZE_FIX defined */
6691	MMR3HeapFree(pszExtraData);
6692
6693	/* Use defaults from max@bpp mode. */
6694	switch (cBits)
6695	{
6696	case 8:
6697	u16DefMode = VBE_VESA_MODE_1024X768X8;
6698	break;
6699
6700	case 16:
6701	u16DefMode = VBE_VESA_MODE_1024X768X565;
6702	break;
6703
6704	case 24:
6705	u16DefMode = VBE_VESA_MODE_1024X768X888;
6706	break;
6707
6708	case 32:
6709	u16DefMode = VBE_OWN_MODE_1024X768X8888;
6710	break;
6711
6712	default: /* gcc, shut up! */
6713	AssertMsgFailed(("gone postal!\n"));
6714	continue;
6715	}
6716
6717	/* mode_info_list is not terminated */
6718	for (j = 0; j < MODE_INFO_SIZE && pDefMode->mode != u16DefMode; j++)
6719	pDefMode++;
6720	Assert(j < MODE_INFO_SIZE);
6721
6722	pCurMode = pDefMode;
6723	pCurMode->mode = u16CurMode++;
6724
6725	/* adjust defaults */
6726	pCurMode->info.XResolution = cx;
6727	pCurMode->info.YResolution = cy;
6728	pCurMode->info.BytesPerScanLine = cbPitch;
6729	pCurMode->info.LinBytesPerScanLine = cbPitch;
6730	vgaAdjustModeInfo(pThis, pCurMode);
6731
6732	/* commit it */
6733	pCurMode++;
6734	}
6735	else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
6736	{
6737	AssertMsgFailed(("CFGMR3QueryStringAlloc(,'%s',) -> %Rrc\n", szExtraDataKey, rc));
6738	return rc;
6739	}
6740	} /* foreach custom mode key */
6741	}
6742
6743	/*
6744	* Add the "End of list" mode.
6745	*/
6746	memset(pCurMode, 0, sizeof(*pCurMode));
6747	pCurMode->mode = VBE_VESA_MODE_END_OF_LIST;
6748
6749	/*
6750	* Register I/O Port for the VBE BIOS Extra Data.
6751	*/
6752	rc = PDMDevHlpIOPortRegister(pDevIns, VBE_EXTRA_PORT, 1, NULL, vbeIOPortWriteVBEExtra, vbeIOPortReadVBEExtra, NULL, NULL, "VBE BIOS Extra Data");
6753	if (RT_FAILURE(rc))
6754	return rc;
6755	#endif /* VBE_NEW_DYN_LIST */
6756
6757	/*
6758	* Register I/O Port for the BIOS Logo.
6759	*/
6760	rc = PDMDevHlpIOPortRegister(pDevIns, LOGO_IO_PORT, 1, NULL, vbeIOPortWriteCMDLogo, vbeIOPortReadCMDLogo, NULL, NULL, "BIOS Logo");
6761	if (RT_FAILURE(rc))
6762	return rc;
6763
6764	/*
6765	* Register debugger info callbacks.
6766	*/
6767	PDMDevHlpDBGFInfoRegister(pDevIns, "vga", "Display basic VGA state.", vgaInfoState);
6768	PDMDevHlpDBGFInfoRegister(pDevIns, "vgatext", "Display VGA memory formatted as text.", vgaInfoText);
6769	PDMDevHlpDBGFInfoRegister(pDevIns, "vgacr", "Dump VGA CRTC registers.", vgaInfoCR);
6770	PDMDevHlpDBGFInfoRegister(pDevIns, "vgagr", "Dump VGA Graphics Controller registers.", vgaInfoGR);
6771	PDMDevHlpDBGFInfoRegister(pDevIns, "vgasr", "Dump VGA Sequencer registers.", vgaInfoSR);
6772	PDMDevHlpDBGFInfoRegister(pDevIns, "vgaar", "Dump VGA Attribute Controller registers.", vgaInfoAR);
6773	PDMDevHlpDBGFInfoRegister(pDevIns, "vgapl", "Dump planar graphics state.", vgaInfoPlanar);
6774	PDMDevHlpDBGFInfoRegister(pDevIns, "vgadac", "Dump VGA DAC registers.", vgaInfoDAC);
6775	PDMDevHlpDBGFInfoRegister(pDevIns, "vbe", "Dump VGA VBE registers.", vgaInfoVBE);
6776
6777	/*
6778	* Construct the logo header.
6779	*/
6780	LOGOHDR LogoHdr = { LOGO_HDR_MAGIC, 0, 0, 0, 0, 0, 0 };
6781
6782	rc = CFGMR3QueryU8(pCfg, "FadeIn", &LogoHdr.fu8FadeIn);
6783	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
6784	LogoHdr.fu8FadeIn = 1;
6785	else if (RT_FAILURE(rc))
6786	return PDMDEV_SET_ERROR(pDevIns, rc,
6787	N_("Configuration error: Querying \"FadeIn\" as integer failed"));
6788
6789	rc = CFGMR3QueryU8(pCfg, "FadeOut", &LogoHdr.fu8FadeOut);
6790	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
6791	LogoHdr.fu8FadeOut = 1;
6792	else if (RT_FAILURE(rc))
6793	return PDMDEV_SET_ERROR(pDevIns, rc,
6794	N_("Configuration error: Querying \"FadeOut\" as integer failed"));
6795
6796	rc = CFGMR3QueryU16(pCfg, "LogoTime", &LogoHdr.u16LogoMillies);
6797	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
6798	LogoHdr.u16LogoMillies = 0;
6799	else if (RT_FAILURE(rc))
6800	return PDMDEV_SET_ERROR(pDevIns, rc,
6801	N_("Configuration error: Querying \"LogoTime\" as integer failed"));
6802
6803	rc = CFGMR3QueryU8(pCfg, "ShowBootMenu", &LogoHdr.fu8ShowBootMenu);
6804	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
6805	LogoHdr.fu8ShowBootMenu = 0;
6806	else if (RT_FAILURE(rc))
6807	return PDMDEV_SET_ERROR(pDevIns, rc,
6808	N_("Configuration error: Querying \"ShowBootMenu\" as integer failed"));
6809
6810	#if defined(DEBUG) && !defined(DEBUG_sunlover) && !defined(DEBUG_michael)
6811	/* Disable the logo abd menu if all default settings. */
6812	if ( LogoHdr.fu8FadeIn
6813	&& LogoHdr.fu8FadeOut
6814	&& LogoHdr.u16LogoMillies == 0
6815	&& LogoHdr.fu8ShowBootMenu == 2)
6816	{
6817	LogoHdr.fu8FadeIn = LogoHdr.fu8FadeOut = 0;
6818	LogoHdr.u16LogoMillies = 500;
6819	}
6820	#endif
6821
6822	/* Delay the logo a little bit */
6823	if (LogoHdr.fu8FadeIn && LogoHdr.fu8FadeOut && !LogoHdr.u16LogoMillies)
6824	LogoHdr.u16LogoMillies = RT_MAX(LogoHdr.u16LogoMillies, LOGO_DELAY_TIME);
6825
6826	/*
6827	* Get the Logo file name.
6828	*/
6829	rc = CFGMR3QueryStringAlloc(pCfg, "LogoFile", &pThis->pszLogoFile);
6830	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
6831	pThis->pszLogoFile = NULL;
6832	else if (RT_FAILURE(rc))
6833	return PDMDEV_SET_ERROR(pDevIns, rc,
6834	N_("Configuration error: Querying \"LogoFile\" as a string failed"));
6835	else if (!*pThis->pszLogoFile)
6836	{
6837	MMR3HeapFree(pThis->pszLogoFile);
6838	pThis->pszLogoFile = NULL;
6839	}
6840
6841	/*
6842	* Determine the logo size, open any specified logo file in the process.
6843	*/
6844	LogoHdr.cbLogo = g_cbVgaDefBiosLogo;
6845	RTFILE FileLogo = NIL_RTFILE;
6846	if (pThis->pszLogoFile)
6847	{
6848	rc = RTFileOpen(&FileLogo, pThis->pszLogoFile,
6849	RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
6850	if (RT_SUCCESS(rc))
6851	{
6852	uint64_t cbFile;
6853	rc = RTFileGetSize(FileLogo, &cbFile);
6854	if (RT_SUCCESS(rc))
6855	{
6856	if (cbFile > 0 && cbFile < 32*_1M)
6857	LogoHdr.cbLogo = (uint32_t)cbFile;
6858	else
6859	rc = VERR_TOO_MUCH_DATA;
6860	}
6861	}
6862	if (RT_FAILURE(rc))
6863	{
6864	/*
6865	* Ignore failure and fall back to the default logo.
6866	*/
6867	LogRel(("vgaR3Construct: Failed to open logo file '%s', rc=%Rrc!\n", pThis->pszLogoFile, rc));
6868	if (FileLogo != NIL_RTFILE)
6869	RTFileClose(FileLogo);
6870	FileLogo = NIL_RTFILE;
6871	MMR3HeapFree(pThis->pszLogoFile);
6872	pThis->pszLogoFile = NULL;
6873	}
6874	}
6875
6876	/*
6877	* Disable graphic splash screen if it doesn't fit into VRAM.
6878	*/
6879	if (pThis->vram_size < LOGO_MAX_SIZE)
6880	LogoHdr.fu8FadeIn = LogoHdr.fu8FadeOut = LogoHdr.u16LogoMillies = 0;
6881
6882	/*
6883	* Allocate buffer for the logo data.
6884	* RT_MAX() is applied to let us fall back to default logo on read failure.
6885	*/
6886	pThis->cbLogo = sizeof(LogoHdr) + LogoHdr.cbLogo;
6887	pThis->pbLogo = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, RT_MAX(pThis->cbLogo, g_cbVgaDefBiosLogo + sizeof(LogoHdr)));
6888	if (pThis->pbLogo)
6889	{
6890	/*
6891	* Write the logo header.
6892	*/
6893	PLOGOHDR pLogoHdr = (PLOGOHDR)pThis->pbLogo;
6894	*pLogoHdr = LogoHdr;
6895
6896	/*
6897	* Write the logo bitmap.
6898	*/
6899	if (pThis->pszLogoFile)
6900	{
6901	rc = RTFileRead(FileLogo, pLogoHdr + 1, LogoHdr.cbLogo, NULL);
6902	if (RT_SUCCESS(rc))
6903	rc = vbeParseBitmap(pThis);
6904	if (RT_FAILURE(rc))
6905	{
6906	LogRel(("Error %Rrc reading logo file '%s', using internal logo\n",
6907	rc, pThis->pszLogoFile));
6908	pLogoHdr->cbLogo = LogoHdr.cbLogo = g_cbVgaDefBiosLogo;
6909	}
6910	}
6911	if ( !pThis->pszLogoFile
6912	\|\| RT_FAILURE(rc))
6913	{
6914	memcpy(pLogoHdr + 1, g_abVgaDefBiosLogo, LogoHdr.cbLogo);
6915	rc = vbeParseBitmap(pThis);
6916	if (RT_FAILURE(rc))
6917	AssertReleaseMsgFailed(("Parsing of internal bitmap failed! vbeParseBitmap() -> %Rrc\n", rc));
6918	}
6919
6920	rc = VINF_SUCCESS;
6921	}
6922	else
6923	rc = VERR_NO_MEMORY;
6924
6925	/*
6926	* Cleanup.
6927	*/
6928	if (FileLogo != NIL_RTFILE)
6929	RTFileClose(FileLogo);
6930
6931	#ifdef VBOX_WITH_HGSMI
6932	VBVAInit (pThis);
6933	#endif /* VBOX_WITH_HGSMI */
6934
6935	#ifdef VBOX_WITH_VDMA
6936	if (rc == VINF_SUCCESS)
6937	{
6938	rc = vboxVDMAConstruct(pThis, 1024);
6939	AssertRC(rc);
6940	}
6941	#endif
6942
6943	#ifdef VBOX_WITH_VMSVGA
6944	if ( rc == VINF_SUCCESS
6945	&& pThis->fVMSVGAEnabled)
6946	{
6947	rc = vmsvgaInit(pDevIns);
6948	}
6949	#endif
6950
6951	/*
6952	* Statistics.
6953	*/
6954	STAM_REG(pVM, &pThis->StatRZMemoryRead, STAMTYPE_PROFILE, "/Devices/VGA/RZ/MMIO-Read", STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCMemoryRead() body.");
6955	STAM_REG(pVM, &pThis->StatR3MemoryRead, STAMTYPE_PROFILE, "/Devices/VGA/R3/MMIO-Read", STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCMemoryRead() body.");
6956	STAM_REG(pVM, &pThis->StatRZMemoryWrite, STAMTYPE_PROFILE, "/Devices/VGA/RZ/MMIO-Write", STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCMemoryWrite() body.");
6957	STAM_REG(pVM, &pThis->StatR3MemoryWrite, STAMTYPE_PROFILE, "/Devices/VGA/R3/MMIO-Write", STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCMemoryWrite() body.");
6958	STAM_REG(pVM, &pThis->StatMapPage, STAMTYPE_COUNTER, "/Devices/VGA/MapPageCalls", STAMUNIT_OCCURENCES, "Calls to IOMMMIOMapMMIO2Page.");
6959	STAM_REG(pVM, &pThis->StatUpdateDisp, STAMTYPE_COUNTER, "/Devices/VGA/UpdateDisplay", STAMUNIT_OCCURENCES, "Calls to vgaPortUpdateDisplay().");
6960
6961	/* Init latched access mask. */
6962	pThis->uMaskLatchAccess = 0x3ff;
6963
6964	if (RT_SUCCESS(rc))
6965	{
6966	PPDMIBASE pBase;
6967	/*
6968	* Attach status driver (optional).
6969	*/
6970	rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
6971	if (RT_SUCCESS(rc))
6972	{
6973	pThis->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
6974	pThis->pMediaNotify = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMEDIANOTIFY);
6975	}
6976	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
6977	{
6978	Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
6979	rc = VINF_SUCCESS;
6980	}
6981	else
6982	{
6983	AssertMsgFailed(("Failed to attach to status driver. rc=%Rrc\n", rc));
6984	rc = PDMDEV_SET_ERROR(pDevIns, rc, N_("VGA cannot attach to status driver"));
6985	}
6986	}
6987	return rc;
6988	}
6989
6990	static DECLCALLBACK(void) vgaR3PowerOn(PPDMDEVINS pDevIns)
6991	{
6992	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
6993	#ifdef VBOX_WITH_VMSVGA
6994	vmsvgaR3PowerOn(pDevIns);
6995	#endif
6996	VBVAOnResume(pThis);
6997	}
6998
6999	static DECLCALLBACK(void) vgaR3Resume(PPDMDEVINS pDevIns)
7000	{
7001	PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
7002	VBVAOnResume(pThis);
7003	}
7004
7005	/**
7006	* The device registration structure.
7007	*/
7008	const PDMDEVREG g_DeviceVga =
7009	{
7010	/* u32Version */
7011	PDM_DEVREG_VERSION,
7012	/* szName */
7013	"vga",
7014	/* szRCMod */
7015	"VBoxDDRC.rc",
7016	/* szR0Mod */
7017	"VBoxDDR0.r0",
7018	/* pszDescription */
7019	"VGA Adaptor with VESA extensions.",
7020	/* fFlags */
7021	PDM_DEVREG_FLAGS_DEFAULT_BITS \| PDM_DEVREG_FLAGS_RC \| PDM_DEVREG_FLAGS_R0,
7022	/* fClass */
7023	PDM_DEVREG_CLASS_GRAPHICS,
7024	/* cMaxInstances */
7025	1,
7026	/* cbInstance */
7027	sizeof(VGASTATE),
7028	/* pfnConstruct */
7029	vgaR3Construct,
7030	/* pfnDestruct */
7031	vgaR3Destruct,
7032	/* pfnRelocate */
7033	vgaR3Relocate,
7034	/* pfnMemSetup */
7035	NULL,
7036	/* pfnPowerOn */
7037	vgaR3PowerOn,
7038	/* pfnReset */
7039	vgaR3Reset,
7040	/* pfnSuspend */
7041	NULL,
7042	/* pfnResume */
7043	vgaR3Resume,
7044	/* pfnAttach */
7045	vgaAttach,
7046	/* pfnDetach */
7047	vgaDetach,
7048	/* pfnQueryInterface */
7049	NULL,
7050	/* pfnInitComplete */
7051	NULL,
7052	/* pfnPowerOff */
7053	NULL,
7054	/* pfnSoftReset */
7055	NULL,
7056	/* u32VersionEnd */
7057	PDM_DEVREG_VERSION
7058	};
7059
7060	#endif /* !IN_RING3 */
7061	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
7062
7063	/*
7064	* Local Variables:
7065	* nuke-trailing-whitespace-p:nil
7066	* End:
7067	*/

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

source: vbox/trunk/src/VBox/Devices/Graphics/DevVGA.cpp@ 61092

Download in other formats: