VirtualBox

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

Last change on this file since 31713 was 31434, checked in by vboxsync, 14 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette