DevPcBios.cpp@ 82986

Last change on this file since 82986 was 82968, checked in by vboxsync, 5 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 68.4 KB

Line
1	/* $Id: DevPcBios.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2	/** @file
3	* DevPcBios - PC BIOS Device.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DEV_PC_BIOS
23	#include <VBox/vmm/pdmdev.h>
24	#include <VBox/vmm/pdmstorageifs.h>
25	#include <VBox/vmm/mm.h>
26	#include <VBox/vmm/pgm.h>
27	#include <VBox/vmm/cpum.h>
28
29	#include <VBox/log.h>
30	#include <iprt/asm.h>
31	#include <iprt/assert.h>
32	#include <iprt/buildconfig.h>
33	#include <iprt/file.h>
34	#include <iprt/mem.h>
35	#include <iprt/string.h>
36	#include <iprt/uuid.h>
37	#include <iprt/cdefs.h>
38	#include <VBox/bios.h>
39	#include <VBox/err.h>
40	#include <VBox/param.h>
41
42	#include "VBoxDD.h"
43	#include "VBoxDD2.h"
44	#include "DevPcBios.h"
45	#include "DevFwCommon.h"
46
47	#define NET_BOOT_DEVS 4
48
49
50	/** @page pg_devbios_cmos_assign CMOS Assignments (BIOS)
51	*
52	* The BIOS uses a CMOS to store configuration data.
53	* It is currently used as follows:
54	*
55	* @verbatim
56	First CMOS bank (offsets 0x00 to 0x7f):
57	Floppy drive type:
58	0x10
59	Hard disk type (old):
60	0x12
61	Equipment byte:
62	0x14
63	Base memory:
64	0x15
65	0x16
66	Extended memory:
67	0x17
68	0x18
69	0x30
70	0x31
71	First IDE HDD:
72	0x19
73	0x1e - 0x25
74	Second IDE HDD:
75	0x1a
76	0x26 - 0x2d
77	Checksum of 0x10-0x2d:
78	0x2e
79	0x2f
80	Amount of memory above 16M and below 4GB in 64KB units:
81	0x34
82	0x35
83	Boot device (BOCHS BIOS specific):
84	0x38
85	0x3c
86	0x3d
87	PXE debug:
88	0x3f
89	First SATA HDD:
90	0x40 - 0x47
91	Second SATA HDD:
92	0x48 - 0x4f
93	Third SATA HDD:
94	0x50 - 0x57
95	Fourth SATA HDD:
96	0x58 - 0x5f
97	Number of CPUs:
98	0x60
99	RAM above 4G in 64KB units:
100	0x61 - 0x65
101	Third IDE HDD:
102	0x67 - 0x6e
103	Fourth IDE HDD:
104	0x70 - 0x77
105	APIC/x2APIC settings:
106	0x78
107
108	Second CMOS bank (offsets 0x80 to 0xff):
109	Reserved for internal use by PXE ROM:
110	0x80 - 0x81
111	First net boot device PCI bus/dev/fn:
112	0x82 - 0x83
113	Second to third net boot devices:
114	0x84 - 0x89
115	First SCSI HDD:
116	0x90 - 0x97
117	Second SCSI HDD:
118	0x98 - 0x9f
119	Third SCSI HDD:
120	0xa0 - 0xa7
121	Fourth SCSI HDD:
122	0xa8 - 0xaf
123
124	@endverbatim
125	*
126	* @todo Mark which bits are compatible with which BIOSes and
127	* which are our own definitions.
128	*/
129
130
131	/*********************************************************************************************************************************
132	* Structures and Typedefs *
133	*********************************************************************************************************************************/
134
135	/**
136	* The boot device.
137	*/
138	typedef enum DEVPCBIOSBOOT
139	{
140	DEVPCBIOSBOOT_NONE,
141	DEVPCBIOSBOOT_FLOPPY,
142	DEVPCBIOSBOOT_HD,
143	DEVPCBIOSBOOT_DVD,
144	DEVPCBIOSBOOT_LAN
145	} DEVPCBIOSBOOT;
146
147	/**
148	* PC Bios instance data structure.
149	*/
150	typedef struct DEVPCBIOS
151	{
152	/** Pointer back to the device instance. */
153	PPDMDEVINS pDevIns;
154
155	/** Boot devices (ordered). */
156	DEVPCBIOSBOOT aenmBootDevice[4];
157	/** Bochs shutdown index. */
158	uint32_t iShutdown;
159	/** Floppy device. */
160	char *pszFDDevice;
161	/** Harddisk device. */
162	char *pszHDDevice;
163	/** Sata harddisk device. */
164	char *pszSataDevice;
165	/** LUNs of the four BIOS-accessible SATA disks. */
166	uint32_t iSataHDLUN[4];
167	/** SCSI harddisk device. */
168	char *pszScsiDevice;
169	/** LUNs of the four BIOS-accessible SCSI disks. */
170	uint32_t iScsiHDLUN[4];
171	/** Bios message buffer. */
172	char szMsg[256];
173	/** Bios message buffer index. */
174	uint32_t iMsg;
175	/** The system BIOS ROM data. */
176	uint8_t *pu8PcBios;
177	/** The size of the system BIOS ROM. */
178	uint32_t cbPcBios;
179	/** The name of the BIOS ROM file. */
180	char *pszPcBiosFile;
181	/** The LAN boot ROM data. */
182	uint8_t *pu8LanBoot;
183	/** The name of the LAN boot ROM file. */
184	char *pszLanBootFile;
185	/** The size of the LAN boot ROM. */
186	uint64_t cbLanBoot;
187	/** The DMI tables. */
188	uint8_t au8DMIPage[0x1000];
189	/** The boot countdown (in seconds). */
190	uint8_t uBootDelay;
191	/** I/O-APIC enabled? */
192	uint8_t u8IOAPIC;
193	/** APIC mode to be set up by BIOS */
194	uint8_t u8APICMode;
195	/** PXE debug logging enabled? */
196	uint8_t u8PXEDebug;
197	/** Physical address of the MP table. */
198	uint32_t u32MPTableAddr;
199	/** PXE boot PCI bus/dev/fn list. */
200	uint16_t au16NetBootDev[NET_BOOT_DEVS];
201	/** Number of logical CPUs in guest */
202	uint16_t cCpus;
203	/* Physical address of PCI config space MMIO region. Currently unused. */
204	uint64_t u64McfgBase;
205	/* Length of PCI config space MMIO region. Currently unused. */
206	uint64_t cbMcfgLength;
207
208	/** Firmware registration structure. */
209	PDMFWREG FwReg;
210	/** Dummy. */
211	PCPDMFWHLPR3 pFwHlpR3;
212	/** Number of soft resets we've logged. */
213	uint32_t cLoggedSoftResets;
214	/** Whether to consult the shutdown status (CMOS[0xf]) for deciding upon soft
215	* or hard reset. */
216	bool fCheckShutdownStatusForSoftReset;
217	/** Whether to clear the shutdown status on hard reset. */
218	bool fClearShutdownStatusOnHardReset;
219	/** Current port number for Bochs shutdown (used by APM). */
220	RTIOPORT ShutdownPort;
221	/** True=use new port number for Bochs shutdown (used by APM). */
222	bool fNewShutdownPort;
223	bool afPadding[3+4];
224	/** The shudown I/O port, either at 0x040f or 0x8900 (old saved state). */
225	IOMMMIOHANDLE hIoPortShutdown;
226	} DEVPCBIOS;
227	/** Pointer to the BIOS device state. */
228	typedef DEVPCBIOS *PDEVPCBIOS;
229
230
231	/*********************************************************************************************************************************
232	* Defined Constants And Macros *
233	*********************************************************************************************************************************/
234	/** The saved state version. */
235	#define PCBIOS_SSM_VERSION 0
236
237
238	/*********************************************************************************************************************************
239	* Global Variables *
240	*********************************************************************************************************************************/
241	/** Saved state DEVPCBIOS field descriptors. */
242	static SSMFIELD const g_aPcBiosFields[] =
243	{
244	SSMFIELD_ENTRY( DEVPCBIOS, fNewShutdownPort),
245	SSMFIELD_ENTRY_TERM()
246	};
247
248
249	/**
250	* @callback_method_impl{FNIOMIOPORTNEWIN, Bochs Debug.}
251	*/
252	static DECLCALLBACK(VBOXSTRICTRC)
253	pcbiosIOPortDebugRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT offPort, uint32_t pu32, unsigned cb)
254	{
255	RT_NOREF5(pDevIns, pvUser, offPort, pu32, cb);
256	return VERR_IOM_IOPORT_UNUSED;
257	}
258
259
260	/**
261	* @callback_method_impl{FNIOMIOPORTNEWOUT, Bochs Debug.}
262	*/
263	static DECLCALLBACK(VBOXSTRICTRC)
264	pcbiosIOPortDebugWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
265	{
266	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
267	RT_NOREF(pvUser);
268	Assert(offPort < 4);
269
270	/*
271	* Bochs BIOS char printing.
272	*/
273	if ( cb == 1
274	&& ( offPort == 2
275	\|\| offPort == 3))
276	{
277	/* The raw version. */
278	switch (u32)
279	{
280	case '\r': Log2(("pcbios: <return>\n")); break;
281	case '\n': Log2(("pcbios: <newline>\n")); break;
282	case '\t': Log2(("pcbios: <tab>\n")); break;
283	default: Log2(("pcbios: %c (%02x)\n", u32, u32)); break;
284	}
285
286	/* The readable, buffered version. */
287	uint32_t iMsg = pThis->iMsg;
288	if (u32 == '\n' \|\| u32 == '\r')
289	{
290	AssertStmt(iMsg < sizeof(pThis->szMsg), iMsg = sizeof(pThis->szMsg) - 1);
291	pThis->szMsg[iMsg] = '\0';
292	if (iMsg)
293	Log(("pcbios: %s\n", pThis->szMsg));
294	iMsg = 0;
295	}
296	else
297	{
298	if (iMsg >= sizeof(pThis->szMsg) - 1)
299	{
300	pThis->szMsg[iMsg] = '\0';
301	Log(("pcbios: %s\n", pThis->szMsg));
302	iMsg = 0;
303	}
304	pThis->szMsg[iMsg] = (char)u32;
305	pThis->szMsg[++iMsg] = '\0';
306	}
307	pThis->iMsg = iMsg;
308	return VINF_SUCCESS;
309	}
310
311	/* not in use. */
312	return VINF_SUCCESS;
313	}
314
315
316	/**
317	* @callback_method_impl{FNIOMIOPORTNEWIN, Bochs Shutdown port.}
318	*/
319	static DECLCALLBACK(VBOXSTRICTRC)
320	pcbiosIOPortShutdownRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT offPort, uint32_t pu32, unsigned cb)
321	{
322	RT_NOREF5(pDevIns, pvUser, offPort, pu32, cb);
323	return VERR_IOM_IOPORT_UNUSED;
324	}
325
326
327	/**
328	* @callback_method_impl{FNIOMIOPORTNEWOUT, Bochs Shutdown port.}
329	*/
330	static DECLCALLBACK(VBOXSTRICTRC)
331	pcbiosIOPortShutdownWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
332	{
333	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
334	RT_NOREF(pvUser, offPort);
335	Assert(offPort == 0);
336
337	if (cb == 1)
338	{
339	static const unsigned char s_szShutdown[] = "Shutdown";
340	if ( pThis->iShutdown < sizeof(s_szShutdown) /* paranoia */
341	&& u32 == s_szShutdown[pThis->iShutdown])
342	{
343	pThis->iShutdown++;
344	if (pThis->iShutdown >= 8)
345	{
346	pThis->iShutdown = 0;
347	LogRel(("PcBios: APM shutdown request\n"));
348	return PDMDevHlpVMPowerOff(pDevIns);
349	}
350	}
351	else
352	pThis->iShutdown = 0;
353	}
354	/* else: not in use. */
355
356	return VINF_SUCCESS;
357	}
358
359
360	/**
361	* Register the Bochs shutdown port.
362	* This is used by pcbiosConstruct, pcbiosReset and pcbiosLoadExec.
363	*/
364	static int pcbiosRegisterShutdown(PPDMDEVINS pDevIns, PDEVPCBIOS pThis, bool fNewShutdownPort)
365	{
366	if (pThis->ShutdownPort != 0)
367	{
368	int rc = PDMDevHlpIoPortUnmap(pDevIns, pThis->hIoPortShutdown);
369	AssertRC(rc);
370	}
371
372	pThis->fNewShutdownPort = fNewShutdownPort;
373	if (fNewShutdownPort)
374	pThis->ShutdownPort = VBOX_BIOS_SHUTDOWN_PORT;
375	else
376	pThis->ShutdownPort = VBOX_BIOS_OLD_SHUTDOWN_PORT;
377	return PDMDevHlpIoPortMap(pDevIns, pThis->hIoPortShutdown, pThis->ShutdownPort);
378	}
379
380
381	/**
382	* @callback_method_impl{FNSSMDEVSAVEEXEC}
383	*/
384	static DECLCALLBACK(int) pcbiosSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
385	{
386	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
387	return pDevIns->pHlpR3->pfnSSMPutStruct(pSSM, pThis, g_aPcBiosFields);
388	}
389
390
391	/**
392	* @callback_method_impl{FNSSMDEVLOADPREP,
393	* Clears the fNewShutdownPort flag prior to loading the state so that old
394	* saved VM states keeps using the old port address (no pcbios state)}
395	*/
396	static DECLCALLBACK(int) pcbiosLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
397	{
398	RT_NOREF(pSSM);
399	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
400
401	/* Since there are legacy saved state files without any SSM data for PCBIOS
402	* this is the only way to handle them correctly. */
403	pThis->fNewShutdownPort = false;
404
405	return VINF_SUCCESS;
406	}
407
408
409	/**
410	* @callback_method_impl{FNSSMDEVLOADEXEC}
411	*/
412	static DECLCALLBACK(int) pcbiosLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
413	{
414	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
415
416	if (uVersion > PCBIOS_SSM_VERSION)
417	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
418	Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
419
420	return pDevIns->pHlpR3->pfnSSMGetStruct(pSSM, pThis, g_aPcBiosFields);
421	}
422
423
424	/**
425	* @callback_method_impl{FNSSMDEVLOADDONE,
426	* Updates the shutdown port registration to match the flag loaded (or not).}
427	*/
428	static DECLCALLBACK(int) pcbiosLoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
429	{
430	RT_NOREF(pSSM);
431	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
432	return pcbiosRegisterShutdown(pDevIns, pThis, pThis->fNewShutdownPort);
433	}
434
435
436	/**
437	* Write to CMOS memory.
438	* This is used by the init complete code.
439	*/
440	static void pcbiosCmosWrite(PPDMDEVINS pDevIns, int off, uint32_t u32Val)
441	{
442	Assert(off < 256);
443	Assert(u32Val < 256);
444
445	int rc = PDMDevHlpCMOSWrite(pDevIns, off, u32Val);
446	AssertRC(rc);
447	}
448
449
450	/**
451	* Read from CMOS memory.
452	* This is used by the init complete code.
453	*/
454	static uint8_t pcbiosCmosRead(PPDMDEVINS pDevIns, unsigned off)
455	{
456	Assert(off < 256);
457
458	uint8_t u8val;
459	int rc = PDMDevHlpCMOSRead(pDevIns, off, &u8val);
460	AssertRC(rc);
461
462	return u8val;
463	}
464
465
466	/**
467	* @interface_method_impl{PDMFWREG,pfnIsHardReset}
468	*/
469	static DECLCALLBACK(bool) pcbiosFw_IsHardReset(PPDMDEVINS pDevIns, uint32_t fFlags)
470	{
471	RT_NOREF1(fFlags);
472	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
473	if (pThis->fCheckShutdownStatusForSoftReset)
474	{
475	uint8_t bShutdownStatus = pcbiosCmosRead(pDevIns, 0xf);
476	if ( bShutdownStatus == 0x5
477	\|\| bShutdownStatus == 0x9
478	\|\| bShutdownStatus == 0xa)
479	{
480	const uint32_t cMaxLogged = 10;
481	if (pThis->cLoggedSoftResets < cMaxLogged)
482	{
483	RTFAR16 Far16 = { 0xfeed, 0xface };
484	PDMDevHlpPhysRead(pDevIns, 0x467, &Far16, sizeof(Far16));
485	pThis->cLoggedSoftResets++;
486	LogRel(("PcBios: Soft reset #%u - shutdown status %#x, warm reset vector (0040:0067) is %04x:%04x%s\n",
487	pThis->cLoggedSoftResets, bShutdownStatus, Far16.sel, Far16.off,
488	pThis->cLoggedSoftResets < cMaxLogged ? "." : " - won't log any more!"));
489	}
490	return false;
491	}
492	}
493	return true;
494	}
495
496
497	/**
498	* @interface_method_impl{PDMDEVREG,pfnReset}
499	*/
500	static DECLCALLBACK(void) pcbiosReset(PPDMDEVINS pDevIns)
501	{
502	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
503
504	if (pThis->fClearShutdownStatusOnHardReset)
505	{
506	uint8_t bShutdownStatus = pcbiosCmosRead(pDevIns, 0xf);
507	if (bShutdownStatus != 0)
508	{
509	LogRel(("PcBios: Clearing shutdown status code %02x.\n", bShutdownStatus));
510	pcbiosCmosWrite(pDevIns, 0xf, 0);
511	}
512	}
513
514	/* After reset the new BIOS code is active, use the new shutdown port. */
515	pcbiosRegisterShutdown(pDevIns, pThis, true /* fNewShutdownPort */);
516	}
517
518
519	/**
520	* Attempt to guess the LCHS disk geometry from the MS-DOS master boot record
521	* (partition table).
522	*
523	* @returns VBox status code.
524	* @param pMedia The media device interface of the disk.
525	* @param pLCHSGeometry Where to return the disk geometry on success
526	*/
527	static int biosGuessDiskLCHS(PPDMIMEDIA pMedia, PPDMMEDIAGEOMETRY pLCHSGeometry)
528	{
529	uint8_t aMBR[512], *p;
530	int rc;
531	uint32_t iEndHead, iEndSector, cLCHSCylinders, cLCHSHeads, cLCHSSectors;
532
533	if (!pMedia)
534	return VERR_INVALID_PARAMETER;
535	rc = pMedia->pfnReadPcBios(pMedia, 0, aMBR, sizeof(aMBR));
536	if (RT_FAILURE(rc))
537	return rc;
538	/* Test MBR magic number. */
539	if (aMBR[510] != 0x55 \|\| aMBR[511] != 0xaa)
540	return VERR_INVALID_PARAMETER;
541	for (uint32_t i = 0; i < 4; i++)
542	{
543	/* Figure out the start of a partition table entry. */
544	p = &aMBR[0x1be + i * 16];
545	iEndHead = p[5];
546	iEndSector = p[6] & 63;
547	if ((p[12] \| p[13] \| p[14] \| p[15]) && iEndSector & iEndHead)
548	{
549	/* Assumption: partition terminates on a cylinder boundary. */
550	cLCHSHeads = iEndHead + 1;
551	cLCHSSectors = iEndSector;
552	cLCHSCylinders = RT_MIN(1024, pMedia->pfnGetSize(pMedia) / (512 * cLCHSHeads * cLCHSSectors));
553	if (cLCHSCylinders >= 1)
554	{
555	pLCHSGeometry->cCylinders = cLCHSCylinders;
556	pLCHSGeometry->cHeads = cLCHSHeads;
557	pLCHSGeometry->cSectors = cLCHSSectors;
558	Log(("%s: LCHS=%d %d %d\n", __FUNCTION__, cLCHSCylinders, cLCHSHeads, cLCHSSectors));
559	return VINF_SUCCESS;
560	}
561	}
562	}
563	return VERR_INVALID_PARAMETER;
564	}
565
566
567	/**
568	* Initializes the CMOS data for one harddisk.
569	*/
570	static void pcbiosCmosInitHardDisk(PPDMDEVINS pDevIns, int offType, int offInfo, PCPDMMEDIAGEOMETRY pLCHSGeometry)
571	{
572	Log2(("%s: offInfo=%#x: LCHS=%d/%d/%d\n", __FUNCTION__, offInfo, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
573	if (offType)
574	pcbiosCmosWrite(pDevIns, offType, 47);
575	/* Cylinders low */
576	pcbiosCmosWrite(pDevIns, offInfo + 0, RT_MIN(pLCHSGeometry->cCylinders, 1024) & 0xff);
577	/* Cylinders high */
578	pcbiosCmosWrite(pDevIns, offInfo + 1, RT_MIN(pLCHSGeometry->cCylinders, 1024) >> 8);
579	/* Heads */
580	pcbiosCmosWrite(pDevIns, offInfo + 2, pLCHSGeometry->cHeads);
581	/* Landing zone low */
582	pcbiosCmosWrite(pDevIns, offInfo + 3, 0xff);
583	/* Landing zone high */
584	pcbiosCmosWrite(pDevIns, offInfo + 4, 0xff);
585	/* Write precomp low */
586	pcbiosCmosWrite(pDevIns, offInfo + 5, 0xff);
587	/* Write precomp high */
588	pcbiosCmosWrite(pDevIns, offInfo + 6, 0xff);
589	/* Sectors */
590	pcbiosCmosWrite(pDevIns, offInfo + 7, pLCHSGeometry->cSectors);
591	}
592
593
594	/**
595	* Set logical CHS geometry for a hard disk
596	*
597	* @returns VBox status code.
598	* @param pBase Base interface for the device.
599	* @param pHardDisk The hard disk.
600	* @param pLCHSGeometry Where to store the geometry settings.
601	*/
602	static int setLogicalDiskGeometry(PPDMIBASE pBase, PPDMIMEDIA pHardDisk, PPDMMEDIAGEOMETRY pLCHSGeometry)
603	{
604	RT_NOREF1(pBase);
605
606	PDMMEDIAGEOMETRY LCHSGeometry;
607	int rc = pHardDisk->pfnBiosGetLCHSGeometry(pHardDisk, &LCHSGeometry);
608	if ( rc == VERR_PDM_GEOMETRY_NOT_SET
609	\|\| LCHSGeometry.cCylinders == 0
610	\|\| LCHSGeometry.cHeads == 0
611	\|\| LCHSGeometry.cHeads > 255
612	\|\| LCHSGeometry.cSectors == 0
613	\|\| LCHSGeometry.cSectors > 63)
614	{
615	/* No LCHS geometry, autodetect and set. */
616	rc = biosGuessDiskLCHS(pHardDisk, &LCHSGeometry);
617	if (RT_FAILURE(rc))
618	{
619	/* Try if PCHS geometry works, otherwise fall back. */
620	rc = pHardDisk->pfnBiosGetPCHSGeometry(pHardDisk, &LCHSGeometry);
621	}
622	if ( RT_FAILURE(rc)
623	\|\| LCHSGeometry.cCylinders == 0
624	\|\| LCHSGeometry.cCylinders > 1024
625	\|\| LCHSGeometry.cHeads == 0
626	\|\| LCHSGeometry.cHeads > 16
627	\|\| LCHSGeometry.cSectors == 0
628	\|\| LCHSGeometry.cSectors > 63)
629	{
630	uint64_t cSectors = pHardDisk->pfnGetSize(pHardDisk) / 512;
631	if (cSectors / 16 / 63 <= 1024)
632	{
633	LCHSGeometry.cCylinders = RT_MAX(cSectors / 16 / 63, 1);
634	LCHSGeometry.cHeads = 16;
635	}
636	else if (cSectors / 32 / 63 <= 1024)
637	{
638	LCHSGeometry.cCylinders = RT_MAX(cSectors / 32 / 63, 1);
639	LCHSGeometry.cHeads = 32;
640	}
641	else if (cSectors / 64 / 63 <= 1024)
642	{
643	LCHSGeometry.cCylinders = cSectors / 64 / 63;
644	LCHSGeometry.cHeads = 64;
645	}
646	else if (cSectors / 128 / 63 <= 1024)
647	{
648	LCHSGeometry.cCylinders = cSectors / 128 / 63;
649	LCHSGeometry.cHeads = 128;
650	}
651	else
652	{
653	LCHSGeometry.cCylinders = RT_MIN(cSectors / 255 / 63, 1024);
654	LCHSGeometry.cHeads = 255;
655	}
656	LCHSGeometry.cSectors = 63;
657
658	}
659	rc = pHardDisk->pfnBiosSetLCHSGeometry(pHardDisk, &LCHSGeometry);
660	if (rc == VERR_VD_IMAGE_READ_ONLY)
661	{
662	LogRel(("PcBios: ATA failed to update LCHS geometry, read only\n"));
663	rc = VINF_SUCCESS;
664	}
665	else if (rc == VERR_PDM_GEOMETRY_NOT_SET)
666	{
667	LogRel(("PcBios: ATA failed to update LCHS geometry, backend refused\n"));
668	rc = VINF_SUCCESS;
669	}
670	}
671
672	*pLCHSGeometry = LCHSGeometry;
673
674	return rc;
675	}
676
677
678	/**
679	* Get logical CHS geometry for a hard disk, intended for SCSI/SAS drives
680	* with no physical geometry.
681	*
682	* @returns VBox status code.
683	* @param pHardDisk The hard disk.
684	* @param pLCHSGeometry Where to store the geometry settings.
685	*/
686	static int getLogicalDiskGeometry(PPDMIMEDIA pHardDisk, PPDMMEDIAGEOMETRY pLCHSGeometry)
687	{
688	PDMMEDIAGEOMETRY LCHSGeometry;
689	int rc = VINF_SUCCESS;
690
691	rc = pHardDisk->pfnBiosGetLCHSGeometry(pHardDisk, &LCHSGeometry);
692	if ( rc == VERR_PDM_GEOMETRY_NOT_SET
693	\|\| LCHSGeometry.cCylinders == 0
694	\|\| LCHSGeometry.cHeads == 0
695	\|\| LCHSGeometry.cHeads > 255
696	\|\| LCHSGeometry.cSectors == 0
697	\|\| LCHSGeometry.cSectors > 63)
698	{
699	/* Unlike the ATA case, if the image does not provide valid logical
700	* geometry, we leave things alone and let the BIOS decide what the
701	* logical geometry should be.
702	*/
703	rc = VERR_PDM_GEOMETRY_NOT_SET;
704	}
705	else
706	*pLCHSGeometry = LCHSGeometry;
707
708	return rc;
709	}
710
711
712	/**
713	* Get BIOS boot code from enmBootDevice in order
714	*
715	* @todo r=bird: This is a rather silly function since the conversion is 1:1.
716	*/
717	static uint8_t getBiosBootCode(PDEVPCBIOS pThis, unsigned iOrder)
718	{
719	switch (pThis->aenmBootDevice[iOrder])
720	{
721	case DEVPCBIOSBOOT_NONE:
722	return 0;
723	case DEVPCBIOSBOOT_FLOPPY:
724	return 1;
725	case DEVPCBIOSBOOT_HD:
726	return 2;
727	case DEVPCBIOSBOOT_DVD:
728	return 3;
729	case DEVPCBIOSBOOT_LAN:
730	return 4;
731	default:
732	AssertMsgFailed(("aenmBootDevice[%d]=%d\n", iOrder, pThis->aenmBootDevice[iOrder]));
733	return 0;
734	}
735	}
736
737
738	/**
739	* @interface_method_impl{PDMDEVREG,pfnInitComplete}
740	*
741	* This routine will write information needed by the bios to the CMOS.
742	*
743	* @see http://www.brl.ntt.co.jp/people/takehiko/interrupt/CMOS.LST.txt for
744	* a description of standard and non-standard CMOS registers.
745	*/
746	static DECLCALLBACK(int) pcbiosInitComplete(PPDMDEVINS pDevIns)
747	{
748	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
749	uint32_t u32;
750	unsigned i;
751	PUVM pUVM = PDMDevHlpGetUVM(pDevIns); AssertRelease(pUVM);
752	PPDMIMEDIA apHDs[4] = {0};
753	LogFlow(("pcbiosInitComplete:\n"));
754
755	PVM pVM = PDMDevHlpGetVM(pDevIns);
756	uint64_t const cbRamSize = MMR3PhysGetRamSize(pVM);
757	uint32_t const cbBelow4GB = MMR3PhysGetRamSizeBelow4GB(pVM);
758	uint64_t const cbAbove4GB = MMR3PhysGetRamSizeAbove4GB(pVM);
759
760	/*
761	* Memory sizes.
762	*/
763	/* base memory. */
764	u32 = cbRamSize > 640 ? 640 : (uint32_t)cbRamSize / _1K; /* <-- this test is wrong, but it doesn't matter since we never assign less than 1MB */
765	pcbiosCmosWrite(pDevIns, 0x15, RT_BYTE1(u32)); /* 15h - Base Memory in K, Low Byte */
766	pcbiosCmosWrite(pDevIns, 0x16, RT_BYTE2(u32)); /* 16h - Base Memory in K, High Byte */
767
768	/* Extended memory, up to 65MB */
769	u32 = cbRamSize >= 65 * _1M ? 0xffff : ((uint32_t)cbRamSize - _1M) / _1K;
770	pcbiosCmosWrite(pDevIns, 0x17, RT_BYTE1(u32)); /* 17h - Extended Memory in K, Low Byte */
771	pcbiosCmosWrite(pDevIns, 0x18, RT_BYTE2(u32)); /* 18h - Extended Memory in K, High Byte */
772	pcbiosCmosWrite(pDevIns, 0x30, RT_BYTE1(u32)); /* 30h - Extended Memory in K, Low Byte */
773	pcbiosCmosWrite(pDevIns, 0x31, RT_BYTE2(u32)); /* 31h - Extended Memory in K, High Byte */
774
775	/* Bochs BIOS specific? Anyway, it's the amount of memory above 16MB
776	and below 4GB (as it can only hold 4GB-16M). We have to chop off the
777	top 32MB or it conflict with what the ACPI tables return. (Should these
778	be adjusted, we still have to chop it at 0xfffc0000 or it'll conflict
779	with the high BIOS mapping.) */
780	if (cbRamSize > 16 * _1M)
781	u32 = (RT_MIN(cbBelow4GB, UINT32_C(0xfe000000)) - 16U * _1M) / _64K;
782	else
783	u32 = 0;
784	pcbiosCmosWrite(pDevIns, 0x34, RT_BYTE1(u32));
785	pcbiosCmosWrite(pDevIns, 0x35, RT_BYTE2(u32));
786
787	/* Bochs/VBox BIOS specific way of specifying memory above 4GB in 64KB units.
788	Bochs got these in a different location which we've already used for SATA,
789	it also lacks the last two. */
790	uint64_t c64KBAbove4GB = cbAbove4GB / _64K;
791	/* Make sure it doesn't hit the limits of the current BIOS code (RAM limit of ~255TB). */
792	AssertLogRelMsgReturn((c64KBAbove4GB >> (3 * 8)) < 255, ("%#RX64\n", c64KBAbove4GB), VERR_OUT_OF_RANGE);
793	pcbiosCmosWrite(pDevIns, 0x61, RT_BYTE1(c64KBAbove4GB));
794	pcbiosCmosWrite(pDevIns, 0x62, RT_BYTE2(c64KBAbove4GB));
795	pcbiosCmosWrite(pDevIns, 0x63, RT_BYTE3(c64KBAbove4GB));
796	pcbiosCmosWrite(pDevIns, 0x64, RT_BYTE4(c64KBAbove4GB));
797	pcbiosCmosWrite(pDevIns, 0x65, RT_BYTE5(c64KBAbove4GB));
798
799	/*
800	* Number of CPUs.
801	*/
802	pcbiosCmosWrite(pDevIns, 0x60, pThis->cCpus & 0xff);
803
804	/*
805	* APIC mode.
806	*/
807	pcbiosCmosWrite(pDevIns, 0x78, pThis->u8APICMode);
808
809	/*
810	* Bochs BIOS specifics - boot device.
811	* We do both new and old (ami-style) settings.
812	* See rombios.c line ~7215 (int19_function).
813	*/
814
815	uint8_t reg3d = getBiosBootCode(pThis, 0) \| (getBiosBootCode(pThis, 1) << 4);
816	uint8_t reg38 = /* pcbiosCmosRead(pDevIns, 0x38) \| */ getBiosBootCode(pThis, 2) << 4;
817	/* This is an extension. Bochs BIOS normally supports only 3 boot devices. */
818	uint8_t reg3c = getBiosBootCode(pThis, 3) \| (pThis->uBootDelay << 4);
819	pcbiosCmosWrite(pDevIns, 0x3d, reg3d);
820	pcbiosCmosWrite(pDevIns, 0x38, reg38);
821	pcbiosCmosWrite(pDevIns, 0x3c, reg3c);
822
823	/*
824	* PXE debug option.
825	*/
826	pcbiosCmosWrite(pDevIns, 0x3f, pThis->u8PXEDebug);
827
828	/*
829	* Network boot device list.
830	*/
831	for (i = 0; i < NET_BOOT_DEVS; ++i)
832	{
833	pcbiosCmosWrite(pDevIns, 0x82 + i * 2, RT_BYTE1(pThis->au16NetBootDev[i]));
834	pcbiosCmosWrite(pDevIns, 0x83 + i * 2, RT_BYTE2(pThis->au16NetBootDev[i]));
835	}
836
837	/*
838	* Floppy drive type.
839	*/
840	uint32_t cFDs = 0;
841	u32 = 0;
842	for (i = 0; i < 2; i++)
843	{
844	PPDMIBASE pBase;
845	int rc = PDMR3QueryLun(pUVM, pThis->pszFDDevice, 0, i, &pBase);
846	if (RT_SUCCESS(rc))
847	{
848	PPDMIMEDIA pFD = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMEDIA);
849	if (pFD)
850	{
851	cFDs++;
852	unsigned cShift = i == 0 ? 4 : 0;
853	switch (pFD->pfnGetType(pFD))
854	{
855	case PDMMEDIATYPE_FLOPPY_360: u32 \|= 1 << cShift; break;
856	case PDMMEDIATYPE_FLOPPY_1_20: u32 \|= 2 << cShift; break;
857	case PDMMEDIATYPE_FLOPPY_720: u32 \|= 3 << cShift; break;
858	case PDMMEDIATYPE_FLOPPY_1_44: u32 \|= 4 << cShift; break;
859	case PDMMEDIATYPE_FLOPPY_2_88: u32 \|= 5 << cShift; break;
860	case PDMMEDIATYPE_FLOPPY_FAKE_15_6: u32 \|= 14 << cShift; break;
861	case PDMMEDIATYPE_FLOPPY_FAKE_63_5: u32 \|= 15 << cShift; break;
862	default: AssertFailed(); break;
863	}
864	}
865	}
866	}
867	pcbiosCmosWrite(pDevIns, 0x10, u32); /* 10h - Floppy Drive Type */
868
869	/*
870	* Equipment byte.
871	*/
872	if (cFDs > 0)
873	u32 = ((cFDs - 1) << 6) \| 0x01; /* floppy installed, additional drives. */
874	else
875	u32 = 0x00; /* floppy not installed. */
876	u32 \|= RT_BIT(1); /* math coprocessor installed */
877	u32 \|= RT_BIT(2); /* keyboard enabled (or mouse?) */
878	u32 \|= RT_BIT(3); /* display enabled (monitory type is 0, i.e. vga) */
879	pcbiosCmosWrite(pDevIns, 0x14, u32); /* 14h - Equipment Byte */
880
881	/*
882	* IDE harddisks.
883	*/
884	for (i = 0; i < RT_ELEMENTS(apHDs); i++)
885	{
886	PPDMIBASE pBase;
887	int rc = PDMR3QueryLun(pUVM, pThis->pszHDDevice, 0, i, &pBase);
888	if (RT_SUCCESS(rc))
889	apHDs[i] = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMEDIA);
890	if ( apHDs[i]
891	&& ( apHDs[i]->pfnGetType(apHDs[i]) != PDMMEDIATYPE_HARD_DISK
892	\|\| !apHDs[i]->pfnBiosIsVisible(apHDs[i])))
893	apHDs[i] = NULL;
894	if (apHDs[i])
895	{
896	PDMMEDIAGEOMETRY LCHSGeometry;
897	int rc2 = setLogicalDiskGeometry(pBase, apHDs[i], &LCHSGeometry);
898	AssertRC(rc2);
899
900	if (i < 4)
901	{
902	/* Award BIOS extended drive types for first to fourth disk.
903	* Used by the BIOS for setting the logical geometry. */
904	int offType, offInfo;
905	switch (i)
906	{
907	case 0:
908	offType = 0x19;
909	offInfo = 0x1e;
910	break;
911	case 1:
912	offType = 0x1a;
913	offInfo = 0x26;
914	break;
915	case 2:
916	offType = 0x00;
917	offInfo = 0x67;
918	break;
919	case 3:
920	default:
921	offType = 0x00;
922	offInfo = 0x70;
923	break;
924	}
925	pcbiosCmosInitHardDisk(pDevIns, offType, offInfo,
926	&LCHSGeometry);
927	}
928	LogRel(("PcBios: ATA LUN#%d LCHS=%u/%u/%u\n", i, LCHSGeometry.cCylinders, LCHSGeometry.cHeads, LCHSGeometry.cSectors));
929	}
930	}
931
932	/* 0Fh means extended and points to 19h, 1Ah */
933	u32 = (apHDs[0] ? 0xf0 : 0) \| (apHDs[1] ? 0x0f : 0);
934	pcbiosCmosWrite(pDevIns, 0x12, u32);
935
936	/*
937	* SATA harddisks.
938	*/
939	if (pThis->pszSataDevice)
940	{
941	/* Clear pointers to the block devices. */
942	for (i = 0; i < RT_ELEMENTS(apHDs); i++)
943	apHDs[i] = NULL;
944
945	for (i = 0; i < RT_ELEMENTS(apHDs); i++)
946	{
947	PPDMIBASE pBase;
948	int rc = PDMR3QueryLun(pUVM, pThis->pszSataDevice, 0, pThis->iSataHDLUN[i], &pBase);
949	if (RT_SUCCESS(rc))
950	apHDs[i] = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMEDIA);
951	if ( apHDs[i]
952	&& ( apHDs[i]->pfnGetType(apHDs[i]) != PDMMEDIATYPE_HARD_DISK
953	\|\| !apHDs[i]->pfnBiosIsVisible(apHDs[i])))
954	apHDs[i] = NULL;
955	if (apHDs[i])
956	{
957	PDMMEDIAGEOMETRY LCHSGeometry;
958	rc = setLogicalDiskGeometry(pBase, apHDs[i], &LCHSGeometry);
959	AssertRC(rc);
960
961	if (i < 4)
962	{
963	/* Award BIOS extended drive types for first to fourth disk.
964	* Used by the BIOS for setting the logical geometry. */
965	int offInfo;
966	switch (i)
967	{
968	case 0:
969	offInfo = 0x40;
970	break;
971	case 1:
972	offInfo = 0x48;
973	break;
974	case 2:
975	offInfo = 0x50;
976	break;
977	case 3:
978	default:
979	offInfo = 0x58;
980	break;
981	}
982	pcbiosCmosInitHardDisk(pDevIns, 0x00, offInfo,
983	&LCHSGeometry);
984	}
985	LogRel(("PcBios: SATA LUN#%d LCHS=%u/%u/%u\n", i, LCHSGeometry.cCylinders, LCHSGeometry.cHeads, LCHSGeometry.cSectors));
986	}
987	}
988	}
989
990	/*
991	* SCSI harddisks. Not handled quite the same as SATA.
992	*/
993	if (pThis->pszScsiDevice)
994	{
995	/* Clear pointers to the block devices. */
996	for (i = 0; i < RT_ELEMENTS(apHDs); i++)
997	apHDs[i] = NULL;
998
999	for (i = 0; i < RT_ELEMENTS(apHDs); i++)
1000	{
1001	PPDMIBASE pBase;
1002	int rc = PDMR3QueryLun(pUVM, pThis->pszScsiDevice, 0, pThis->iScsiHDLUN[i], &pBase);
1003	if (RT_SUCCESS(rc))
1004	apHDs[i] = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMEDIA);
1005	if ( apHDs[i]
1006	&& ( apHDs[i]->pfnGetType(apHDs[i]) != PDMMEDIATYPE_HARD_DISK
1007	\|\| !apHDs[i]->pfnBiosIsVisible(apHDs[i])))
1008	apHDs[i] = NULL;
1009	if (apHDs[i])
1010	{
1011	PDMMEDIAGEOMETRY LCHSGeometry;
1012	rc = getLogicalDiskGeometry(apHDs[i], &LCHSGeometry);
1013
1014	if (i < 4 && RT_SUCCESS(rc))
1015	{
1016	/* Extended drive information (for SCSI disks).
1017	* Used by the BIOS for setting the logical geometry, but
1018	* only if the image provided valid data.
1019	*/
1020	int offInfo;
1021	switch (i)
1022	{
1023	case 0:
1024	offInfo = 0x90;
1025	break;
1026	case 1:
1027	offInfo = 0x98;
1028	break;
1029	case 2:
1030	offInfo = 0xa0;
1031	break;
1032	case 3:
1033	default:
1034	offInfo = 0xa8;
1035	break;
1036	}
1037	pcbiosCmosInitHardDisk(pDevIns, 0x00, offInfo, &LCHSGeometry);
1038	LogRel(("PcBios: SCSI LUN#%d LCHS=%u/%u/%u\n", i, LCHSGeometry.cCylinders, LCHSGeometry.cHeads, LCHSGeometry.cSectors));
1039	}
1040	else
1041	LogRel(("PcBios: SCSI LUN#%d LCHS not provided\n", i));
1042	}
1043	}
1044	}
1045
1046	/* Calculate and store AT-style CMOS checksum. */
1047	uint16_t cksum = 0;
1048	for (i = 0x10; i < 0x2e; ++i)
1049	cksum += pcbiosCmosRead(pDevIns, i);
1050	pcbiosCmosWrite(pDevIns, 0x2e, RT_BYTE1(cksum));
1051	pcbiosCmosWrite(pDevIns, 0x2f, RT_BYTE2(cksum));
1052
1053	LogFlow(("%s: returns VINF_SUCCESS\n", __FUNCTION__));
1054	return VINF_SUCCESS;
1055	}
1056
1057
1058	/**
1059	* @interface_method_impl{PDMDEVREG,pfnMemSetup}
1060	*/
1061	static DECLCALLBACK(void) pcbiosMemSetup(PPDMDEVINS pDevIns, PDMDEVMEMSETUPCTX enmCtx)
1062	{
1063	RT_NOREF1(enmCtx);
1064	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
1065	LogFlow(("pcbiosMemSetup:\n"));
1066
1067	if (pThis->u8IOAPIC)
1068	FwCommonPlantMpsFloatPtr(pDevIns, pThis->u32MPTableAddr);
1069
1070	/*
1071	* Re-shadow the LAN ROM image and make it RAM/RAM.
1072	*
1073	* This is normally done by the BIOS code, but since we're currently lacking
1074	* the chipset support for this we do it here (and in the constructor).
1075	*/
1076	uint32_t cPages = RT_ALIGN_64(pThis->cbLanBoot, PAGE_SIZE) >> PAGE_SHIFT;
1077	RTGCPHYS GCPhys = VBOX_LANBOOT_SEG << 4;
1078	while (cPages > 0)
1079	{
1080	uint8_t abPage[PAGE_SIZE];
1081	int rc;
1082
1083	/* Read the (original) ROM page and write it back to the RAM page. */
1084	rc = PDMDevHlpROMProtectShadow(pDevIns, GCPhys, PAGE_SIZE, PGMROMPROT_READ_ROM_WRITE_RAM);
1085	AssertLogRelRC(rc);
1086
1087	rc = PDMDevHlpPhysRead(pDevIns, GCPhys, abPage, PAGE_SIZE);
1088	AssertLogRelRC(rc);
1089	if (RT_FAILURE(rc))
1090	memset(abPage, 0xcc, sizeof(abPage));
1091
1092	rc = PDMDevHlpPhysWrite(pDevIns, GCPhys, abPage, PAGE_SIZE);
1093	AssertLogRelRC(rc);
1094
1095	/* Switch to the RAM/RAM mode. */
1096	rc = PDMDevHlpROMProtectShadow(pDevIns, GCPhys, PAGE_SIZE, PGMROMPROT_READ_RAM_WRITE_RAM);
1097	AssertLogRelRC(rc);
1098
1099	/* Advance */
1100	GCPhys += PAGE_SIZE;
1101	cPages--;
1102	}
1103	}
1104
1105
1106	/**
1107	* @interface_method_impl{PDMDEVREG,pfnDestruct}
1108	*/
1109	static DECLCALLBACK(int) pcbiosDestruct(PPDMDEVINS pDevIns)
1110	{
1111	PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
1112	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
1113	LogFlow(("pcbiosDestruct:\n"));
1114
1115	/*
1116	* Free MM heap pointers.
1117	*/
1118	if (pThis->pu8PcBios)
1119	{
1120	PDMDevHlpMMHeapFree(pDevIns, pThis->pu8PcBios);
1121	pThis->pu8PcBios = NULL;
1122	}
1123
1124	if (pThis->pszPcBiosFile)
1125	{
1126	PDMDevHlpMMHeapFree(pDevIns, pThis->pszPcBiosFile);
1127	pThis->pszPcBiosFile = NULL;
1128	}
1129
1130	if (pThis->pu8LanBoot)
1131	{
1132	PDMDevHlpMMHeapFree(pDevIns, pThis->pu8LanBoot);
1133	pThis->pu8LanBoot = NULL;
1134	}
1135
1136	if (pThis->pszLanBootFile)
1137	{
1138	PDMDevHlpMMHeapFree(pDevIns, pThis->pszLanBootFile);
1139	pThis->pszLanBootFile = NULL;
1140	}
1141
1142	if (pThis->pszHDDevice)
1143	{
1144	PDMDevHlpMMHeapFree(pDevIns, pThis->pszHDDevice);
1145	pThis->pszHDDevice = NULL;
1146	}
1147
1148	if (pThis->pszFDDevice)
1149	{
1150	PDMDevHlpMMHeapFree(pDevIns, pThis->pszFDDevice);
1151	pThis->pszFDDevice = NULL;
1152	}
1153
1154	if (pThis->pszSataDevice)
1155	{
1156	PDMDevHlpMMHeapFree(pDevIns, pThis->pszSataDevice);
1157	pThis->pszSataDevice = NULL;
1158	}
1159
1160	if (pThis->pszScsiDevice)
1161	{
1162	PDMDevHlpMMHeapFree(pDevIns, pThis->pszScsiDevice);
1163	pThis->pszScsiDevice = NULL;
1164	}
1165
1166	return VINF_SUCCESS;
1167	}
1168
1169
1170	/**
1171	* Convert config value to DEVPCBIOSBOOT.
1172	*
1173	* @returns VBox status code.
1174	* @param pDevIns Device instance data.
1175	* @param pCfg Configuration handle.
1176	* @param pszParam The name of the value to read.
1177	* @param penmBoot Where to store the boot method.
1178	*/
1179	static int pcbiosBootFromCfg(PPDMDEVINS pDevIns, PCFGMNODE pCfg, const char pszParam, DEVPCBIOSBOOT penmBoot)
1180	{
1181	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1182
1183	char szBuf[64];
1184	int rc = pHlp->pfnCFGMQueryString(pCfg, pszParam, szBuf, sizeof(szBuf));
1185	if (RT_FAILURE(rc))
1186	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
1187	N_("Configuration error: Querying \"%s\" as a string failed"), pszParam);
1188
1189	if (!strcmp(szBuf, "DVD") \|\| !strcmp(szBuf, "CDROM"))
1190	*penmBoot = DEVPCBIOSBOOT_DVD;
1191	else if (!strcmp(szBuf, "IDE"))
1192	*penmBoot = DEVPCBIOSBOOT_HD;
1193	else if (!strcmp(szBuf, "FLOPPY"))
1194	*penmBoot = DEVPCBIOSBOOT_FLOPPY;
1195	else if (!strcmp(szBuf, "LAN"))
1196	*penmBoot = DEVPCBIOSBOOT_LAN;
1197	else if (!strcmp(szBuf, "NONE"))
1198	*penmBoot = DEVPCBIOSBOOT_NONE;
1199	else
1200	rc = PDMDevHlpVMSetError(pDevIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
1201	N_("Configuration error: The \"%s\" value \"%s\" is unknown"), pszParam, szBuf);
1202	return rc;
1203	}
1204
1205
1206	/**
1207	* @interface_method_impl{PDMDEVREG,pfnConstruct}
1208	*/
1209	static DECLCALLBACK(int) pcbiosConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
1210	{
1211	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
1212	PDEVPCBIOS pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPCBIOS);
1213	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1214	int rc;
1215	int cb;
1216	Assert(iInstance == 0); RT_NOREF(iInstance);
1217
1218	/*
1219	* Validate configuration.
1220	*/
1221	PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns,
1222	"BootDevice0"
1223	"\|BootDevice1"
1224	"\|BootDevice2"
1225	"\|BootDevice3"
1226	"\|HardDiskDevice"
1227	"\|SataHardDiskDevice"
1228	"\|SataLUN1"
1229	"\|SataLUN2"
1230	"\|SataLUN3"
1231	"\|SataLUN4"
1232	"\|ScsiHardDiskDevice"
1233	"\|ScsiLUN1"
1234	"\|ScsiLUN2"
1235	"\|ScsiLUN3"
1236	"\|ScsiLUN4"
1237	"\|FloppyDevice"
1238	"\|DelayBoot"
1239	"\|BiosRom"
1240	"\|LanBootRom"
1241	"\|PXEDebug"
1242	"\|UUID"
1243	"\|UuidLe"
1244	"\|IOAPIC"
1245	"\|APIC"
1246	"\|NumCPUs"
1247	"\|McfgBase"
1248	"\|McfgLength"
1249	"\|DmiBIOSFirmwareMajor"
1250	"\|DmiBIOSFirmwareMinor"
1251	"\|DmiBIOSReleaseDate"
1252	"\|DmiBIOSReleaseMajor"
1253	"\|DmiBIOSReleaseMinor"
1254	"\|DmiBIOSVendor"
1255	"\|DmiBIOSVersion"
1256	"\|DmiSystemFamily"
1257	"\|DmiSystemProduct"
1258	"\|DmiSystemSerial"
1259	"\|DmiSystemSKU"
1260	"\|DmiSystemUuid"
1261	"\|DmiSystemVendor"
1262	"\|DmiSystemVersion"
1263	"\|DmiBoardAssetTag"
1264	"\|DmiBoardBoardType"
1265	"\|DmiBoardLocInChass"
1266	"\|DmiBoardProduct"
1267	"\|DmiBoardSerial"
1268	"\|DmiBoardVendor"
1269	"\|DmiBoardVersion"
1270	"\|DmiChassisAssetTag"
1271	"\|DmiChassisSerial"
1272	"\|DmiChassisType"
1273	"\|DmiChassisVendor"
1274	"\|DmiChassisVersion"
1275	"\|DmiProcManufacturer"
1276	"\|DmiProcVersion"
1277	"\|DmiOEMVBoxVer"
1278	"\|DmiOEMVBoxRev"
1279	"\|DmiUseHostInfo"
1280	"\|DmiExposeMemoryTable"
1281	"\|DmiExposeProcInf"
1282	"\|CheckShutdownStatusForSoftReset"
1283	"\|ClearShutdownStatusOnHardReset"
1284	,
1285	"NetBoot");
1286	/*
1287	* Init the data.
1288	*/
1289	rc = pHlp->pfnCFGMQueryU16Def(pCfg, "NumCPUs", &pThis->cCpus, 1);
1290	if (RT_FAILURE(rc))
1291	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Querying \"NumCPUs\" as integer failed"));
1292
1293	rc = pHlp->pfnCFGMQueryU64Def(pCfg, "McfgBase", &pThis->u64McfgBase, 0);
1294	if (RT_FAILURE(rc))
1295	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Querying \"\" as integer failed"));
1296	rc = pHlp->pfnCFGMQueryU64Def(pCfg, "McfgLength", &pThis->cbMcfgLength, 0);
1297	if (RT_FAILURE(rc))
1298	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Querying \"McfgLength\" as integer failed"));
1299
1300
1301	LogRel(("PcBios: [SMP] BIOS with %u CPUs\n", pThis->cCpus));
1302
1303	rc = pHlp->pfnCFGMQueryU8Def(pCfg, "IOAPIC", &pThis->u8IOAPIC, 1);
1304	if (RT_FAILURE (rc))
1305	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to read \"IOAPIC\""));
1306
1307	rc = pHlp->pfnCFGMQueryU8Def(pCfg, "APIC", &pThis->u8APICMode, 1);
1308	if (RT_FAILURE (rc))
1309	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to read \"APIC\""));
1310
1311	static const char * const s_apszBootDevices[] = { "BootDevice0", "BootDevice1", "BootDevice2", "BootDevice3" };
1312	Assert(RT_ELEMENTS(s_apszBootDevices) == RT_ELEMENTS(pThis->aenmBootDevice));
1313	for (unsigned i = 0; i < RT_ELEMENTS(pThis->aenmBootDevice); i++)
1314	{
1315	rc = pcbiosBootFromCfg(pDevIns, pCfg, s_apszBootDevices[i], &pThis->aenmBootDevice[i]);
1316	if (RT_FAILURE(rc))
1317	return rc;
1318	}
1319
1320	rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "HardDiskDevice", &pThis->pszHDDevice);
1321	if (RT_FAILURE(rc))
1322	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Querying \"HardDiskDevice\" as a string failed"));
1323
1324	rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "FloppyDevice", &pThis->pszFDDevice);
1325	if (RT_FAILURE(rc))
1326	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Querying \"FloppyDevice\" as a string failed"));
1327
1328	rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "SataHardDiskDevice", &pThis->pszSataDevice);
1329	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1330	pThis->pszSataDevice = NULL;
1331	else if (RT_FAILURE(rc))
1332	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Querying \"SataHardDiskDevice\" as a string failed"));
1333
1334	if (pThis->pszSataDevice)
1335	{
1336	static const char * const s_apszSataDisks[] = { "SataLUN1", "SataLUN2", "SataLUN3", "SataLUN4" };
1337	Assert(RT_ELEMENTS(s_apszSataDisks) == RT_ELEMENTS(pThis->iSataHDLUN));
1338	for (unsigned i = 0; i < RT_ELEMENTS(pThis->iSataHDLUN); i++)
1339	{
1340	rc = pHlp->pfnCFGMQueryU32(pCfg, s_apszSataDisks[i], &pThis->iSataHDLUN[i]);
1341	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1342	pThis->iSataHDLUN[i] = i;
1343	else if (RT_FAILURE(rc))
1344	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
1345	N_("Configuration error: Querying \"%s\" as a string failed"), s_apszSataDisks);
1346	}
1347	}
1348
1349	/* Repeat the exercise for SCSI drives. */
1350	rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "ScsiHardDiskDevice", &pThis->pszScsiDevice);
1351	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1352	pThis->pszScsiDevice = NULL;
1353	else if (RT_FAILURE(rc))
1354	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Querying \"ScsiHardDiskDevice\" as a string failed"));
1355
1356	if (pThis->pszScsiDevice)
1357	{
1358	static const char * const s_apszScsiDisks[] = { "ScsiLUN1", "ScsiLUN2", "ScsiLUN3", "ScsiLUN4" };
1359	Assert(RT_ELEMENTS(s_apszScsiDisks) == RT_ELEMENTS(pThis->iScsiHDLUN));
1360	for (unsigned i = 0; i < RT_ELEMENTS(pThis->iScsiHDLUN); i++)
1361	{
1362	rc = pHlp->pfnCFGMQueryU32(pCfg, s_apszScsiDisks[i], &pThis->iScsiHDLUN[i]);
1363	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1364	pThis->iScsiHDLUN[i] = i;
1365	else if (RT_FAILURE(rc))
1366	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
1367	N_("Configuration error: Querying \"%s\" as a string failed"), s_apszScsiDisks);
1368	}
1369	}
1370
1371	/* PXE debug logging option. */
1372	rc = pHlp->pfnCFGMQueryU8Def(pCfg, "PXEDebug", &pThis->u8PXEDebug, false);
1373	if (RT_FAILURE(rc))
1374	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Querying \"PXEDebug\" as integer failed"));
1375
1376
1377	/*
1378	* Register the I/O Ports.
1379	*/
1380	IOMIOPORTHANDLE hIoPorts;
1381	rc = PDMDevHlpIoPortCreateAndMap(pDevIns, 0x400 /uPort/, 4 /cPorts/, pcbiosIOPortDebugWrite, pcbiosIOPortDebugRead,
1382	"Bochs PC BIOS - Panic & Debug", NULL, &hIoPorts);
1383	AssertRCReturn(rc, rc);
1384
1385	rc = PDMDevHlpIoPortCreateIsa(pDevIns, 1 /cPorts/, pcbiosIOPortShutdownWrite, pcbiosIOPortShutdownRead, NULL /pvUser/,
1386	"Bochs PC BIOS - Shutdown", NULL /paExtDescs/, &pThis->hIoPortShutdown);
1387	AssertRCReturn(rc, rc);
1388	rc = pcbiosRegisterShutdown(pDevIns, pThis, true /* fNewShutdownPort */);
1389	AssertRCReturn(rc, rc);
1390
1391	/*
1392	* Register SSM handlers, for remembering which shutdown port to use.
1393	*/
1394	rc = PDMDevHlpSSMRegisterEx(pDevIns, PCBIOS_SSM_VERSION, 1 /* cbGuess */, NULL,
1395	NULL, NULL, NULL,
1396	NULL, pcbiosSaveExec, NULL,
1397	pcbiosLoadPrep, pcbiosLoadExec, pcbiosLoadDone);
1398
1399	/* Clear the net boot device list. All bits set invokes old behavior,
1400	* as if no second CMOS bank was present.
1401	*/
1402	memset(&pThis->au16NetBootDev, 0xff, sizeof(pThis->au16NetBootDev));
1403
1404	/*
1405	* Determine the network boot order.
1406	*/
1407	PCFGMNODE pCfgNetBoot = pHlp->pfnCFGMGetChild(pCfg, "NetBoot");
1408	if (pCfgNetBoot == NULL)
1409	{
1410	/* Do nothing. */
1411	rc = VINF_SUCCESS;
1412	}
1413	else
1414	{
1415	PCFGMNODE pCfgNetBootDevice;
1416	uint8_t u8PciBus;
1417	uint8_t u8PciDev;
1418	uint8_t u8PciFn;
1419	uint16_t u16BusDevFn;
1420	char szIndex[] = "?";
1421
1422	Assert(pCfgNetBoot);
1423	for (unsigned i = 0; i < NET_BOOT_DEVS; ++i)
1424	{
1425	szIndex[0] = '0' + i;
1426	pCfgNetBootDevice = pHlp->pfnCFGMGetChild(pCfgNetBoot, szIndex);
1427
1428	rc = pHlp->pfnCFGMQueryU8(pCfgNetBootDevice, "PCIBusNo", &u8PciBus);
1429	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
1430	{
1431	/* Do nothing and stop iterating. */
1432	rc = VINF_SUCCESS;
1433	break;
1434	}
1435	else if (RT_FAILURE(rc))
1436	return PDMDEV_SET_ERROR(pDevIns, rc,
1437	N_("Configuration error: Querying \"Netboot/x/PCIBusNo\" as integer failed"));
1438	rc = pHlp->pfnCFGMQueryU8(pCfgNetBootDevice, "PCIDeviceNo", &u8PciDev);
1439	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
1440	{
1441	/* Do nothing and stop iterating. */
1442	rc = VINF_SUCCESS;
1443	break;
1444	}
1445	else if (RT_FAILURE(rc))
1446	return PDMDEV_SET_ERROR(pDevIns, rc,
1447	N_("Configuration error: Querying \"Netboot/x/PCIDeviceNo\" as integer failed"));
1448	rc = pHlp->pfnCFGMQueryU8(pCfgNetBootDevice, "PCIFunctionNo", &u8PciFn);
1449	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
1450	{
1451	/* Do nothing and stop iterating. */
1452	rc = VINF_SUCCESS;
1453	break;
1454	}
1455	else if (RT_FAILURE(rc))
1456	return PDMDEV_SET_ERROR(pDevIns, rc,
1457	N_("Configuration error: Querying \"Netboot/x/PCIFunctionNo\" as integer failed"));
1458	u16BusDevFn = (((uint16_t)u8PciBus) << 8) \| ((u8PciDev & 0x1F) << 3) \| (u8PciFn & 0x7);
1459	pThis->au16NetBootDev[i] = u16BusDevFn;
1460	}
1461	}
1462
1463	/*
1464	* Get the system BIOS ROM file name.
1465	*/
1466	rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "BiosRom", &pThis->pszPcBiosFile);
1467	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1468	{
1469	pThis->pszPcBiosFile = NULL;
1470	rc = VINF_SUCCESS;
1471	}
1472	else if (RT_FAILURE(rc))
1473	return PDMDEV_SET_ERROR(pDevIns, rc,
1474	N_("Configuration error: Querying \"BiosRom\" as a string failed"));
1475	else if (!*pThis->pszPcBiosFile)
1476	{
1477	PDMDevHlpMMHeapFree(pDevIns, pThis->pszPcBiosFile);
1478	pThis->pszPcBiosFile = NULL;
1479	}
1480
1481	/*
1482	* Get the CPU arch so we can load the appropriate ROMs.
1483	*/
1484	PVM pVM = PDMDevHlpGetVM(pDevIns);
1485	CPUMMICROARCH const enmMicroarch = pVM ? CPUMGetGuestMicroarch(pVM) : kCpumMicroarch_Intel_P6;
1486
1487	if (pThis->pszPcBiosFile)
1488	{
1489	/*
1490	* Load the BIOS ROM.
1491	*/
1492	RTFILE hFilePcBios;
1493	rc = RTFileOpen(&hFilePcBios, pThis->pszPcBiosFile,
1494	RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1495	if (RT_SUCCESS(rc))
1496	{
1497	/* Figure the size and check restrictions. */
1498	uint64_t cbPcBios;
1499	rc = RTFileQuerySize(hFilePcBios, &cbPcBios);
1500	if (RT_SUCCESS(rc))
1501	{
1502	pThis->cbPcBios = (uint32_t)cbPcBios;
1503	if ( RT_ALIGN(pThis->cbPcBios, _64K) == pThis->cbPcBios
1504	&& pThis->cbPcBios == cbPcBios
1505	&& pThis->cbPcBios <= 32 * _64K
1506	&& pThis->cbPcBios >= _64K)
1507	{
1508	pThis->pu8PcBios = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, pThis->cbPcBios);
1509	if (pThis->pu8PcBios)
1510	{
1511	rc = RTFileRead(hFilePcBios, pThis->pu8PcBios, pThis->cbPcBios, NULL);
1512	if (RT_FAILURE(rc))
1513	rc = PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
1514	N_("Error reading the BIOS image ('%s)"), pThis->pszPcBiosFile);
1515	}
1516	else
1517	rc = PDMDevHlpVMSetError(pDevIns, VERR_NO_MEMORY, RT_SRC_POS,
1518	N_("Failed to allocate %#x bytes for loading the BIOS image"),
1519	pThis->cbPcBios);
1520	}
1521	else
1522	rc = PDMDevHlpVMSetError(pDevIns, VERR_OUT_OF_RANGE, RT_SRC_POS,
1523	N_("Invalid system BIOS file size ('%s'): %#llx (%llu)"),
1524	pThis->pszPcBiosFile, cbPcBios, cbPcBios);
1525	}
1526	else
1527	rc = PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
1528	N_("Failed to query the system BIOS file size ('%s')"),
1529	pThis->pszPcBiosFile);
1530	RTFileClose(hFilePcBios);
1531	}
1532	else
1533	rc = PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
1534	N_("Failed to open system BIOS file '%s'"), pThis->pszPcBiosFile);
1535	if (RT_FAILURE(rc))
1536	return rc;
1537
1538	LogRel(("PcBios: Using BIOS ROM '%s' with a size of %#x bytes\n", pThis->pszPcBiosFile, pThis->cbPcBios));
1539	}
1540	else
1541	{
1542	/*
1543	* Use one of the embedded BIOS ROM images.
1544	*/
1545	uint8_t const *pbBios;
1546	uint32_t cbBios;
1547	if ( enmMicroarch == kCpumMicroarch_Intel_8086
1548	\|\| enmMicroarch == kCpumMicroarch_Intel_80186
1549	\|\| enmMicroarch == kCpumMicroarch_NEC_V20
1550	\|\| enmMicroarch == kCpumMicroarch_NEC_V30)
1551	{
1552	pbBios = g_abPcBiosBinary8086;
1553	cbBios = g_cbPcBiosBinary8086;
1554	LogRel(("PcBios: Using the 8086 BIOS image!\n"));
1555	}
1556	else if (enmMicroarch == kCpumMicroarch_Intel_80286)
1557	{
1558	pbBios = g_abPcBiosBinary286;
1559	cbBios = g_cbPcBiosBinary286;
1560	LogRel(("PcBios: Using the 286 BIOS image!\n"));
1561	}
1562	else
1563	{
1564	pbBios = g_abPcBiosBinary386;
1565	cbBios = g_cbPcBiosBinary386;
1566	LogRel(("PcBios: Using the 386+ BIOS image.\n"));
1567	}
1568	pThis->pu8PcBios = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, cbBios);
1569	if (pThis->pu8PcBios)
1570	{
1571	pThis->cbPcBios = cbBios;
1572	memcpy(pThis->pu8PcBios, pbBios, cbBios);
1573	}
1574	else
1575	return PDMDevHlpVMSetError(pDevIns, VERR_NO_MEMORY, RT_SRC_POS,
1576	N_("Failed to allocate %#x bytes for loading the embedded BIOS image"), cbBios);
1577	}
1578	const uint8_t *pu8PcBiosBinary = pThis->pu8PcBios;
1579	uint32_t cbPcBiosBinary = pThis->cbPcBios;
1580
1581	/*
1582	* Query the machine's UUID for SMBIOS/DMI use.
1583	*/
1584	RTUUID uuid;
1585	rc = pHlp->pfnCFGMQueryBytes(pCfg, "UUID", &uuid, sizeof(uuid));
1586	if (RT_FAILURE(rc))
1587	return PDMDEV_SET_ERROR(pDevIns, rc,
1588	N_("Configuration error: Querying \"UUID\" failed"));
1589
1590	bool fUuidLe;
1591	rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "UuidLe", &fUuidLe, false);
1592	if (RT_FAILURE(rc))
1593	return PDMDEV_SET_ERROR(pDevIns, rc,
1594	N_("Configuration error: Querying \"UuidLe\" failed"));
1595
1596	if (!fUuidLe)
1597	{
1598	/*
1599	* UUIDs are stored little endian actually (see chapter 7.2.1 System — UUID
1600	* of the DMI/SMBIOS spec) but to not force reactivation of existing guests we have
1601	* to carry this bug along... (see also DevEFI.cpp when changing this)
1602	*
1603	* Convert the UUID to network byte order. Not entirely straightforward as
1604	* parts are MSB already...
1605	*/
1606	uuid.Gen.u32TimeLow = RT_H2BE_U32(uuid.Gen.u32TimeLow);
1607	uuid.Gen.u16TimeMid = RT_H2BE_U16(uuid.Gen.u16TimeMid);
1608	uuid.Gen.u16TimeHiAndVersion = RT_H2BE_U16(uuid.Gen.u16TimeHiAndVersion);
1609	}
1610
1611	uint16_t cbDmiTables = 0;
1612	uint16_t cDmiTables = 0;
1613	rc = FwCommonPlantDMITable(pDevIns, pThis->au8DMIPage, VBOX_DMI_TABLE_SIZE,
1614	&uuid, pCfg, pThis->cCpus, &cbDmiTables, &cDmiTables);
1615	if (RT_FAILURE(rc))
1616	return rc;
1617
1618	/* Look for _SM_/_DMI_ anchor strings within the BIOS and replace the table headers. */
1619	unsigned offAnchor = ~0U;
1620	unsigned const cbToSearch = pThis->cbPcBios - 32;
1621	for (unsigned off = 0; off <= cbToSearch; off += 16)
1622	{
1623	if ( pThis->pu8PcBios[off + 0x00] != '_'
1624	\|\| pThis->pu8PcBios[off + 0x01] != 'S'
1625	\|\| pThis->pu8PcBios[off + 0x02] != 'M'
1626	\|\| pThis->pu8PcBios[off + 0x03] != '_'
1627	\|\| pThis->pu8PcBios[off + 0x10] != '_'
1628	\|\| pThis->pu8PcBios[off + 0x11] != 'D'
1629	\|\| pThis->pu8PcBios[off + 0x12] != 'M'
1630	\|\| pThis->pu8PcBios[off + 0x13] != 'I'
1631	\|\| pThis->pu8PcBios[off + 0x14] != '_')
1632	{ /* likely */ }
1633	else
1634	{
1635	offAnchor = off;
1636	FwCommonPlantSmbiosAndDmiHdrs(pDevIns, pThis->pu8PcBios + off, cbDmiTables, cDmiTables);
1637	break;
1638	}
1639	}
1640	AssertLogRel(offAnchor <= cbToSearch);
1641
1642	if (pThis->u8IOAPIC)
1643	{
1644	pThis->u32MPTableAddr = VBOX_DMI_TABLE_BASE + VBOX_DMI_TABLE_SIZE;
1645	FwCommonPlantMpsTable(pDevIns, pThis->au8DMIPage /* aka VBOX_DMI_TABLE_BASE */ + VBOX_DMI_TABLE_SIZE,
1646	_4K - VBOX_DMI_TABLE_SIZE, pThis->cCpus);
1647	LogRel(("PcBios: MPS table at %08x\n", pThis->u32MPTableAddr));
1648	}
1649
1650	rc = PDMDevHlpROMRegister(pDevIns, VBOX_DMI_TABLE_BASE, _4K, pThis->au8DMIPage, _4K,
1651	PGMPHYS_ROM_FLAGS_PERMANENT_BINARY, "DMI tables");
1652	if (RT_FAILURE(rc))
1653	return rc;
1654
1655	/*
1656	* Map the BIOS into memory.
1657	* There are two mappings:
1658	* 1. 0x000e0000 to 0x000fffff contains the last 128 kb of the bios.
1659	* The bios code might be 64 kb in size, and will then start at 0xf0000.
1660	* 2. 0xfffxxxxx to 0xffffffff contains the entire bios.
1661	*/
1662	AssertReleaseMsg(cbPcBiosBinary >= _64K, ("cbPcBiosBinary=%#x\n", cbPcBiosBinary));
1663	AssertReleaseMsg(RT_ALIGN_Z(cbPcBiosBinary, _64K) == cbPcBiosBinary,
1664	("cbPcBiosBinary=%#x\n", cbPcBiosBinary));
1665	cb = RT_MIN(cbPcBiosBinary, 128 * _1K); /* Effectively either 64 or 128K. */
1666	rc = PDMDevHlpROMRegister(pDevIns, 0x00100000 - cb, cb, &pu8PcBiosBinary[cbPcBiosBinary - cb], cb,
1667	PGMPHYS_ROM_FLAGS_PERMANENT_BINARY, "PC BIOS - 0xfffff");
1668	if (RT_FAILURE(rc))
1669	return rc;
1670	rc = PDMDevHlpROMRegister(pDevIns, (uint32_t)-(int32_t)cbPcBiosBinary, cbPcBiosBinary, pu8PcBiosBinary, cbPcBiosBinary,
1671	PGMPHYS_ROM_FLAGS_PERMANENT_BINARY, "PC BIOS - 0xffffffff");
1672	if (RT_FAILURE(rc))
1673	return rc;
1674
1675	/*
1676	* Get the LAN boot ROM file name.
1677	*/
1678	rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "LanBootRom", &pThis->pszLanBootFile);
1679	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1680	{
1681	pThis->pszLanBootFile = NULL;
1682	rc = VINF_SUCCESS;
1683	}
1684	else if (RT_FAILURE(rc))
1685	return PDMDEV_SET_ERROR(pDevIns, rc,
1686	N_("Configuration error: Querying \"LanBootRom\" as a string failed"));
1687	else if (!*pThis->pszLanBootFile)
1688	{
1689	PDMDevHlpMMHeapFree(pDevIns, pThis->pszLanBootFile);
1690	pThis->pszLanBootFile = NULL;
1691	}
1692
1693	/*
1694	* Not loading LAN ROM for old CPUs.
1695	*/
1696	if ( enmMicroarch != kCpumMicroarch_Intel_8086
1697	&& enmMicroarch != kCpumMicroarch_Intel_80186
1698	&& enmMicroarch != kCpumMicroarch_NEC_V20
1699	&& enmMicroarch != kCpumMicroarch_NEC_V30
1700	&& enmMicroarch != kCpumMicroarch_Intel_80286)
1701	{
1702	const uint8_t *pu8LanBootBinary = NULL;
1703	uint64_t cbLanBootBinary;
1704	uint64_t cbFileLanBoot = 0;
1705
1706	/*
1707	* Open the LAN boot ROM and figure it size.
1708	* Determine the LAN boot ROM size, open specified ROM file in the process.
1709	*/
1710	if (pThis->pszLanBootFile)
1711	{
1712	RTFILE hFileLanBoot = NIL_RTFILE;
1713	rc = RTFileOpen(&hFileLanBoot, pThis->pszLanBootFile,
1714	RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1715	if (RT_SUCCESS(rc))
1716	{
1717	rc = RTFileQuerySize(hFileLanBoot, &cbFileLanBoot);
1718	if (RT_SUCCESS(rc))
1719	{
1720	if (cbFileLanBoot <= _64K - (VBOX_LANBOOT_SEG << 4 & 0xffff))
1721	{
1722	LogRel(("PcBios: Using LAN ROM '%s' with a size of %#x bytes\n", pThis->pszLanBootFile, cbFileLanBoot));
1723
1724	/*
1725	* Allocate buffer for the LAN boot ROM data and load it.
1726	*/
1727	pThis->pu8LanBoot = (uint8_t *)PDMDevHlpMMHeapAllocZ(pDevIns, cbFileLanBoot);
1728	if (pThis->pu8LanBoot)
1729	{
1730	rc = RTFileRead(hFileLanBoot, pThis->pu8LanBoot, cbFileLanBoot, NULL);
1731	AssertLogRelRCReturnStmt(rc, RTFileClose(hFileLanBoot), rc);
1732	}
1733	else
1734	rc = VERR_NO_MEMORY;
1735	}
1736	else
1737	rc = VERR_TOO_MUCH_DATA;
1738	}
1739	RTFileClose(hFileLanBoot);
1740	}
1741	if (RT_FAILURE(rc))
1742	{
1743	/*
1744	* Play stupid and ignore failures, falling back to the built-in LAN boot ROM.
1745	*/
1746	/** @todo r=bird: This should have some kind of rational. We don't usually
1747	* ignore the VM configuration. */
1748	LogRel(("PcBios: Failed to open LAN boot ROM file '%s', rc=%Rrc!\n", pThis->pszLanBootFile, rc));
1749	PDMDevHlpMMHeapFree(pDevIns, pThis->pszLanBootFile);
1750	pThis->pszLanBootFile = NULL;
1751	}
1752	}
1753
1754	/* If we were unable to get the data from file for whatever reason, fall
1755	* back to the built-in LAN boot ROM image.
1756	*/
1757	if (pThis->pu8LanBoot == NULL)
1758	{
1759	#ifdef VBOX_WITH_PXE_ROM
1760	pu8LanBootBinary = g_abNetBiosBinary;
1761	cbLanBootBinary = g_cbNetBiosBinary;
1762	#endif
1763	}
1764	else
1765	{
1766	pu8LanBootBinary = pThis->pu8LanBoot;
1767	cbLanBootBinary = cbFileLanBoot;
1768	}
1769
1770	/*
1771	* Map the Network Boot ROM into memory.
1772	*
1773	* Currently there is a fixed mapping: 0x000e2000 to 0x000effff contains
1774	* the (up to) 56 kb ROM image. The mapping size is fixed to trouble with
1775	* the saved state (in PGM).
1776	*/
1777	if (pu8LanBootBinary)
1778	{
1779	pThis->cbLanBoot = cbLanBootBinary;
1780
1781	rc = PDMDevHlpROMRegister(pDevIns, VBOX_LANBOOT_SEG << 4,
1782	RT_MAX(cbLanBootBinary, _64K - (VBOX_LANBOOT_SEG << 4 & 0xffff)),
1783	pu8LanBootBinary, cbLanBootBinary,
1784	PGMPHYS_ROM_FLAGS_SHADOWED, "Net Boot ROM");
1785	AssertRCReturn(rc, rc);
1786	}
1787	}
1788	else if (pThis->pszLanBootFile)
1789	LogRel(("PcBios: Skipping LAN ROM '%s' due to ancient target CPU.\n", pThis->pszLanBootFile));
1790	#ifdef VBOX_WITH_PXE_ROM
1791	else
1792	LogRel(("PcBios: Skipping built in ROM due to ancient target CPU.\n"));
1793	#endif
1794
1795	/*
1796	* Configure Boot delay.
1797	*/
1798	rc = pHlp->pfnCFGMQueryU8Def(pCfg, "DelayBoot", &pThis->uBootDelay, 0);
1799	if (RT_FAILURE(rc))
1800	return PDMDEV_SET_ERROR(pDevIns, rc,
1801	N_("Configuration error: Querying \"DelayBoot\" as integer failed"));
1802	if (pThis->uBootDelay > 15)
1803	pThis->uBootDelay = 15;
1804
1805
1806	/*
1807	* Read shutdown status code config and register ourselves as the firmware device.
1808	*/
1809
1810	/** @cfgm{CheckShutdownStatusForSoftReset, boolean, true}
1811	* Whether to consult the shutdown status code (CMOS register 0Fh) to
1812	* determine whether the guest intended a soft or hard reset. Currently only
1813	* shutdown status codes 05h, 09h and 0Ah are considered soft reset. */
1814	rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "CheckShutdownStatusForSoftReset", &pThis->fCheckShutdownStatusForSoftReset, true);
1815	AssertLogRelRCReturn(rc, rc);
1816
1817	/** @cfgm{ClearShutdownStatusOnHardReset, boolean, true}
1818	* Whether to clear the shutdown status code (CMOS register 0Fh) on hard reset. */
1819	rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "ClearShutdownStatusOnHardReset", &pThis->fClearShutdownStatusOnHardReset, true);
1820	AssertLogRelRCReturn(rc, rc);
1821
1822	LogRel(("PcBios: fCheckShutdownStatusForSoftReset=%RTbool fClearShutdownStatusOnHardReset=%RTbool\n",
1823	pThis->fCheckShutdownStatusForSoftReset, pThis->fClearShutdownStatusOnHardReset));
1824
1825	static PDMFWREG const s_FwReg = { PDM_FWREG_VERSION, pcbiosFw_IsHardReset, PDM_FWREG_VERSION };
1826	rc = PDMDevHlpFirmwareRegister(pDevIns, &s_FwReg, &pThis->pFwHlpR3);
1827	AssertLogRelRCReturn(rc, rc);
1828
1829	return VINF_SUCCESS;
1830	}
1831
1832
1833	/**
1834	* The device registration structure.
1835	*/
1836	const PDMDEVREG g_DevicePcBios =
1837	{
1838	/* .u32Version = */ PDM_DEVREG_VERSION,
1839	/* .uReserved0 = */ 0,
1840	/* .szName = */ "pcbios",
1841	/* .fFlags = */ PDM_DEVREG_FLAGS_DEFAULT_BITS \| PDM_DEVREG_FLAGS_NEW_STYLE,
1842	/* .fClass = */ PDM_DEVREG_CLASS_ARCH_BIOS,
1843	/* .cMaxInstances = */ 1,
1844	/* .uSharedVersion = */ 42,
1845	/* .cbInstanceShared = */ sizeof(DEVPCBIOS),
1846	/* .cbInstanceCC = */ 0,
1847	/* .cbInstanceRC = */ 0,
1848	/* .cMaxPciDevices = */ 0,
1849	/* .cMaxMsixVectors = */ 0,
1850	/* .pszDescription = */ "PC BIOS Device",
1851	#if defined(IN_RING3)
1852	/* .pszRCMod = */ "",
1853	/* .pszR0Mod = */ "",
1854	/* .pfnConstruct = */ pcbiosConstruct,
1855	/* .pfnDestruct = */ pcbiosDestruct,
1856	/* .pfnRelocate = */ NULL,
1857	/* .pfnMemSetup = */ pcbiosMemSetup,
1858	/* .pfnPowerOn = */ NULL,
1859	/* .pfnReset = */ pcbiosReset,
1860	/* .pfnSuspend = */ NULL,
1861	/* .pfnResume = */ NULL,
1862	/* .pfnAttach = */ NULL,
1863	/* .pfnDetach = */ NULL,
1864	/* .pfnQueryInterface = */ NULL,
1865	/* .pfnInitComplete = */ pcbiosInitComplete,
1866	/* .pfnPowerOff = */ NULL,
1867	/* .pfnSoftReset = */ NULL,
1868	/* .pfnReserved0 = */ NULL,
1869	/* .pfnReserved1 = */ NULL,
1870	/* .pfnReserved2 = */ NULL,
1871	/* .pfnReserved3 = */ NULL,
1872	/* .pfnReserved4 = */ NULL,
1873	/* .pfnReserved5 = */ NULL,
1874	/* .pfnReserved6 = */ NULL,
1875	/* .pfnReserved7 = */ NULL,
1876	#elif defined(IN_RING0)
1877	/* .pfnEarlyConstruct = */ NULL,
1878	/* .pfnConstruct = */ NULL,
1879	/* .pfnDestruct = */ NULL,
1880	/* .pfnFinalDestruct = */ NULL,
1881	/* .pfnRequest = */ NULL,
1882	/* .pfnReserved0 = */ NULL,
1883	/* .pfnReserved1 = */ NULL,
1884	/* .pfnReserved2 = */ NULL,
1885	/* .pfnReserved3 = */ NULL,
1886	/* .pfnReserved4 = */ NULL,
1887	/* .pfnReserved5 = */ NULL,
1888	/* .pfnReserved6 = */ NULL,
1889	/* .pfnReserved7 = */ NULL,
1890	#elif defined(IN_RC)
1891	/* .pfnConstruct = */ NULL,
1892	/* .pfnReserved0 = */ NULL,
1893	/* .pfnReserved1 = */ NULL,
1894	/* .pfnReserved2 = */ NULL,
1895	/* .pfnReserved3 = */ NULL,
1896	/* .pfnReserved4 = */ NULL,
1897	/* .pfnReserved5 = */ NULL,
1898	/* .pfnReserved6 = */ NULL,
1899	/* .pfnReserved7 = */ NULL,
1900	#else
1901	# error "Not in IN_RING3, IN_RING0 or IN_RC!"
1902	#endif
1903	/* .u32VersionEnd = */ PDM_DEVREG_VERSION
1904	};
1905

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

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

Download in other formats: