DevPcBios.cpp@ 6290

Last change on this file since 6290 was 5999, checked in by vboxsync, 17 years ago
The Giant CDDL Dual-License Header Change.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 51.8 KB

Line
1	/* $Id: DevPcBios.cpp 5999 2007-12-07 15:05:06Z vboxsync $ */
2	/** @file
3	* PC BIOS Device.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/*******************************************************************************
19	* Header Files *
20	*******************************************************************************/
21	#define LOG_GROUP LOG_GROUP_DEV_PC_BIOS
22	#include <VBox/pdmdev.h>
23	#include <VBox/mm.h>
24
25	#include <VBox/log.h>
26	#include <iprt/assert.h>
27	#include <iprt/alloc.h>
28	#include <iprt/file.h>
29	#include <iprt/string.h>
30	#include <VBox/err.h>
31	#include <VBox/param.h>
32
33	#include "Builtins.h"
34	#include "Builtins2.h"
35	#include "DevPcBios.h"
36
37
38	/*******************************************************************************
39	* Structures and Typedefs *
40	*******************************************************************************/
41
42	/**
43	* The boot device.
44	*/
45	typedef enum DEVPCBIOSBOOT
46	{
47	DEVPCBIOSBOOT_NONE,
48	DEVPCBIOSBOOT_FLOPPY,
49	DEVPCBIOSBOOT_HD,
50	DEVPCBIOSBOOT_DVD,
51	DEVPCBIOSBOOT_LAN
52	} DEVPCBIOSBOOT;
53
54	/**
55	* PC Bios instance data structure.
56	*/
57	typedef struct DEVPCBIOS
58	{
59	/** Pointer back to the device instance. */
60	PPDMDEVINS pDevIns;
61
62	/** Boot devices (ordered). */
63	DEVPCBIOSBOOT aenmBootDevice[4];
64	/** Ram Size (in bytes). */
65	uint64_t cbRam;
66	/** Bochs shutdown index. */
67	uint32_t iShutdown;
68	/** Floppy device. */
69	char *pszFDDevice;
70	/** Harddisk device. */
71	char *pszHDDevice;
72	/** Bios message buffer. */
73	char szMsg[256];
74	/** Bios message buffer index. */
75	uint32_t iMsg;
76	/** Current logo data offset. */
77	uint32_t offLogoData;
78	/** Use built-in or loaded logo. */
79	bool fDefaultLogo;
80	/** The size of the BIOS logo data. */
81	uint32_t cbLogo;
82	/** The BIOS logo data. */
83	uint8_t *pu8Logo;
84	/** The name of the logo file. */
85	char *pszLogoFile;
86	/** The LAN boot ROM data. */
87	uint8_t *pu8LanBoot;
88	/** The name of the LAN boot ROM file. */
89	char *pszLanBootFile;
90	/** The DMI tables. */
91	uint8_t au8DMIPage[0x1000];
92	/** The boot countdown (in seconds). */
93	uint8_t uBootDelay;
94	/** I/O-APIC enabled? */
95	uint8_t u8IOAPIC;
96	/** PXE debug logging enabled? */
97	uint8_t u8PXEDebug;
98	} DEVPCBIOS, *PDEVPCBIOS;
99
100
101	/** @todo The logo stuff shared with the BIOS goes into a header of course. */
102
103	/**
104	* PC Bios logo data structure.
105	*/
106	#pragma pack(2) /* pack(2) is important! (seems that bios compiled with pack(2)...) */
107	typedef struct LOGOHDR
108	{
109	/** Signature (LOGO_HDR_MAGIC/0x66BB). */
110	uint16_t u16Signature;
111	/** Fade in - boolean. */
112	uint8_t u8FadeIn;
113	/** Fade out - boolean. */
114	uint8_t u8FadeOut;
115	/** Logo time (msec). */
116	uint16_t u16LogoMillies;
117	/** Show setup - boolean. */
118	uint8_t u8ShowBootMenu;
119	/** Logo file size. */
120	uint32_t cbLogo;
121	} LOGOHDR, *PLOGOHDR;
122	#pragma pack()
123
124	/** PC port for Logo I/O */
125	#define LOGO_IO_PORT 0x506
126
127	/** The value of the LOGOHDR::u16Signature field. */
128	#define LOGO_HDR_MAGIC 0x66BB
129
130	/** The value which will switch you the default logo. */
131	#define LOGO_DEFAULT_LOGO 0xFFFF
132
133	/** The maximal logo size in bytes. (640x480x8bpp + header/palette) */
134	#define LOGO_MAX_SIZE 640 * 480 + 0x442
135
136	#pragma pack(1)
137
138	/** DMI header */
139	typedef struct DMIHDR
140	{
141	uint8_t u8Type;
142	uint8_t u8Length;
143	uint16_t u16Handle;
144	} *PDMIHDR;
145	AssertCompileSize(DMIHDR, 4);
146
147	/** DMI BIOS information */
148	typedef struct DMIBIOSINF
149	{
150	DMIHDR header;
151	uint8_t u8Vendor;
152	uint8_t u8Version;
153	uint16_t u16Start;
154	uint8_t u8Release;
155	uint8_t u8ROMSize;
156	uint64_t u64Characteristics;
157	uint8_t u8CharacteristicsByte1;
158	uint8_t u8CharacteristicsByte2;
159	} *PDMIBIOSINF;
160	AssertCompileSize(DMIBIOSINF, 0x14);
161
162	/** DMI system information */
163	typedef struct DMISYSTEMINF
164	{
165	DMIHDR header;
166	uint8_t u8Manufacturer;
167	uint8_t u8ProductName;
168	uint8_t u8Version;
169	uint8_t u8SerialNumber;
170	uint8_t au8Uuid[16];
171	uint8_t u8WakeupType;
172	uint8_t u8SKUNumber;
173	uint8_t u8Family;
174	} *PDMISYSTEMINF;
175	AssertCompileSize(DMISYSTEMINF, 0x1b);
176
177	/** MPS floating pointer structure */
178	typedef struct MPSFLOATPTR
179	{
180	uint8_t au8Signature[4];
181	uint32_t u32MPSAddr;
182	uint8_t u8Length;
183	uint8_t u8SpecRev;
184	uint8_t u8Checksum;
185	uint8_t au8Feature[5];
186	} *PMPSFLOATPTR;
187	AssertCompileSize(MPSFLOATPTR, 16);
188
189	/** MPS config table header */
190	typedef struct MPSCFGTBLHEADER
191	{
192	uint8_t au8Signature[4];
193	uint16_t u16Length;
194	uint8_t u8SpecRev;
195	uint8_t u8Checksum;
196	uint8_t au8OemId[8];
197	uint8_t au8ProductId[12];
198	uint32_t u32OemTablePtr;
199	uint16_t u16OemTableSize;
200	uint16_t u16EntryCount;
201	uint32_t u32AddrLocalApic;
202	uint16_t u16ExtTableLength;
203	uint8_t u8ExtTableChecksxum;
204	uint8_t u8Reserved;
205	} *PMPSCFGTBLHEADER;
206	AssertCompileSize(MPSCFGTBLHEADER, 0x2c);
207
208	/** MPS processor entry */
209	typedef struct MPSPROCENTRY
210	{
211	uint8_t u8EntryType;
212	uint8_t u8LocalApicId;
213	uint8_t u8LocalApicVersion;
214	uint8_t u8CPUFlags;
215	uint32_t u32CPUSignature;
216	uint32_t u32CPUFeatureFlags;
217	uint32_t u32Reserved[2];
218	} *PMPSPROCENTRY;
219	AssertCompileSize(MPSPROCENTRY, 20);
220
221	/** MPS bus entry */
222	typedef struct MPSBUSENTRY
223	{
224	uint8_t u8EntryType;
225	uint8_t u8BusId;
226	uint8_t au8BusTypeStr[6];
227	} *PMPSBUSENTRY;
228	AssertCompileSize(MPSBUSENTRY, 8);
229
230	/** MPS I/O-APIC entry */
231	typedef struct MPSIOAPICENTRY
232	{
233	uint8_t u8EntryType;
234	uint8_t u8Id;
235	uint8_t u8Version;
236	uint8_t u8Flags;
237	uint32_t u32Addr;
238	} *PMPSIOAPICENTRY;
239	AssertCompileSize(MPSIOAPICENTRY, 8);
240
241	/** MPS I/O-Interrupt entry */
242	typedef struct MPSIOINTERRUPTENTRY
243	{
244	uint8_t u8EntryType;
245	uint8_t u8Type;
246	uint16_t u16Flags;
247	uint8_t u8SrcBusId;
248	uint8_t u8SrcBusIrq;
249	uint8_t u8DstIOAPICId;
250	uint8_t u8DstIOAPICInt;
251	} *PMPSIOIRQENTRY;
252	AssertCompileSize(MPSIOINTERRUPTENTRY, 8);
253
254	#pragma pack()
255
256
257	/*******************************************************************************
258	* Internal Functions *
259	*******************************************************************************/
260	__BEGIN_DECLS
261
262	static DECLCALLBACK(int) logoIOPortRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb);
263	static DECLCALLBACK(int) logoIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb);
264
265	__END_DECLS
266
267
268	/**
269	* Write to CMOS memory.
270	* This is used by the init complete code.
271	*/
272	static void pcbiosCmosWrite(PPDMDEVINS pDevIns, int off, uint32_t u32Val)
273	{
274	Assert(off < 128);
275	Assert(u32Val < 256);
276
277	#if 1
278	int rc = PDMDevHlpCMOSWrite(pDevIns, off, u32Val);
279	AssertRC(rc);
280	#else
281	PVM pVM = PDMDevHlpGetVM(pDevIns);
282	IOMIOPortWrite(pVM, 0x70, off, 1);
283	IOMIOPortWrite(pVM, 0x71, u32Val, 1);
284	IOMIOPortWrite(pVM, 0x70, 0, 1);
285	#endif
286	}
287
288	/* -=-=-=-=-=-=- based on code from pc.c -=-=-=-=-=-=- */
289
290	/**
291	* Initializes the CMOS data for one harddisk.
292	*/
293	static void pcbiosCmosInitHardDisk(PPDMDEVINS pDevIns, int offType, int offInfo, PPDMIBLOCKBIOS pBlockBios)
294	{
295	if ( pBlockBios->pfnGetType(pBlockBios) == PDMBLOCKTYPE_HARD_DISK
296	&& pBlockBios->pfnIsVisible(pBlockBios))
297	{
298	uint32_t cCylinders;
299	uint32_t cHeads;
300	uint32_t cSectors;
301	int rc = pBlockBios->pfnGetGeometry(pBlockBios, &cCylinders, &cHeads, &cSectors);
302	if (VBOX_SUCCESS(rc))
303	{
304	Log2(("pcbiosCmosInitHardDisk: offInfo=%#x: CHS=%d/%d/%d\n", offInfo, cCylinders, cHeads, cSectors));
305	pcbiosCmosWrite(pDevIns, offType, 47); /* 19h - First Extended Hard Disk Drive Type */
306	pcbiosCmosWrite(pDevIns, offInfo + 0, RT_MIN(cCylinders, 16383) & 0xff); /* 1Bh - (AMI) First Hard Disk (type 47) user defined: # of Cylinders, LSB */
307	pcbiosCmosWrite(pDevIns, offInfo + 1, RT_MIN(cCylinders, 16383) >> 8); /* 1Ch - (AMI) First Hard Disk user defined: # of Cylinders, High Byte */
308	pcbiosCmosWrite(pDevIns, offInfo + 2, cHeads); /* 1Dh - (AMI) First Hard Disk user defined: Number of Heads */
309	pcbiosCmosWrite(pDevIns, offInfo + 3, 0xff); /* 1Eh - (AMI) First Hard Disk user defined: Write Precompensation Cylinder, Low Byte */
310	pcbiosCmosWrite(pDevIns, offInfo + 4, 0xff); /* 1Fh - (AMI) First Hard Disk user defined: Write Precompensation Cylinder, High Byte */
311	pcbiosCmosWrite(pDevIns, offInfo + 5, 0xc0 \| ((cHeads > 8) << 3)); /* 20h - (AMI) First Hard Disk user defined: Control Byte */
312	pcbiosCmosWrite(pDevIns, offInfo + 6, 0xff); /* 21h - (AMI) First Hard Disk user defined: Landing Zone, Low Byte */
313	pcbiosCmosWrite(pDevIns, offInfo + 7, 0xff); /* 22h - (AMI) First Hard Disk user defined: Landing Zone, High Byte */
314	pcbiosCmosWrite(pDevIns, offInfo + 8, cSectors); /* 23h - (AMI) First Hard Disk user defined: # of Sectors per track */
315	return;
316	}
317	}
318	pcbiosCmosWrite(pDevIns, offType, 0);
319	}
320
321
322	/**
323	* Get BIOS boot code from enmBootDevice in order
324	*
325	* @todo r=bird: This is a rather silly function since the conversion is 1:1.
326	*/
327	static uint8_t getBiosBootCode(PDEVPCBIOS pData, unsigned iOrder)
328	{
329	switch (pData->aenmBootDevice[iOrder])
330	{
331	case DEVPCBIOSBOOT_NONE:
332	return 0;
333	case DEVPCBIOSBOOT_FLOPPY:
334	return 1;
335	case DEVPCBIOSBOOT_HD:
336	return 2;
337	case DEVPCBIOSBOOT_DVD:
338	return 3;
339	case DEVPCBIOSBOOT_LAN:
340	return 4;
341	default:
342	AssertMsgFailed(("aenmBootDevice[%d]=%d\n", iOrder, pData->aenmBootDevice[iOrder]));
343	return 0;
344	}
345	}
346
347
348	/**
349	* Init complete notification.
350	* This routine will write information needed by the bios to the CMOS.
351	*
352	* @returns VBOX status code.
353	* @param pDevIns The device instance.
354	* @see http://www.brl.ntt.co.jp/people/takehiko/interrupt/CMOS.LST.txt for
355	* a description of standard and non-standard CMOS registers.
356	*/
357	static DECLCALLBACK(int) pcbiosInitComplete(PPDMDEVINS pDevIns)
358	{
359	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
360	uint32_t u32;
361	unsigned i;
362	PVM pVM = PDMDevHlpGetVM(pDevIns);
363	PPDMIBLOCKBIOS apHDs[4] = {0};
364	PPDMIBLOCKBIOS apFDs[2] = {0};
365	AssertRelease(pVM);
366	LogFlow(("pcbiosInitComplete:\n"));
367
368	/*
369	* Memory sizes.
370	*/
371	/* base memory. */
372	u32 = pData->cbRam > 640 ? 640 : (uint32_t)pData->cbRam / _1K;
373	pcbiosCmosWrite(pDevIns, 0x15, u32 & 0xff); /* 15h - Base Memory in K, Low Byte */
374	pcbiosCmosWrite(pDevIns, 0x16, u32 >> 8); /* 16h - Base Memory in K, High Byte */
375
376	/* Extended memory, up to 65MB */
377	u32 = pData->cbRam >= 65 * _1M ? 0xffff : ((uint32_t)pData->cbRam - _1M) / _1K;
378	pcbiosCmosWrite(pDevIns, 0x17, u32 & 0xff); /* 17h - Extended Memory in K, Low Byte */
379	pcbiosCmosWrite(pDevIns, 0x18, u32 >> 8); /* 18h - Extended Memory in K, High Byte */
380	pcbiosCmosWrite(pDevIns, 0x30, u32 & 0xff); /* 30h - Extended Memory in K, Low Byte */
381	pcbiosCmosWrite(pDevIns, 0x31, u32 >> 8); /* 31h - Extended Memory in K, High Byte */
382
383	/* Bochs BIOS specific? Anyway, it's the amount of memory above 16MB */
384	if (pData->cbRam > 16 * _1M)
385	{
386	u32 = (uint32_t)( (pData->cbRam - 16 * _1M) / _64K );
387	u32 = RT_MIN(u32, 0xffff);
388	}
389	else
390	u32 = 0;
391	pcbiosCmosWrite(pDevIns, 0x34, u32 & 0xff);
392	pcbiosCmosWrite(pDevIns, 0x35, u32 >> 8);
393
394	/*
395	* Bochs BIOS specifics - boot device.
396	* We do both new and old (ami-style) settings.
397	* See rombios.c line ~7215 (int19_function).
398	*/
399
400	uint8_t reg3d = getBiosBootCode(pData, 0) \| (getBiosBootCode(pData, 1) << 4);
401	uint8_t reg38 = /* pcbiosCmosRead(pDevIns, 0x38) \| */ getBiosBootCode(pData, 2) << 4;
402	/* This is an extension. Bochs BIOS normally supports only 3 boot devices. */
403	uint8_t reg3c = getBiosBootCode(pData, 3) \| (pData->uBootDelay << 4);
404	pcbiosCmosWrite(pDevIns, 0x3d, reg3d);
405	pcbiosCmosWrite(pDevIns, 0x38, reg38);
406	pcbiosCmosWrite(pDevIns, 0x3c, reg3c);
407
408	/*
409	* PXE debug option.
410	*/
411	pcbiosCmosWrite(pDevIns, 0x3f, pData->u8PXEDebug);
412
413	/*
414	* Floppy drive type.
415	*/
416	for (i = 0; i < ELEMENTS(apFDs); i++)
417	{
418	PPDMIBASE pBase;
419	int rc = PDMR3QueryLun(pVM, pData->pszFDDevice, 0, i, &pBase);
420	if (VBOX_SUCCESS(rc))
421	apFDs[i] = (PPDMIBLOCKBIOS)pBase->pfnQueryInterface(pBase, PDMINTERFACE_BLOCK_BIOS);
422	}
423	u32 = 0;
424	if (apFDs[0])
425	switch (apFDs[0]->pfnGetType(apFDs[0]))
426	{
427	case PDMBLOCKTYPE_FLOPPY_360: u32 \|= 1 << 4; break;
428	case PDMBLOCKTYPE_FLOPPY_1_20: u32 \|= 2 << 4; break;
429	case PDMBLOCKTYPE_FLOPPY_720: u32 \|= 3 << 4; break;
430	case PDMBLOCKTYPE_FLOPPY_1_44: u32 \|= 4 << 4; break;
431	case PDMBLOCKTYPE_FLOPPY_2_88: u32 \|= 5 << 4; break;
432	default: AssertFailed(); break;
433	}
434	if (apFDs[1])
435	switch (apFDs[1]->pfnGetType(apFDs[1]))
436	{
437	case PDMBLOCKTYPE_FLOPPY_360: u32 \|= 1; break;
438	case PDMBLOCKTYPE_FLOPPY_1_20: u32 \|= 2; break;
439	case PDMBLOCKTYPE_FLOPPY_720: u32 \|= 3; break;
440	case PDMBLOCKTYPE_FLOPPY_1_44: u32 \|= 4; break;
441	case PDMBLOCKTYPE_FLOPPY_2_88: u32 \|= 5; break;
442	default: AssertFailed(); break;
443	}
444	pcbiosCmosWrite(pDevIns, 0x10, u32); /* 10h - Floppy Drive Type */
445
446	/*
447	* Equipment byte.
448	*/
449	u32 = !!apFDs[0] + !!apFDs[1];
450	switch (u32)
451	{
452	case 1: u32 = 0x01; break; /* floppy installed, 1 drive. */
453	case 2: u32 = 0x41; break; /* floppy installed, 2 drives. */
454	default:u32 = 0; break; /* floppy not installed. */
455	}
456	u32 \|= RT_BIT(1); /* math coprocessor installed */
457	u32 \|= RT_BIT(2); /* keyboard enabled (or mouse?) */
458	u32 \|= RT_BIT(3); /* display enabled (monitory type is 0, i.e. vga) */
459	pcbiosCmosWrite(pDevIns, 0x14, u32); /* 14h - Equipment Byte */
460
461	/*
462	* Harddisks.
463	*/
464	for (i = 0; i < ELEMENTS(apHDs); i++)
465	{
466	PPDMIBASE pBase;
467	int rc = PDMR3QueryLun(pVM, pData->pszHDDevice, 0, i, &pBase);
468	if (VBOX_SUCCESS(rc))
469	apHDs[i] = (PPDMIBLOCKBIOS)pBase->pfnQueryInterface(pBase, PDMINTERFACE_BLOCK_BIOS);
470	}
471
472	u32 = (apHDs[0] ? 0xf0 : 0) \| (apHDs[1] ? 0x0f : 0); /* 0Fh means extended and points to 1Ah, 1Bh */
473	pcbiosCmosWrite(pDevIns, 0x12, u32); /* 12h - Hard Disk Data (type) */
474	if (apHDs[0])
475	pcbiosCmosInitHardDisk(pDevIns, 0x19, 0x1b, apHDs[0]); /* 19h - First Extended Hard Disk Drive Type */
476	if (apHDs[1])
477	pcbiosCmosInitHardDisk(pDevIns, 0x1a, 0x24, apHDs[1]); /* 1Ah - Second Extended Hard Disk Drive Type */
478
479	/*
480	* Translation type - Bochs BIOS specific.
481	*/
482	u32 = 0;
483	for (i = 0; i < 4; i++)
484	{
485	if (apHDs[i])
486	{
487	PDMBIOSTRANSLATION enmTranslation;
488	int rc = apHDs[i]->pfnGetTranslation(apHDs[i], &enmTranslation);
489	if (VBOX_FAILURE(rc) \|\| enmTranslation == PDMBIOSTRANSLATION_AUTO)
490	{
491	uint32_t cCylinders, cHeads, cSectors;
492	rc = apHDs[i]->pfnGetGeometry(apHDs[i], &cCylinders, &cHeads, &cSectors);
493	if (VBOX_FAILURE(rc))
494	{
495	AssertMsg(rc == VERR_PDM_MEDIA_NOT_MOUNTED, ("This shouldn't happen! rc=%Vrc\n", rc));
496	enmTranslation = PDMBIOSTRANSLATION_NONE;
497	}
498	else if (cCylinders <= 1024 && cHeads <= 16 && cSectors <= 63)
499	{
500	/* Disk <= 512 MByte not needing LBA translation. */
501	enmTranslation = PDMBIOSTRANSLATION_NONE;
502	}
503	else if (cSectors != 63 \|\| (cHeads != 16 && cHeads != 32 && cHeads != 64 && cHeads != 128 && cHeads != 255))
504	{
505	/* Disk with strange geometry. Using LBA here can
506	* break booting of the guest OS. Especially operating
507	* systems from Microsoft are sensitive to BIOS CHS not
508	* matching what the partition table says. */
509	enmTranslation = PDMBIOSTRANSLATION_NONE;
510	}
511	else
512	enmTranslation = PDMBIOSTRANSLATION_LBA;
513	}
514	switch (enmTranslation)
515	{
516	case PDMBIOSTRANSLATION_AUTO: /* makes gcc happy */
517	case PDMBIOSTRANSLATION_NONE:
518	/* u32 \|= 0 << (i * 2) */
519	break;
520	default:
521	AssertMsgFailed(("bad enmTranslation=%d\n", enmTranslation));
522	case PDMBIOSTRANSLATION_LBA:
523	u32 \|= 1 << (i * 2);
524	break;
525	}
526	}
527	}
528	Log2(("pcbiosInitComplete: translation byte: %#02x\n", u32));
529	pcbiosCmosWrite(pDevIns, 0x39, u32);
530
531	LogFlow(("pcbiosInitComplete: returns VINF_SUCCESS\n"));
532	return VINF_SUCCESS;
533	}
534
535
536	/**
537	* Port I/O Handler for IN operations.
538	*
539	* @returns VBox status code.
540	*
541	* @param pDevIns The device instance.
542	* @param pvUser User argument - ignored.
543	* @param Port Port number used for the IN operation.
544	* @param pu32 Where to store the result.
545	* @param cb Number of bytes read.
546	*/
547	static DECLCALLBACK(int) pcbiosIOPortRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
548	{
549	NOREF(pDevIns);
550	NOREF(pvUser);
551	NOREF(Port);
552	NOREF(pu32);
553	NOREF(cb);
554	return VERR_IOM_IOPORT_UNUSED;
555	}
556
557
558	/**
559	* Port I/O Handler for OUT operations.
560	*
561	* @returns VBox status code.
562	*
563	* @param pDevIns The device instance.
564	* @param pvUser User argument - ignored.
565	* @param Port Port number used for the IN operation.
566	* @param u32 The value to output.
567	* @param cb The value size in bytes.
568	*/
569	static DECLCALLBACK(int) pcbiosIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
570	{
571	/*
572	* Bochs BIOS Panic
573	*/
574	if ( cb == 2
575	&& ( Port == 0x400
576	\|\| Port == 0x401))
577	{
578	Log(("pcbios: PC BIOS panic at rombios.c(%d)\n", u32));
579	AssertReleaseMsgFailed(("PC BIOS panic at rombios.c(%d)\n", u32));
580	return VERR_INTERNAL_ERROR;
581	}
582
583	/*
584	* Bochs BIOS char printing.
585	*/
586	if ( cb == 1
587	&& ( Port == 0x402
588	\|\| Port == 0x403))
589	{
590	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
591	/* The raw version. */
592	switch (u32)
593	{
594	case '\r': Log2(("pcbios: <return>\n")); break;
595	case '\n': Log2(("pcbios: <newline>\n")); break;
596	case '\t': Log2(("pcbios: <tab>\n")); break;
597	default: Log2(("pcbios: %c (%02x)\n", u32, u32)); break;
598	}
599
600	/* The readable, buffered version. */
601	if (u32 == '\n' \|\| u32 == '\r')
602	{
603	pData->szMsg[pData->iMsg] = '\0';
604	if (pData->iMsg)
605	Log(("pcbios: %s\n", pData->szMsg));
606	pData->iMsg = 0;
607	}
608	else
609	{
610	if (pData->iMsg >= sizeof(pData->szMsg)-1)
611	{
612	pData->szMsg[pData->iMsg] = '\0';
613	Log(("pcbios: %s\n", pData->szMsg));
614	pData->iMsg = 0;
615	}
616	pData->szMsg[pData->iMsg] = (char )u32;
617	pData->szMsg[++pData->iMsg] = '\0';
618	}
619	return VINF_SUCCESS;
620	}
621
622	/*
623	* Bochs BIOS shutdown request.
624	*/
625	if (cb == 1 && Port == 0x8900)
626	{
627	static const unsigned char szShutdown[] = "Shutdown";
628	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
629	if (u32 == szShutdown[pData->iShutdown])
630	{
631	pData->iShutdown++;
632	if (pData->iShutdown == 8)
633	{
634	pData->iShutdown = 0;
635	LogRel(("8900h shutdown request.\n"));
636	return PDMDevHlpVMPowerOff(pDevIns);
637	}
638	}
639	else
640	pData->iShutdown = 0;
641	return VINF_SUCCESS;
642	}
643
644	/* not in use. */
645	return VINF_SUCCESS;
646	}
647
648
649	/**
650	* LOGO port I/O Handler for IN operations.
651	*
652	* @returns VBox status code.
653	*
654	* @param pDevIns The device instance.
655	* @param pvUser User argument - ignored.
656	* @param uPort Port number used for the IN operation.
657	* @param pu32 Where to store the result.
658	* @param cb Number of bytes read.
659	*/
660	static DECLCALLBACK(int) logoIOPortRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
661	{
662	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
663	Log(("logoIOPortRead call Port:%x pu32:%x cb:%d (%d)\n", Port, pu32, cb, pData->offLogoData));
664
665	PRTUINT64U p;
666	if (pData->fDefaultLogo)
667	{
668	/*
669	* Default bios logo.
670	*/
671	if (pData->offLogoData + cb > g_cbPcDefBiosLogo)
672	{
673	Log(("logoIOPortRead: Requested address is out of Logo data!!! offLogoData=%#x(%d) cbLogo=%#x(%d)\n",
674	pData->offLogoData, pData->offLogoData, g_cbPcDefBiosLogo, g_cbPcDefBiosLogo));
675	return VINF_SUCCESS;
676	}
677	p = (PRTUINT64U)&g_abPcDefBiosLogo[pData->offLogoData];
678	}
679	else
680	{
681	/*
682	* Custom logo.
683	*/
684	if (pData->offLogoData + cb > pData->cbLogo)
685	{
686	Log(("logoIOPortRead: Requested address is out of Logo data!!! offLogoData=%#x(%d) cbLogo=%#x(%d)\n",
687	pData->offLogoData, pData->offLogoData, pData->cbLogo, pData->cbLogo));
688	return VINF_SUCCESS;
689	}
690	p = (PRTUINT64U)&pData->pu8Logo[pData->offLogoData];
691	}
692
693	switch (cb)
694	{
695	case 1: *pu32 = p->au8[0]; break;
696	case 2: *pu32 = p->au16[0]; break;
697	case 4: *pu32 = p->au32[0]; break;
698	//case 8: *pu32 = p->au64[0]; break;
699	default: AssertFailed(); break;
700	}
701	Log(("logoIOPortRead: LogoOffset=%#x(%d) cb=%#x %.*Vhxs\n", pData->offLogoData, pData->offLogoData, cb, cb, pu32));
702	pData->offLogoData += cb;
703
704	return VINF_SUCCESS;
705	}
706
707
708	/**
709	* LOGO port I/O Handler for OUT operations.
710	*
711	* @returns VBox status code.
712	*
713	* @param pDevIns The device instance.
714	* @param pvUser User argument - ignored.
715	* @param uPort Port number used for the IN operation.
716	* @param u32 The value to output.
717	* @param cb The value size in bytes.
718	*/
719	static DECLCALLBACK(int) logoIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
720	{
721	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
722	Log(("logoIOPortWrite: Port=%x cb=%d u32=%#04x (byte)\n", Port, cb, u32));
723
724	/* Switch to default BIOS logo or change logo data offset. */
725	if ( cb == 2
726	&& u32 == LOGO_DEFAULT_LOGO)
727	{
728	pData->fDefaultLogo = true;
729	pData->offLogoData = 0;
730	}
731	else
732	pData->offLogoData = u32;
733
734	return VINF_SUCCESS;
735	}
736
737
738	/**
739	* Construct the DMI table.
740	*
741	* @param table pointer to DMI table.
742	*/
743	#define STRCPY(p, s) do { memcpy (p, s, sizeof(s)); p += sizeof(s); } while (0)
744	static void pcbiosPlantDMITable(uint8_t *pTable, PRTUUID puuid)
745	{
746	char pszStr = (char)pTable;
747	int iStrNr;
748
749	PDMIBIOSINF pBIOSInf = (PDMIBIOSINF)pszStr;
750	pszStr = (char*)(pBIOSInf+1);
751	iStrNr = 1;
752	pBIOSInf->header.u8Type = 0; /* BIOS Information */
753	pBIOSInf->header.u8Length = sizeof(*pBIOSInf);
754	pBIOSInf->header.u16Handle = 0x0000;
755	pBIOSInf->u8Vendor = iStrNr++;
756	STRCPY(pszStr, "innotek GmbH");
757	pBIOSInf->u8Version = iStrNr++;
758	STRCPY(pszStr, "VirtualBox");
759	pBIOSInf->u16Start = 0xE000;
760	pBIOSInf->u8Release = iStrNr++;
761	STRCPY(pszStr, "12/01/2006");
762	pBIOSInf->u8ROMSize = 1; /* 128K */
763	pBIOSInf->u64Characteristics = RT_BIT(4) /* ISA is supported */
764	\| RT_BIT(7) /* PCI is supported */
765	\| RT_BIT(15) /* Boot from CD is supported */
766	\| RT_BIT(16) /* Selectable Boot is supported */
767	\| RT_BIT(27) /* Int 9h, 8042 Keyboard services supported */
768	\| RT_BIT(30) /* Int 10h, CGA/Mono Video Services supported */
769	/* any more?? */
770	;
771	pBIOSInf->u8CharacteristicsByte1 = RT_BIT(0) /* ACPI is supported */
772	/* any more?? */
773	;
774	pBIOSInf->u8CharacteristicsByte2 = 0
775	/* any more?? */
776	;
777	*pszStr++ = '\0';
778
779
780	PDMISYSTEMINF pSystemInf = (PDMISYSTEMINF)pszStr;
781	pszStr = (char*)(pSystemInf+1);
782	iStrNr = 1;
783	pSystemInf->header.u8Type = 1; /* System Information */
784	pSystemInf->header.u8Length = sizeof(*pSystemInf);
785	pSystemInf->header.u16Handle = 0x0001;
786	pSystemInf->u8Manufacturer = iStrNr++;
787	STRCPY(pszStr, "innotek GmbH");
788	pSystemInf->u8ProductName = iStrNr++;
789	STRCPY(pszStr, "VirtualBox");
790	pSystemInf->u8Version = iStrNr++;
791	STRCPY(pszStr, "1.2");
792	pSystemInf->u8SerialNumber = iStrNr++;
793	STRCPY(pszStr, "0");
794	memcpy(pSystemInf->au8Uuid, puuid, sizeof(RTUUID));
795	pSystemInf->u8WakeupType = 6; /* Power Switch */
796	pSystemInf->u8SKUNumber = 0;
797	pSystemInf->u8Family = iStrNr++;
798	STRCPY(pszStr, "Virtual Machine");
799	*pszStr++ = '\0';
800
801	AssertMsg(pszStr - (char*)pTable == VBOX_DMI_TABLE_SIZE,
802	("VBOX_DMI_TABLE_SIZE=%d, actual DMI table size is %d",
803	VBOX_DMI_TABLE_SIZE, pszStr - (char*)pTable));
804	}
805	AssertCompile(VBOX_DMI_TABLE_ENTR == 2);
806
807
808	/**
809	* Calculate a simple checksum for the MPS table.
810	*
811	* @param data data
812	* @param len size of data
813	*/
814	static uint8_t pcbiosChecksum(const uint8_t * const au8Data, uint32_t u32Length)
815	{
816	uint8_t u8Sum = 0;
817	for (size_t i = 0; i < u32Length; ++i)
818	u8Sum += au8Data[i];
819	return -u8Sum;
820	}
821
822
823	/**
824	* Construct the MPS table. Only applicable if IOAPIC is active.
825	*
826	* @param pDevIns The device instance data.
827	* @param addr physical address in guest memory.
828	*/
829	static void pcbiosPlantMPStable(PPDMDEVINS pDevIns, uint8_t *pTable)
830	{
831	/* configuration table */
832	PMPSCFGTBLHEADER pCfgTab = (MPSCFGTBLHEADER*)pTable;
833	memcpy(pCfgTab->au8Signature, "PCMP", 4);
834	pCfgTab->u8SpecRev = 4; /* 1.4 */
835	memcpy(pCfgTab->au8OemId, "VBOXCPU ", 8);
836	memcpy(pCfgTab->au8ProductId, "VirtualBox ", 12);
837	pCfgTab->u32OemTablePtr = 0;
838	pCfgTab->u16OemTableSize = 0;
839	pCfgTab->u16EntryCount = 1 /* Processor */
840	+ 1 /* ISA Bus */
841	+ 1 /* I/O-APIC */
842	+ 16 /* Interrupts */;
843	pCfgTab->u32AddrLocalApic = 0xfee00000;
844	pCfgTab->u16ExtTableLength = 0;
845	pCfgTab->u8ExtTableChecksxum = 0;
846	pCfgTab->u8Reserved = 0;
847
848	uint32_t u32Eax, u32Ebx, u32Ecx, u32Edx;
849	uint32_t u32CPUSignature = 0x0520; /* default: Pentium 100 */
850	uint32_t u32FeatureFlags = 0x0001; /* default: FPU */
851	PDMDevHlpGetCpuId(pDevIns, 0, &u32Eax, &u32Ebx, &u32Ecx, &u32Edx);
852	if (u32Eax >= 1)
853	{
854	PDMDevHlpGetCpuId(pDevIns, 1, &u32Eax, &u32Ebx, &u32Ecx, &u32Edx);
855	u32CPUSignature = u32Eax & 0xfff;
856	/* Local APIC will be enabled later so override it here. Since we provide
857	* an MP table we have an IOAPIC and therefore a Local APIC. */
858	u32FeatureFlags = u32Edx \| X86_CPUID_FEATURE_EDX_APIC;
859	}
860
861	/* one processor so far */
862	PMPSPROCENTRY pProcEntry = (PMPSPROCENTRY)(pCfgTab+1);
863	pProcEntry->u8EntryType = 0; /* processor entry */
864	pProcEntry->u8LocalApicId = 0;
865	pProcEntry->u8LocalApicVersion = 0x11;
866	pProcEntry->u8CPUFlags = 2 /* bootstrap processor / \| 1 / enabled */;
867	pProcEntry->u32CPUSignature = u32CPUSignature;
868	pProcEntry->u32CPUFeatureFlags = u32FeatureFlags;
869	pProcEntry->u32Reserved[0] =
870	pProcEntry->u32Reserved[1] = 0;
871
872	/* ISA bus */
873	PMPSBUSENTRY pBusEntry = (PMPSBUSENTRY)(pProcEntry+1);
874	pBusEntry->u8EntryType = 1; /* bus entry */
875	pBusEntry->u8BusId = 0; /* this ID is referenced by the interrupt entries */
876	memcpy(pBusEntry->au8BusTypeStr, "ISA ", 6);
877
878	/* PCI bus? */
879
880	/* I/O-APIC.
881	* MP spec: "The configuration table contains one or more entries for I/O APICs.
882	* ... At least one I/O APIC must be enabled." */
883	PMPSIOAPICENTRY pIOAPICEntry = (PMPSIOAPICENTRY)(pBusEntry+1);
884	pIOAPICEntry->u8EntryType = 2; /* I/O-APIC entry */
885	pIOAPICEntry->u8Id = 1; /* this ID is referenced by the interrupt entries */
886	pIOAPICEntry->u8Version = 0x11;
887	pIOAPICEntry->u8Flags = 1 /* enable */;
888	pIOAPICEntry->u32Addr = 0xfec00000;
889
890	PMPSIOIRQENTRY pIrqEntry = (PMPSIOIRQENTRY)(pIOAPICEntry+1);
891	for (int i = 0; i < 16; i++, pIrqEntry++)
892	{
893	pIrqEntry->u8EntryType = 3; /* I/O interrupt entry */
894	pIrqEntry->u8Type = 0; /* INT, vectored interrupt */
895	pIrqEntry->u16Flags = 0; /* polarity of APIC I/O input signal = conforms to bus,
896	trigger mode = conforms to bus */
897	pIrqEntry->u8SrcBusId = 0; /* ISA bus */
898	pIrqEntry->u8SrcBusIrq = i;
899	pIrqEntry->u8DstIOAPICId = 1;
900	pIrqEntry->u8DstIOAPICInt = i;
901	}
902
903	pCfgTab->u16Length = (uint8_t*)pIrqEntry - pTable;
904	pCfgTab->u8Checksum = pcbiosChecksum(pTable, pCfgTab->u16Length);
905
906	AssertMsg(pCfgTab->u16Length < 0x1000 - 0x100,
907	("VBOX_MPS_TABLE_SIZE=%d, maximum allowed size is %d",
908	pCfgTab->u16Length, 0x1000-0x100));
909
910	MPSFLOATPTR floatPtr;
911	floatPtr.au8Signature[0] = '_';
912	floatPtr.au8Signature[1] = 'M';
913	floatPtr.au8Signature[2] = 'P';
914	floatPtr.au8Signature[3] = '_';
915	floatPtr.u32MPSAddr = VBOX_MPS_TABLE_BASE;
916	floatPtr.u8Length = 1; /* structure size in paragraphs */
917	floatPtr.u8SpecRev = 4; /* MPS revision 1.4 */
918	floatPtr.u8Checksum = 0;
919	floatPtr.au8Feature[0] = 0;
920	floatPtr.au8Feature[1] = 0;
921	floatPtr.au8Feature[2] = 0;
922	floatPtr.au8Feature[3] = 0;
923	floatPtr.au8Feature[4] = 0;
924	floatPtr.u8Checksum = pcbiosChecksum((uint8_t*)&floatPtr, 16);
925	PDMDevHlpPhysWrite (pDevIns, 0x9fff0, &floatPtr, 16);
926	}
927
928
929	/**
930	* Reset notification.
931	*
932	* @returns VBox status.
933	* @param pDevIns The device instance data.
934	*/
935	static DECLCALLBACK(void) pcbiosReset(PPDMDEVINS pDevIns)
936	{
937	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
938	LogFlow(("pcbiosReset:\n"));
939
940	pData->fDefaultLogo = false;
941	pData->offLogoData = 0;
942	/** @todo Should we perhaps do pcbiosInitComplete() on reset? */
943
944	#if 1
945	/*
946	* Paranoia: Check that the BIOS ROM hasn't changed.
947	*/
948	uint8_t abBuf[PAGE_SIZE];
949
950	/* the low ROM mapping. */
951	unsigned cb = RT_MIN(g_cbPcBiosBinary, 128 * _1K);
952	RTGCPHYS GCPhys = 0x00100000 - cb;
953	const uint8_t *pbVirgin = &g_abPcBiosBinary[g_cbPcBiosBinary - cb];
954	while (GCPhys < 0x00100000)
955	{
956	PDMDevHlpPhysRead(pDevIns, GCPhys, abBuf, PAGE_SIZE);
957	if (memcmp(abBuf, pbVirgin, PAGE_SIZE))
958	{
959	LogRel(("low ROM mismatch! GCPhys=%VGp - Ignore if you've loaded an old saved state with an different VirtualBox version.\n", GCPhys));
960	for (unsigned off = 0; off < PAGE_SIZE; off++)
961	if (abBuf[off] != pbVirgin[off])
962	LogRel(("%VGp: %02x expected %02x\n", GCPhys + off, abBuf[off], pbVirgin[off]));
963	AssertFailed();
964	}
965
966	/* next page */
967	GCPhys += PAGE_SIZE;
968	pbVirgin += PAGE_SIZE;
969	}
970
971	/* the high ROM mapping. */
972	GCPhys = UINT32_C(0xffffffff) - (g_cbPcBiosBinary - 1);
973	pbVirgin = &g_abPcBiosBinary[0];
974	while (pbVirgin < &g_abPcBiosBinary[g_cbPcBiosBinary])
975	{
976	PDMDevHlpPhysRead(pDevIns, GCPhys, abBuf, PAGE_SIZE);
977	if (memcmp(abBuf, pbVirgin, PAGE_SIZE))
978	{
979	LogRel(("high ROM mismatch! GCPhys=%VGp - Ignore if you've loaded an old saved state with an different VirtualBox version.\n", GCPhys));
980	for (unsigned off = 0; off < PAGE_SIZE; off++)
981	if (abBuf[off] != pbVirgin[off])
982	LogRel(("%VGp: %02x expected %02x\n", GCPhys + off, abBuf[off], pbVirgin[off]));
983	AssertFailed();
984	}
985
986	/* next page */
987	GCPhys += PAGE_SIZE;
988	pbVirgin += PAGE_SIZE;
989	}
990	#endif
991
992	if (pData->u8IOAPIC)
993	pcbiosPlantMPStable(pDevIns, pData->au8DMIPage + 0x100);
994	}
995
996
997	/**
998	* Destruct a device instance.
999	*
1000	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
1001	* resources can be freed correctly.
1002	*
1003	* @param pDevIns The device instance data.
1004	*/
1005	static DECLCALLBACK(int) pcbiosDestruct(PPDMDEVINS pDevIns)
1006	{
1007	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
1008	LogFlow(("pcbiosDestruct:\n"));
1009
1010	/*
1011	* Free MM heap pointers.
1012	*/
1013	if (pData->pu8LanBoot)
1014	{
1015	MMR3HeapFree(pData->pu8LanBoot);
1016	pData->pu8LanBoot = NULL;
1017	}
1018
1019	if (pData->pszLanBootFile)
1020	{
1021	MMR3HeapFree(pData->pszLanBootFile);
1022	pData->pszLanBootFile = NULL;
1023	}
1024
1025	if (pData->pu8Logo)
1026	{
1027	MMR3HeapFree(pData->pu8Logo);
1028	pData->pu8Logo = NULL;
1029	}
1030
1031	if (pData->pszLogoFile)
1032	{
1033	MMR3HeapFree(pData->pszLogoFile);
1034	pData->pszLogoFile = NULL;
1035	}
1036
1037	return VINF_SUCCESS;
1038	}
1039
1040
1041	/**
1042	* Convert config value to DEVPCBIOSBOOT.
1043	*
1044	* @returns VBox status code.
1045	* @param pCfgHandle Configuration handle.
1046	* @param pszParam The name of the value to read.
1047	* @param penmBoot Where to store the boot method.
1048	*/
1049	static int pcbiosBootFromCfg(PPDMDEVINS pDevIns, PCFGMNODE pCfgHandle, const char pszParam, DEVPCBIOSBOOT penmBoot)
1050	{
1051	char *psz;
1052	int rc = CFGMR3QueryStringAlloc(pCfgHandle, pszParam, &psz);
1053	if (VBOX_FAILURE(rc))
1054	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
1055	N_("Configuration error: Querying \"%s\" as a string failed"),
1056	pszParam);
1057	if (!strcmp(psz, "DVD") \|\| !strcmp(psz, "CDROM"))
1058	*penmBoot = DEVPCBIOSBOOT_DVD;
1059	else if (!strcmp(psz, "IDE"))
1060	*penmBoot = DEVPCBIOSBOOT_HD;
1061	else if (!strcmp(psz, "FLOPPY"))
1062	*penmBoot = DEVPCBIOSBOOT_FLOPPY;
1063	else if (!strcmp(psz, "LAN"))
1064	*penmBoot = DEVPCBIOSBOOT_LAN;
1065	else if (!strcmp(psz, "NONE"))
1066	*penmBoot = DEVPCBIOSBOOT_NONE;
1067	else
1068	{
1069	PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
1070	N_("Configuration error: The \"%s\" value \"%s\" is unknown.\n"),
1071	pszParam, psz);
1072	rc = VERR_INTERNAL_ERROR;
1073	}
1074	MMR3HeapFree(psz);
1075	return rc;
1076	}
1077
1078	/**
1079	* Construct a device instance for a VM.
1080	*
1081	* @returns VBox status.
1082	* @param pDevIns The device instance data.
1083	* If the registration structure is needed, pDevIns->pDevReg points to it.
1084	* @param iInstance Instance number. Use this to figure out which registers and such to use.
1085	* The device number is also found in pDevIns->iInstance, but since it's
1086	* likely to be freqently used PDM passes it as parameter.
1087	* @param pCfgHandle Configuration node handle for the device. Use this to obtain the configuration
1088	* of the device instance. It's also found in pDevIns->pCfgHandle, but like
1089	* iInstance it's expected to be used a bit in this function.
1090	*/
1091	static DECLCALLBACK(int) pcbiosConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
1092	{
1093	unsigned i;
1094	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
1095	int rc;
1096	int cb;
1097
1098	Assert(iInstance == 0);
1099
1100	/*
1101	* Validate configuration.
1102	*/
1103	if (!CFGMR3AreValuesValid(pCfgHandle,
1104	"BootDevice0\0"
1105	"BootDevice1\0"
1106	"BootDevice2\0"
1107	"BootDevice3\0"
1108	"RamSize\0"
1109	"HardDiskDevice\0"
1110	"FloppyDevice\0"
1111	"FadeIn\0"
1112	"FadeOut\0"
1113	"LogoTime\0"
1114	"LogoFile\0"
1115	"ShowBootMenu\0"
1116	"DelayBoot\0"
1117	"LanBootRom\0"
1118	"PXEDebug\0"
1119	"UUID\0"
1120	"IOAPIC\0"))
1121	return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
1122	N_("Invalid configuraton for device pcbios device"));
1123
1124	/*
1125	* Init the data.
1126	*/
1127	rc = CFGMR3QueryU64(pCfgHandle, "RamSize", &pData->cbRam);
1128	if (VBOX_FAILURE(rc))
1129	return PDMDEV_SET_ERROR(pDevIns, rc,
1130	N_("Configuration error: Querying \"RamSize\" as integer failed"));
1131
1132	rc = CFGMR3QueryU8 (pCfgHandle, "IOAPIC", &pData->u8IOAPIC);
1133	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1134	pData->u8IOAPIC = 1;
1135	else if (VBOX_FAILURE (rc))
1136	return PDMDEV_SET_ERROR(pDevIns, rc,
1137	N_("Configuration error: Failed to read \"IOAPIC\"."));
1138
1139	static const char * const s_apszBootDevices[] = { "BootDevice0", "BootDevice1", "BootDevice2", "BootDevice3" };
1140	Assert(ELEMENTS(s_apszBootDevices) == ELEMENTS(pData->aenmBootDevice));
1141	for (i = 0; i < ELEMENTS(pData->aenmBootDevice); i++)
1142	{
1143	rc = pcbiosBootFromCfg(pDevIns, pCfgHandle, s_apszBootDevices[i], &pData->aenmBootDevice[i]);
1144	if (VBOX_FAILURE(rc))
1145	return rc;
1146	}
1147
1148	rc = CFGMR3QueryStringAlloc(pCfgHandle, "HardDiskDevice", &pData->pszHDDevice);
1149	if (VBOX_FAILURE(rc))
1150	return PDMDEV_SET_ERROR(pDevIns, rc,
1151	N_("Configuration error: Querying \"HardDiskDevice\" as a string failed"));
1152
1153	rc = CFGMR3QueryStringAlloc(pCfgHandle, "FloppyDevice", &pData->pszFDDevice);
1154	if (VBOX_FAILURE(rc))
1155	return PDMDEV_SET_ERROR(pDevIns, rc,
1156	N_("Configuration error: Querying \"FloppyDevice\" as a string failed"));
1157
1158	/*
1159	* Register I/O Ports and PC BIOS.
1160	*/
1161	rc = PDMDevHlpIOPortRegister(pDevIns, 0x400, 4, NULL, pcbiosIOPortWrite, pcbiosIOPortRead,
1162	NULL, NULL, "Bochs PC BIOS - Panic & Debug");
1163	if (VBOX_FAILURE(rc))
1164	return rc;
1165	rc = PDMDevHlpIOPortRegister(pDevIns, 0x8900, 1, NULL, pcbiosIOPortWrite, pcbiosIOPortRead,
1166	NULL, NULL, "Bochs PC BIOS - Shutdown");
1167	if (VBOX_FAILURE(rc))
1168	return rc;
1169
1170	/*
1171	* Query the machine's UUID for SMBIOS/DMI use.
1172	*/
1173	RTUUID uuid;
1174	rc = CFGMR3QueryBytes(pCfgHandle, "UUID", &uuid, sizeof(uuid));
1175	if (VBOX_FAILURE(rc))
1176	return PDMDEV_SET_ERROR(pDevIns, rc,
1177	N_("Configuration error: Querying \"UUID\" failed"));
1178
1179
1180	/* Convert the UUID to network byte order. Not entirely straightforward as parts are MSB already... */
1181	uuid.Gen.u32TimeLow = RT_H2BE_U32(uuid.Gen.u32TimeLow);
1182	uuid.Gen.u16TimeMid = RT_H2BE_U16(uuid.Gen.u16TimeMid);
1183	uuid.Gen.u16TimeHiAndVersion = RT_H2BE_U16(uuid.Gen.u16TimeHiAndVersion);
1184	pcbiosPlantDMITable(pData->au8DMIPage, &uuid);
1185	if (pData->u8IOAPIC)
1186	pcbiosPlantMPStable(pDevIns, pData->au8DMIPage + 0x100);
1187
1188	rc = PDMDevHlpROMRegister(pDevIns, VBOX_DMI_TABLE_BASE, 0x1000, pData->au8DMIPage, false /* fShadow */, "DMI tables");
1189	if (VBOX_FAILURE(rc))
1190	return rc;
1191
1192	/*
1193	* Read the PXE debug logging option.
1194	*/
1195	rc = CFGMR3QueryU8(pCfgHandle, "PXEDebug", &pData->u8PXEDebug);
1196	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1197	pData->u8PXEDebug = 0;
1198	else if (VBOX_FAILURE(rc))
1199	return PDMDEV_SET_ERROR(pDevIns, rc,
1200	N_("Configuration error: Querying \"PXEDebug\" as integer failed"));
1201
1202	/*
1203	* Map the BIOS into memory.
1204	* There are two mappings:
1205	* 1. 0x000e0000 to 0x000fffff contains the last 128 kb of the bios.
1206	* The bios code might be 64 kb in size, and will then start at 0xf0000.
1207	* 2. 0xfffxxxxx to 0xffffffff contains the entire bios.
1208	*/
1209	AssertReleaseMsg(g_cbPcBiosBinary >= _64K, ("g_cbPcBiosBinary=%#x\n", g_cbPcBiosBinary));
1210	AssertReleaseMsg(RT_ALIGN_Z(g_cbPcBiosBinary, _64K) == g_cbPcBiosBinary,
1211	("g_cbPcBiosBinary=%#x\n", g_cbPcBiosBinary));
1212	cb = RT_MIN(g_cbPcBiosBinary, 128 * _1K);
1213	rc = PDMDevHlpROMRegister(pDevIns, 0x00100000 - cb, cb, &g_abPcBiosBinary[g_cbPcBiosBinary - cb],
1214	false /* fShadow */, "PC BIOS - 0xfffff");
1215	if (VBOX_FAILURE(rc))
1216	return rc;
1217	rc = PDMDevHlpROMRegister(pDevIns, (uint32_t)-g_cbPcBiosBinary, g_cbPcBiosBinary, &g_abPcBiosBinary[0],
1218	false /* fShadow */, "PC BIOS - 0xffffffff");
1219	if (VBOX_FAILURE(rc))
1220	return rc;
1221
1222	/*
1223	* Register the BIOS Logo port
1224	*/
1225	rc = PDMDevHlpIOPortRegister(pDevIns, LOGO_IO_PORT, 1, NULL, logoIOPortWrite, logoIOPortRead, NULL, NULL, "PC BIOS - Logo port");
1226	if (VBOX_FAILURE(rc))
1227	return rc;
1228
1229	/*
1230	* Construct the logo header.
1231	*/
1232	LOGOHDR LogoHdr = { LOGO_HDR_MAGIC, 0, 0, 0, 0, 0 };
1233
1234	rc = CFGMR3QueryU8(pCfgHandle, "FadeIn", &LogoHdr.u8FadeIn);
1235	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1236	LogoHdr.u8FadeIn = 1;
1237	else if (VBOX_FAILURE(rc))
1238	return PDMDEV_SET_ERROR(pDevIns, rc,
1239	N_("Configuration error: Querying \"FadeIn\" as integer failed"));
1240
1241	rc = CFGMR3QueryU8(pCfgHandle, "FadeOut", &LogoHdr.u8FadeOut);
1242	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1243	LogoHdr.u8FadeOut = 1;
1244	else if (VBOX_FAILURE(rc))
1245	return PDMDEV_SET_ERROR(pDevIns, rc,
1246	N_("Configuration error: Querying \"FadeOut\" as integer failed"));
1247
1248	rc = CFGMR3QueryU16(pCfgHandle, "LogoTime", &LogoHdr.u16LogoMillies);
1249	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1250	LogoHdr.u16LogoMillies = 1;
1251	else if (VBOX_FAILURE(rc))
1252	return PDMDEV_SET_ERROR(pDevIns, rc,
1253	N_("Configuration error: Querying \"LogoTime\" as integer failed"));
1254
1255	rc = CFGMR3QueryU8(pCfgHandle, "ShowBootMenu", &LogoHdr.u8ShowBootMenu);
1256	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1257	LogoHdr.u8ShowBootMenu = 0;
1258	else if (VBOX_FAILURE(rc))
1259	return PDMDEV_SET_ERROR(pDevIns, rc,
1260	N_("Configuration error: Querying \"ShowBootMenu\" as integer failed"));
1261
1262	/*
1263	* Get the Logo file name.
1264	*/
1265	rc = CFGMR3QueryStringAlloc(pCfgHandle, "LogoFile", &pData->pszLogoFile);
1266	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1267	pData->pszLogoFile = NULL;
1268	else if (VBOX_FAILURE(rc))
1269	return PDMDEV_SET_ERROR(pDevIns, rc,
1270	N_("Configuration error: Querying \"LogoFile\" as a string failed"));
1271	else if (!*pData->pszLogoFile)
1272	{
1273	MMR3HeapFree(pData->pszLogoFile);
1274	pData->pszLogoFile = NULL;
1275	}
1276
1277	/*
1278	* Determine the logo size, open any specified logo file in the process.
1279	*/
1280	LogoHdr.cbLogo = g_cbPcDefBiosLogo;
1281	RTFILE FileLogo = NIL_RTFILE;
1282	if (pData->pszLogoFile)
1283	{
1284	rc = RTFileOpen(&FileLogo, pData->pszLogoFile,
1285	RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1286	if (VBOX_SUCCESS(rc))
1287	{
1288	uint64_t cbFile;
1289	rc = RTFileGetSize(FileLogo, &cbFile);
1290	if (VBOX_SUCCESS(rc))
1291	{
1292	if ( cbFile > 0
1293	&& cbFile < LOGO_MAX_SIZE)
1294	LogoHdr.cbLogo = (uint32_t)cbFile;
1295	else
1296	rc = VERR_TOO_MUCH_DATA;
1297	}
1298	}
1299	if (VBOX_FAILURE(rc))
1300	{
1301	/*
1302	* Ignore failure and fall back to the default logo.
1303	*/
1304	LogRel(("pcbiosConstruct: Failed to open logo file '%s', rc=%Vrc!\n", pData->pszLogoFile, rc));
1305	RTFileClose(FileLogo);
1306	FileLogo = NIL_RTFILE;
1307	MMR3HeapFree(pData->pszLogoFile);
1308	pData->pszLogoFile = NULL;
1309	}
1310	}
1311
1312	/*
1313	* Allocate buffer for the logo data.
1314	* RT_MAX() is applied to let us fall back to default logo on read failure.
1315	*/
1316	pData->cbLogo = sizeof(LogoHdr) + LogoHdr.cbLogo;
1317	pData->pu8Logo = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, RT_MAX(pData->cbLogo, g_cbPcDefBiosLogo + sizeof(LogoHdr)));
1318	if (pData->pu8Logo)
1319	{
1320	/*
1321	* Write the logo header.
1322	*/
1323	PLOGOHDR pLogoHdr = (PLOGOHDR)pData->pu8Logo;
1324	*pLogoHdr = LogoHdr;
1325
1326	/*
1327	* Write the logo bitmap.
1328	*/
1329	if (pData->pszLogoFile)
1330	{
1331	rc = RTFileRead(FileLogo, pLogoHdr + 1, LogoHdr.cbLogo, NULL);
1332	if (VBOX_FAILURE(rc))
1333	{
1334	AssertMsgFailed(("RTFileRead(,,%d,NULL) -> %Vrc\n", LogoHdr.cbLogo, rc));
1335	pLogoHdr->cbLogo = LogoHdr.cbLogo = g_cbPcDefBiosLogo;
1336	memcpy(pLogoHdr + 1, g_abPcDefBiosLogo, LogoHdr.cbLogo);
1337	}
1338	}
1339	else
1340	memcpy(pLogoHdr + 1, g_abPcDefBiosLogo, LogoHdr.cbLogo);
1341
1342	/*
1343	* Call reset to set values and stuff.
1344	*/
1345	pcbiosReset(pDevIns);
1346	rc = VINF_SUCCESS;
1347	}
1348	else
1349	rc = VERR_NO_MEMORY;
1350
1351	/* cleanup */
1352	if (FileLogo != NIL_RTFILE)
1353	RTFileClose(FileLogo);
1354
1355	/*
1356	* Get the LAN boot ROM file name.
1357	*/
1358	rc = CFGMR3QueryStringAlloc(pCfgHandle, "LanBootRom", &pData->pszLanBootFile);
1359	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1360	{
1361	pData->pszLanBootFile = NULL;
1362	rc = VINF_SUCCESS;
1363	}
1364	else if (VBOX_FAILURE(rc))
1365	return PDMDEV_SET_ERROR(pDevIns, rc,
1366	N_("Configuration error: Querying \"LanBootRom\" as a string failed"));
1367	else if (!*pData->pszLanBootFile)
1368	{
1369	MMR3HeapFree(pData->pszLanBootFile);
1370	pData->pszLanBootFile = NULL;
1371	}
1372
1373	const uint8_t *pu8LanBoot = NULL;
1374	uint64_t cbFileLanBoot;
1375	#ifdef VBOX_DO_NOT_LINK_LANBOOT
1376	/*
1377	* Determine the LAN boot ROM size, open specified ROM file in the process.
1378	*/
1379	RTFILE FileLanBoot = NIL_RTFILE;
1380	if (pData->pszLanBootFile)
1381	{
1382	rc = RTFileOpen(&FileLanBoot, pData->pszLanBootFile,
1383	RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1384	if (VBOX_SUCCESS(rc))
1385	{
1386	rc = RTFileGetSize(FileLanBoot, &cbFileLanBoot);
1387	if (VBOX_SUCCESS(rc))
1388	{
1389	if ( RT_ALIGN(cbFileLanBoot, _4K) != cbFileLanBoot
1390	\|\| cbFileLanBoot > _32K)
1391	rc = VERR_TOO_MUCH_DATA;
1392	}
1393	}
1394	if (VBOX_FAILURE(rc))
1395	{
1396	/*
1397	* Ignore failure and fall back to no LAN boot ROM.
1398	*/
1399	Log(("pcbiosConstruct: Failed to open LAN boot ROM file '%s', rc=%Vrc!\n", pData->pszLanBootFile, rc));
1400	RTFileClose(FileLanBoot);
1401	FileLanBoot = NIL_RTFILE;
1402	MMR3HeapFree(pData->pszLanBootFile);
1403	pData->pszLanBootFile = NULL;
1404	}
1405	}
1406
1407	/*
1408	* Get the LAN boot ROM data.
1409	*/
1410	if (pData->pszLanBootFile)
1411	{
1412	/*
1413	* Allocate buffer for the LAN boot ROM data.
1414	*/
1415	pu8LanBoot = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, cbFileLanBoot);
1416	pData->pu8LanBoot = pu8LanBoot;
1417	if (pu8LanBoot)
1418	{
1419	rc = RTFileRead(FileLanBoot, pData->pu8LanBoot, cbFileLanBoot, NULL);
1420	if (VBOX_FAILURE(rc))
1421	{
1422	AssertMsgFailed(("RTFileRead(,,%d,NULL) -> %Vrc\n", cbFileLanBoot, rc));
1423	MMR3HeapFree(pu8LanBoot);
1424	pu8LanBoot = NULL;
1425	pData->pu8LanBoot = NULL;
1426	}
1427	rc = VINF_SUCCESS;
1428	}
1429	else
1430	rc = VERR_NO_MEMORY;
1431	}
1432	else
1433	pData->pu8LanBoot = NULL;
1434
1435	/* cleanup */
1436	if (FileLanBoot != NIL_RTFILE)
1437	RTFileClose(FileLanBoot);
1438
1439	#else /* !VBOX_DO_NOT_LINK_LANBOOT */
1440	pData->pu8LanBoot = NULL;
1441	pu8LanBoot = g_abNetBiosBinary;
1442	cbFileLanBoot = g_cbNetBiosBinary;
1443	#endif /* !VBOX_DO_NOT_LINK_LANBOOT */
1444
1445	/*
1446	* Map the Network Boot ROM into memory.
1447	* Currently there is a fixed mapping: 0x000c8000 to 0x000cffff contains
1448	* the (up to) 32 kb ROM image.
1449	*/
1450	if (pu8LanBoot)
1451	rc = PDMDevHlpROMRegister(pDevIns, VBOX_LANBOOT_SEG << 4, cbFileLanBoot, pu8LanBoot,
1452	true /* fShadow */, "Net Boot ROM");
1453
1454	rc = CFGMR3QueryU8(pCfgHandle, "DelayBoot", &pData->uBootDelay);
1455	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1456	{
1457	pData->uBootDelay = 0;
1458	rc = VINF_SUCCESS;
1459	}
1460	else
1461	{
1462	if (VBOX_FAILURE(rc))
1463	return PDMDEV_SET_ERROR(pDevIns, rc,
1464	N_("Configuration error: Querying \"DelayBoot\" as integer failed"));
1465	if (pData->uBootDelay > 15)
1466	pData->uBootDelay = 15;
1467	}
1468
1469	return rc;
1470	}
1471
1472
1473	/**
1474	* The device registration structure.
1475	*/
1476	const PDMDEVREG g_DevicePcBios =
1477	{
1478	/* u32Version */
1479	PDM_DEVREG_VERSION,
1480	/* szDeviceName */
1481	"pcbios",
1482	/* szGCMod */
1483	"",
1484	/* szR0Mod */
1485	"",
1486	/* pszDescription */
1487	"PC BIOS Device",
1488	/* fFlags */
1489	PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_GUEST_BITS_32_64,
1490	/* fClass */
1491	PDM_DEVREG_CLASS_ARCH_BIOS,
1492	/* cMaxInstances */
1493	1,
1494	/* cbInstance */
1495	sizeof(DEVPCBIOS),
1496	/* pfnConstruct */
1497	pcbiosConstruct,
1498	/* pfnDestruct */
1499	pcbiosDestruct,
1500	/* pfnRelocate */
1501	NULL,
1502	/* pfnIOCtl */
1503	NULL,
1504	/* pfnPowerOn */
1505	NULL,
1506	/* pfnReset */
1507	pcbiosReset,
1508	/* pfnSuspend */
1509	NULL,
1510	/* pfnResume */
1511	NULL,
1512	/* pfnAttach */
1513	NULL,
1514	/* pfnDetach */
1515	NULL,
1516	/* pfnQueryInterface. */
1517	NULL,
1518	/* pfnInitComplete. */
1519	pcbiosInitComplete
1520	};
1521

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

source: vbox/trunk/src/VBox/Devices/PC/DevPcBios.cpp@ 6290

Download in other formats: