DevPcBios.cpp@ 2569

Last change on this file since 2569 was 2543, checked in by vboxsync, 18 years ago
Fixed boch shutdown (write 'Shutdown' to 9800h).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 42.6 KB

Line
1	/** @file
2	*
3	* VBox basic PC devices:
4	* PC BIOS device
5	*/
6
7	/*
8	* Copyright (C) 2006 InnoTek Systemberatung GmbH
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License as published by the Free Software Foundation,
14	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
15	* distribution. VirtualBox OSE is distributed in the hope that it will
16	* be useful, but WITHOUT ANY WARRANTY of any kind.
17	*
18	* If you received this file as part of a commercial VirtualBox
19	* distribution, then only the terms of your commercial VirtualBox
20	* license agreement apply instead of the previous paragraph.
21	*/
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_DEV_PC_BIOS
27	#include <VBox/pdm.h>
28	#include <VBox/mm.h>
29
30	#include <VBox/log.h>
31	#include <iprt/assert.h>
32	#include <iprt/alloc.h>
33	#include <iprt/file.h>
34	#include <iprt/string.h>
35	#include <VBox/err.h>
36
37	#include "vl_vbox.h"
38	#include "Builtins.h"
39	#include "Builtins2.h"
40	#include "DevPcBios.h"
41
42
43	/*******************************************************************************
44	* Structures and Typedefs *
45	*******************************************************************************/
46
47	/**
48	* The boot device.
49	*/
50	typedef enum DEVPCBIOSBOOT
51	{
52	DEVPCBIOSBOOT_NONE,
53	DEVPCBIOSBOOT_FLOPPY,
54	DEVPCBIOSBOOT_HD,
55	DEVPCBIOSBOOT_DVD,
56	DEVPCBIOSBOOT_LAN
57	} DEVPCBIOSBOOT;
58
59	/**
60	* PC Bios instance data structure.
61	*/
62	typedef struct DEVPCBIOS
63	{
64	/** Pointer back to the device instance. */
65	PPDMDEVINS pDevIns;
66
67	/** Boot devices (ordered). */
68	DEVPCBIOSBOOT aenmBootDevice[4];
69	/** Ram Size (in bytes). */
70	uint64_t cbRam;
71	/** Bochs shutdown index. */
72	uint32_t iShutdown;
73	/** Floppy device. */
74	char *pszFDDevice;
75	/** Harddisk device. */
76	char *pszHDDevice;
77	/** Bios message buffer. */
78	char szMsg[256];
79	/** Bios message buffer index. */
80	uint32_t iMsg;
81	/** Current logo data memory bank. */
82	uint8_t u8LogoBank;
83	/** The size of the BIOS logo data. */
84	uint32_t cbLogo;
85	/** The BIOS logo data. */
86	uint8_t *pu8Logo;
87	/** The name of the logo file. */
88	char *pszLogoFile;
89	/** The LAN boot ROM data. */
90	uint8_t *pu8LanBoot;
91	/** The name of the LAN boot ROM file. */
92	char *pszLanBootFile;
93	/** The DMI tables. */
94	uint8_t au8DMIPage[0x1000];
95	/** The boot countdown (in seconds). */
96	uint8_t uBootDelay;
97	} DEVPCBIOS, *PDEVPCBIOS;
98
99
100	/** @todo The logo stuff shared with the BIOS goes into a header of course. */
101
102	/**
103	* PC Bios logo data structure.
104	*/
105	#pragma pack(2) /* pack(2) is important! (seems that bios compiled with pack(2)...) */
106	typedef struct LOGOHDR
107	{
108	/** Signature (0x66BB). */
109	uint16_t u16Signature;
110	/** Fade in - boolean. */
111	uint8_t u8FadeIn;
112	/** Fade out - boolean. */
113	uint8_t u8FadeOut;
114	/** Logo time (msec). */
115	uint16_t u16LogoMillies;
116	/** Show setup - boolean. */
117	uint8_t u8ShowBootMenu;
118	/** Logo file size. */
119	uint32_t cbLogo;
120	} LOGOHDR, *PLOGOHDR;
121	#pragma pack()
122
123	/** The value of the LOGOHDR::u16Signature field. */
124	#define LOGOHDR_MAGIC 0x66BB
125
126	/** Size of a logo bank. */
127	#define LOGO_BANK_SIZE 0xffff
128	/** Logo offset mask. */
129	#define LOGO_BANK_OFFSET 0xffff
130	/** The last bank for custom logo data. */
131	#define LOGO_BANK_LAST 254
132	/** The bank which will give you the default logo. */
133	#define LOGO_BANK_DEFAULT_LOGO 255
134
135	#pragma pack(1)
136
137	typedef struct DMIHDR
138	{
139	uint8_t u8Type;
140	uint8_t u8Length;
141	uint16_t u16Handle;
142	} *PDMIHDR;
143
144	typedef struct DMIBIOSINF
145	{
146	DMIHDR header;
147	uint8_t u8Vendor;
148	uint8_t u8Version;
149	uint16_t u16Start;
150	uint8_t u8Release;
151	uint8_t u8ROMSize;
152	uint64_t u64Characteristics;
153	uint8_t u8CharacteristicsByte1;
154	uint8_t u8CharacteristicsByte2;
155	} *PDMIBIOSINF;
156
157	typedef struct DMISYSTEMINF
158	{
159	DMIHDR header;
160	uint8_t u8Manufacturer;
161	uint8_t u8ProductName;
162	uint8_t u8Version;
163	uint8_t u8SerialNumber;
164	uint8_t au8Uuid[16];
165	uint8_t u8WakeupType;
166	uint8_t u8SKUNumber;
167	uint8_t u8Family;
168	} *PDMISYSTEMINF;
169
170	#pragma pack()
171
172
173	/*******************************************************************************
174	* Internal Functions *
175	*******************************************************************************/
176	__BEGIN_DECLS
177
178	static DECLCALLBACK(int) logoMMIORead(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb);
179	static DECLCALLBACK(int) logoMMIOWrite(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb);
180
181	__END_DECLS
182
183
184	/**
185	* Write to CMOS memory.
186	* This is used by the init complete code.
187	*/
188	static void pcbiosCmosWrite(PPDMDEVINS pDevIns, int off, uint32_t u32Val)
189	{
190	Assert(off < 128);
191	Assert(u32Val < 256);
192
193	#if 1
194	int rc = PDMDevHlpCMOSWrite(pDevIns, off, u32Val);
195	AssertRC(rc);
196	#else
197	PVM pVM = PDMDevHlpGetVM(pDevIns);
198	IOMIOPortWrite(pVM, 0x70, off, 1);
199	IOMIOPortWrite(pVM, 0x71, u32Val, 1);
200	IOMIOPortWrite(pVM, 0x70, 0, 1);
201	#endif
202	}
203
204	/* -=-=-=-=-=-=- based on code from pc.c -=-=-=-=-=-=- */
205
206	/**
207	* Initializes the CMOS data for one harddisk.
208	*/
209	static void pcbiosCmosInitHardDisk(PPDMDEVINS pDevIns, int offType, int offInfo, PPDMIBLOCKBIOS pBlockBios)
210	{
211	if ( pBlockBios->pfnGetType(pBlockBios) == PDMBLOCKTYPE_HARD_DISK
212	&& pBlockBios->pfnIsVisible(pBlockBios))
213	{
214	uint32_t cCylinders;
215	uint32_t cHeads;
216	uint32_t cSectors;
217	int rc = pBlockBios->pfnGetGeometry(pBlockBios, &cCylinders, &cHeads, &cSectors);
218	if (VBOX_SUCCESS(rc))
219	{
220	Log2(("pcbiosCmosInitHardDisk: offInfo=%#x: CHS=%d/%d/%d\n", offInfo, cCylinders, cHeads, cSectors));
221	pcbiosCmosWrite(pDevIns, offType, 47); /* 19h - First Extended Hard Disk Drive Type */
222	pcbiosCmosWrite(pDevIns, offInfo + 0, RT_MIN(cCylinders, 16383) & 0xff); /* 1Bh - (AMI) First Hard Disk (type 47) user defined: # of Cylinders, LSB */
223	pcbiosCmosWrite(pDevIns, offInfo + 1, RT_MIN(cCylinders, 16383) >> 8); /* 1Ch - (AMI) First Hard Disk user defined: # of Cylinders, High Byte */
224	pcbiosCmosWrite(pDevIns, offInfo + 2, cHeads); /* 1Dh - (AMI) First Hard Disk user defined: Number of Heads */
225	pcbiosCmosWrite(pDevIns, offInfo + 3, 0xff); /* 1Eh - (AMI) First Hard Disk user defined: Write Precompensation Cylinder, Low Byte */
226	pcbiosCmosWrite(pDevIns, offInfo + 4, 0xff); /* 1Fh - (AMI) First Hard Disk user defined: Write Precompensation Cylinder, High Byte */
227	pcbiosCmosWrite(pDevIns, offInfo + 5, 0xc0 \| ((cHeads > 8) << 3)); /* 20h - (AMI) First Hard Disk user defined: Control Byte */
228	pcbiosCmosWrite(pDevIns, offInfo + 6, 0xff); /* 21h - (AMI) First Hard Disk user defined: Landing Zone, Low Byte */
229	pcbiosCmosWrite(pDevIns, offInfo + 7, 0xff); /* 22h - (AMI) First Hard Disk user defined: Landing Zone, High Byte */
230	pcbiosCmosWrite(pDevIns, offInfo + 8, cSectors); /* 23h - (AMI) First Hard Disk user defined: # of Sectors per track */
231	return;
232	}
233	}
234	pcbiosCmosWrite(pDevIns, offType, 0);
235	}
236
237
238	/**
239	* Get BIOS boot code from enmBootDevice in order
240	*
241	* @todo r=bird: This is a rather silly function since the conversion is 1:1.
242	*/
243	static uint8_t getBiosBootCode(PDEVPCBIOS pData, unsigned iOrder)
244	{
245	switch (pData->aenmBootDevice[iOrder])
246	{
247	case DEVPCBIOSBOOT_NONE:
248	return 0;
249	case DEVPCBIOSBOOT_FLOPPY:
250	return 1;
251	case DEVPCBIOSBOOT_HD:
252	return 2;
253	case DEVPCBIOSBOOT_DVD:
254	return 3;
255	case DEVPCBIOSBOOT_LAN:
256	return 4;
257	default:
258	AssertMsgFailed(("aenmBootDevice[%d]=%d\n", iOrder, pData->aenmBootDevice[iOrder]));
259	return 0;
260	}
261	}
262
263
264	/**
265	* Init complete notification.
266	* This routine will write information needed by the bios to the CMOS.
267	*
268	* @returns VBOX status code.
269	* @param pDevIns The device instance.
270	* @see http://www.brl.ntt.co.jp/people/takehiko/interrupt/CMOS.LST.txt for
271	* a description of standard and non-standard CMOS registers.
272	*/
273	static DECLCALLBACK(int) pcbiosInitComplete(PPDMDEVINS pDevIns)
274	{
275	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
276	uint32_t u32;
277	unsigned i;
278	PVM pVM = PDMDevHlpGetVM(pDevIns);
279	PPDMIBLOCKBIOS apHDs[4] = {0};
280	PPDMIBLOCKBIOS apFDs[2] = {0};
281	AssertRelease(pVM);
282	LogFlow(("pcbiosInitComplete:\n"));
283
284	/*
285	* Memory sizes.
286	*/
287	/* base memory. */
288	u32 = pData->cbRam > 640 ? 640 : (uint32_t)pData->cbRam / _1K;
289	pcbiosCmosWrite(pDevIns, 0x15, u32 & 0xff); /* 15h - Base Memory in K, Low Byte */
290	pcbiosCmosWrite(pDevIns, 0x16, u32 >> 8); /* 16h - Base Memory in K, High Byte */
291
292	/* Extended memory, up to 65MB */
293	u32 = pData->cbRam >= 65 * _1M ? 0xffff : ((uint32_t)pData->cbRam - _1M) / _1K;
294	pcbiosCmosWrite(pDevIns, 0x17, u32 & 0xff); /* 17h - Extended Memory in K, Low Byte */
295	pcbiosCmosWrite(pDevIns, 0x18, u32 >> 8); /* 18h - Extended Memory in K, High Byte */
296	pcbiosCmosWrite(pDevIns, 0x30, u32 & 0xff); /* 30h - Extended Memory in K, Low Byte */
297	pcbiosCmosWrite(pDevIns, 0x31, u32 >> 8); /* 31h - Extended Memory in K, High Byte */
298
299	/* Bochs BIOS specific? Anyway, it's the amount of memory above 16MB */
300	if (pData->cbRam > 16 * _1M)
301	{
302	u32 = (uint32_t)( (pData->cbRam - 16 * _1M) / _64K );
303	u32 = RT_MIN(u32, 0xffff);
304	}
305	else
306	u32 = 0;
307	pcbiosCmosWrite(pDevIns, 0x34, u32 & 0xff);
308	pcbiosCmosWrite(pDevIns, 0x35, u32 >> 8);
309
310	/*
311	* Bochs BIOS specifics - boot device.
312	* We do both new and old (ami-style) settings.
313	* See rombios.c line ~7215 (int19_function).
314	*/
315
316	uint8_t reg3d = getBiosBootCode(pData, 0) \| (getBiosBootCode(pData, 1) << 4);
317	uint8_t reg38 = /* pcbiosCmosRead(pDevIns, 0x38) \| */ getBiosBootCode(pData, 2) << 4;
318	/* This is an extension. Bochs BIOS normally supports only 3 boot devices. */
319	uint8_t reg3c = getBiosBootCode(pData, 3) \| (pData->uBootDelay << 4);
320	pcbiosCmosWrite(pDevIns, 0x3d, reg3d);
321	pcbiosCmosWrite(pDevIns, 0x38, reg38);
322	pcbiosCmosWrite(pDevIns, 0x3c, reg3c);
323
324	/*
325	* Floppy drive type.
326	*/
327	for (i = 0; i < ELEMENTS(apFDs); i++)
328	{
329	PPDMIBASE pBase;
330	int rc = PDMR3QueryLun(pVM, pData->pszFDDevice, 0, i, &pBase);
331	if (VBOX_SUCCESS(rc))
332	apFDs[i] = (PPDMIBLOCKBIOS)pBase->pfnQueryInterface(pBase, PDMINTERFACE_BLOCK_BIOS);
333	}
334	u32 = 0;
335	if (apFDs[0])
336	switch (apFDs[0]->pfnGetType(apFDs[0]))
337	{
338	case PDMBLOCKTYPE_FLOPPY_360: u32 \|= 1 << 4; break;
339	case PDMBLOCKTYPE_FLOPPY_1_20: u32 \|= 2 << 4; break;
340	case PDMBLOCKTYPE_FLOPPY_720: u32 \|= 3 << 4; break;
341	case PDMBLOCKTYPE_FLOPPY_1_44: u32 \|= 4 << 4; break;
342	case PDMBLOCKTYPE_FLOPPY_2_88: u32 \|= 5 << 4; break;
343	default: AssertFailed(); break;
344	}
345	if (apFDs[1])
346	switch (apFDs[1]->pfnGetType(apFDs[1]))
347	{
348	case PDMBLOCKTYPE_FLOPPY_360: u32 \|= 1; break;
349	case PDMBLOCKTYPE_FLOPPY_1_20: u32 \|= 2; break;
350	case PDMBLOCKTYPE_FLOPPY_720: u32 \|= 3; break;
351	case PDMBLOCKTYPE_FLOPPY_1_44: u32 \|= 4; break;
352	case PDMBLOCKTYPE_FLOPPY_2_88: u32 \|= 5; break;
353	default: AssertFailed(); break;
354	}
355	pcbiosCmosWrite(pDevIns, 0x10, u32); /* 10h - Floppy Drive Type */
356
357	/*
358	* Equipment byte.
359	*/
360	u32 = !!apFDs[0] + !!apFDs[1];
361	switch (u32)
362	{
363	case 1: u32 = 0x01; break; /* floppy installed, 1 drive. */
364	case 2: u32 = 0x41; break; /* floppy installed, 2 drives. */
365	default:u32 = 0; break; /* floppy not installed. */
366	}
367	u32 \|= BIT(1); /* math coprocessor installed */
368	u32 \|= BIT(2); /* keyboard enabled (or mouse?) */
369	u32 \|= BIT(3); /* display enabled (monitory type is 0, i.e. vga) */
370	pcbiosCmosWrite(pDevIns, 0x14, u32); /* 14h - Equipment Byte */
371
372	/*
373	* Harddisks.
374	*/
375	for (i = 0; i < ELEMENTS(apHDs); i++)
376	{
377	PPDMIBASE pBase;
378	int rc = PDMR3QueryLun(pVM, pData->pszHDDevice, 0, i, &pBase);
379	if (VBOX_SUCCESS(rc))
380	apHDs[i] = (PPDMIBLOCKBIOS)pBase->pfnQueryInterface(pBase, PDMINTERFACE_BLOCK_BIOS);
381	}
382
383	u32 = (apHDs[0] ? 0xf0 : 0) \| (apHDs[1] ? 0x0f : 0); /* 0Fh means extended and points to 1Ah, 1Bh */
384	pcbiosCmosWrite(pDevIns, 0x12, u32); /* 12h - Hard Disk Data (type) */
385	if (apHDs[0])
386	pcbiosCmosInitHardDisk(pDevIns, 0x19, 0x1b, apHDs[0]); /* 19h - First Extended Hard Disk Drive Type */
387	if (apHDs[1])
388	pcbiosCmosInitHardDisk(pDevIns, 0x1a, 0x24, apHDs[1]); /* 1Ah - Second Extended Hard Disk Drive Type */
389
390	/*
391	* Translation type - Bochs BIOS specific.
392	*/
393	u32 = 0;
394	for (i = 0; i < 4; i++)
395	{
396	if (apHDs[i])
397	{
398	PDMBIOSTRANSLATION enmTranslation;
399	int rc = apHDs[i]->pfnGetTranslation(apHDs[i], &enmTranslation);
400	if (VBOX_FAILURE(rc) \|\| enmTranslation == PDMBIOSTRANSLATION_AUTO)
401	{
402	uint32_t cCylinders, cHeads, cSectors;
403	rc = apHDs[i]->pfnGetGeometry(apHDs[i], &cCylinders, &cHeads, &cSectors);
404	if (VBOX_FAILURE(rc))
405	{
406	AssertMsg(rc == VERR_PDM_MEDIA_NOT_MOUNTED, ("This shouldn't happen! rc=%Vrc\n", rc));
407	enmTranslation = PDMBIOSTRANSLATION_NONE;
408	}
409	else if (cCylinders <= 1024 && cHeads <= 16 && cSectors <= 63)
410	{
411	/* Disk <= 512 MByte not needing LBA translation. */
412	enmTranslation = PDMBIOSTRANSLATION_NONE;
413	}
414	else if (cSectors != 63 \|\| (cHeads != 16 && cHeads != 32 && cHeads != 64 && cHeads != 128 && cHeads != 255))
415	{
416	/* Disk with strange geometry. Using LBA here can
417	* break booting of the guest OS. Especially operating
418	* systems from Microsoft are sensitive to BIOS CHS not
419	* matching what the partition table says. */
420	enmTranslation = PDMBIOSTRANSLATION_NONE;
421	}
422	else
423	enmTranslation = PDMBIOSTRANSLATION_LBA;
424	}
425	switch (enmTranslation)
426	{
427	case PDMBIOSTRANSLATION_AUTO: /* makes gcc happy */
428	case PDMBIOSTRANSLATION_NONE:
429	/* u32 \|= 0 << (i * 2) */
430	break;
431	default:
432	AssertMsgFailed(("bad enmTranslation=%d\n", enmTranslation));
433	case PDMBIOSTRANSLATION_LBA:
434	u32 \|= 1 << (i * 2);
435	break;
436	}
437	}
438	}
439	Log2(("pcbiosInitComplete: translation byte: %#02x\n", u32));
440	pcbiosCmosWrite(pDevIns, 0x39, u32);
441
442	LogFlow(("pcbiosInitComplete: returns VINF_SUCCESS\n"));
443	return VINF_SUCCESS;
444	}
445
446
447	/**
448	* Port I/O Handler for IN operations.
449	*
450	* @returns VBox status code.
451	*
452	* @param pDevIns The device instance.
453	* @param pvUser User argument - ignored.
454	* @param Port Port number used for the IN operation.
455	* @param pu32 Where to store the result.
456	* @param cb Number of bytes read.
457	*/
458	static DECLCALLBACK(int) pcbiosIOPortRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
459	{
460	NOREF(pDevIns);
461	NOREF(pvUser);
462	NOREF(Port);
463	NOREF(pu32);
464	NOREF(cb);
465	return VERR_IOM_IOPORT_UNUSED;
466	}
467
468
469	/**
470	* Port I/O Handler for OUT operations.
471	*
472	* @returns VBox status code.
473	*
474	* @param pDevIns The device instance.
475	* @param pvUser User argument - ignored.
476	* @param Port Port number used for the IN operation.
477	* @param u32 The value to output.
478	* @param cb The value size in bytes.
479	*/
480	static DECLCALLBACK(int) pcbiosIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
481	{
482	/*
483	* Bochs BIOS Panic
484	*/
485	if ( cb == 2
486	&& ( Port == 0x400
487	\|\| Port == 0x401))
488	{
489	Log(("pcbios: PC BIOS panic at rombios.c(%d)\n", u32));
490	AssertReleaseMsgFailed(("PC BIOS panic at rombios.c(%d)\n", u32));
491	return VERR_INTERNAL_ERROR;
492	}
493
494	/*
495	* Bochs BIOS char printing.
496	*/
497	if ( cb == 1
498	&& ( Port == 0x402
499	\|\| Port == 0x403))
500	{
501	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
502	/* The raw version. */
503	switch (u32)
504	{
505	case '\r': Log2(("pcbios: <return>\n")); break;
506	case '\n': Log2(("pcbios: <newline>\n")); break;
507	case '\t': Log2(("pcbios: <tab>\n")); break;
508	default: Log2(("pcbios: %c (%02x)\n", u32, u32)); break;
509	}
510
511	/* The readable, buffered version. */
512	if (u32 == '\n' \|\| u32 == '\r')
513	{
514	pData->szMsg[pData->iMsg] = '\0';
515	if (pData->iMsg)
516	Log(("pcbios: %s\n", pData->szMsg));
517	pData->iMsg = 0;
518	}
519	else
520	{
521	if (pData->iMsg >= sizeof(pData->szMsg))
522	{
523	pData->szMsg[pData->iMsg] = '\0';
524	Log(("pcbios: %s\n", pData->szMsg));
525	pData->iMsg = 0;
526	}
527	pData->szMsg[pData->iMsg] = (char )u32;
528	pData->szMsg[++pData->iMsg] = '\0';
529	}
530	return VINF_SUCCESS;
531	}
532
533	/*
534	* Bochs BIOS shutdown request.
535	*/
536	if (cb == 1 && Port == 0x8900)
537	{
538	static const unsigned char szShutdown[] = "Shutdown";
539	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
540	if (u32 == szShutdown[pData->iShutdown])
541	{
542	pData->iShutdown++;
543	if (pData->iShutdown == 8)
544	{
545	pData->iShutdown = 0;
546	LogRel(("8900h shutdown request.\n"));
547	return PDMDevHlpVMPowerOff(pDevIns);
548	}
549	}
550	else
551	pData->iShutdown = 0;
552	return VINF_SUCCESS;
553	}
554
555	/* not in use. */
556	return VINF_SUCCESS;
557	}
558
559
560	/**
561	* Legacy LOGO memory (0xd0000 - 0xdffff) read hook, to be called from IOM.
562	*
563	* @returns VBox status code.
564	* @param pDevIns Pointer device instance.
565	* @param pvUser User argument - ignored.
566	* @param GCPhysAddr Physical address of memory to read.
567	* @param pv Where to store readed data.
568	* @param cb Bytes to read.
569	*/
570	static DECLCALLBACK(int) logoMMIORead(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb)
571	{
572	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
573	Log(("logoMMIORead call GCPhysAddr:%x pv:%x cb:%d (%d)\n", GCPhysAddr, pv, cb, pData->u8LogoBank));
574
575	uint32_t offLogo = GCPhysAddr & LOGO_BANK_OFFSET;
576	if (pData->u8LogoBank != LOGO_BANK_DEFAULT_LOGO)
577	{
578	/*
579	* Banked logo.
580	*/
581	offLogo += pData->u8LogoBank * LOGO_BANK_SIZE;
582	if ( offLogo > pData->cbLogo
583	\|\| offLogo + cb > pData->cbLogo)
584	{
585	Log(("logoMMIORead: Requested address is out of Logo data!!! offLogo=%#x(%d) cbLogo=%#x(%d)\n",
586	offLogo, offLogo, pData->cbLogo, pData->cbLogo));
587	return VINF_SUCCESS;
588	}
589
590	memcpy(pv, &pData->pu8Logo[offLogo], cb);
591	Log(("logoMMIORead: offLogo=%#x(%d) cb=%#x %.*Vhxs\n", offLogo, offLogo, cb, cb, &pData->pu8Logo[offLogo]));
592	}
593	else
594	{
595	/*
596	* Default bios logo.
597	*/
598	if (offLogo > g_cbPcDefBiosLogo \|\| offLogo + cb > g_cbPcDefBiosLogo)
599	{
600	Log(("logoMMIORead: Requested address is out of Logo data!!! offLogo=%#x(%d) max:%#x(%d)\n",
601	offLogo, offLogo, g_cbPcDefBiosLogo, g_cbPcDefBiosLogo));
602	return VINF_SUCCESS;
603	}
604
605	memcpy(pv, &g_abPcDefBiosLogo[offLogo], cb);
606	Log(("logoMMIORead: offLogo=%#x(%d) cb=%#x %.*Vhxs\n", offLogo, offLogo, cb, cb, &g_abPcDefBiosLogo[offLogo]));
607	}
608
609	return VINF_SUCCESS;
610	}
611
612
613	/**
614	* Legacy LOGO memory (0xd0000 - 0xdffff) write hook, to be called from IOM.
615	*
616	* @returns VBox status code.
617	* @param pDevIns Pointer device instance.
618	* @param pvUser User argument - ignored.
619	* @param GCPhysAddr Physical address of memory to write.
620	* @param pv Pointer to data.
621	* @param cb Bytes to write.
622	*/
623	static DECLCALLBACK(int) logoMMIOWrite(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb)
624	{
625	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
626	Log(("logoMMIOWrite: GCPhysAddr=%x cb=%d pv[0]=%#04x (byte)\n", GCPhysAddr, pv, cb, (uint8_t )pv));
627
628	/*
629	* Byte write to off 0: Switch the logo bank.
630	*/
631	if ((GCPhysAddr & LOGO_BANK_OFFSET) == 0 && cb == 1)
632	{
633	uint8_t u8Bank = (uint8_t )pv;
634	uint32_t off = u8Bank * LOGO_BANK_SIZE;
635
636	if ( u8Bank != LOGO_BANK_DEFAULT_LOGO
637	&& off > pData->cbLogo)
638	{
639	Log(("logoMMIOWrite: The requested bank is outside the logo image! (cbLogo=%d off=%d)\n", pData->cbLogo, off));
640	return VINF_SUCCESS;
641	}
642
643	pData->u8LogoBank = u8Bank;
644	}
645
646	return VINF_SUCCESS;
647	}
648
649
650	/**
651	* Reset notification.
652	*
653	* @returns VBox status.
654	* @param pDevIns The device instance data.
655	*/
656	static DECLCALLBACK(void) pcbiosReset(PPDMDEVINS pDevIns)
657	{
658	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
659	LogFlow(("pcbiosReset:\n"));
660
661	pData->u8LogoBank = 0;
662	/** @todo Should we perhaps do pcbiosInitComplete() on reset? */
663
664	#if 1
665	/*
666	* Paranoia: Check that the BIOS ROM hasn't changed.
667	*/
668	PVM pVM = PDMDevHlpGetVM(pDevIns);
669	/* the low ROM mapping. */
670	unsigned cb = RT_MIN(g_cbPcBiosBinary, 128 * _1K);
671	const uint8_t pb1 = (uint8_t )MMPhysGCPhys2HCVirt(pVM, 0x00100000 - cb, cb);
672	AssertRelease(pb1);
673	const uint8_t *pb2 = &g_abPcBiosBinary[g_cbPcBiosBinary - cb];
674	if (memcmp(pb1, pb2, cb))
675	{
676	AssertMsg2("low ROM mismatch! cb=%#x\n", cb);
677	for (unsigned off = 0; off < cb; off++)
678	if (pb1[off] != pb2[off])
679	AssertMsg2("%05x: %02x expected %02x\n", off, pb1[off], pb2[off]);
680	AssertReleaseFailed();
681	}
682
683	/* the high ROM mapping. */
684	pb1 = (uint8_t *)MMPhysGCPhys2HCVirt(pVM, (uint32_t)-g_cbPcBiosBinary, g_cbPcBiosBinary);
685	AssertRelease(pb1);
686	pb2 = &g_abPcBiosBinary[0];
687	if (memcmp(pb1, pb2, g_cbPcBiosBinary))
688	{
689	AssertMsg2("high ROM mismatch! g_cbPcBiosBinary=%#x\n", g_cbPcBiosBinary);
690	for (unsigned off = 0; off < g_cbPcBiosBinary; off++)
691	if (pb1[off] != pb2[off])
692	AssertMsg2("%05x: %02x expected %02x\n", off, pb1[off], pb2[off]);
693	AssertReleaseFailed();
694	}
695	#endif
696	}
697
698
699	/**
700	* Destruct a device instance.
701	*
702	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
703	* resources can be freed correctly.
704	*
705	* @param pDevIns The device instance data.
706	*/
707	static DECLCALLBACK(int) pcbiosDestruct(PPDMDEVINS pDevIns)
708	{
709	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
710	LogFlow(("pcbiosDestruct:\n"));
711
712	/*
713	* Free MM heap pointers.
714	*/
715	if (pData->pu8LanBoot)
716	{
717	MMR3HeapFree(pData->pu8LanBoot);
718	pData->pu8LanBoot = NULL;
719	}
720
721	if (pData->pszLanBootFile)
722	{
723	MMR3HeapFree(pData->pszLanBootFile);
724	pData->pszLanBootFile = NULL;
725	}
726
727	if (pData->pu8Logo)
728	{
729	MMR3HeapFree(pData->pu8Logo);
730	pData->pu8Logo = NULL;
731	}
732
733	if (pData->pszLogoFile)
734	{
735	MMR3HeapFree(pData->pszLogoFile);
736	pData->pszLogoFile = NULL;
737	}
738
739	return VINF_SUCCESS;
740	}
741
742
743	/**
744	* Convert config value to DEVPCBIOSBOOT.
745	*
746	* @returns VBox status code.
747	* @param pCfgHandle Configuration handle.
748	* @param pszParam The name of the value to read.
749	* @param penmBoot Where to store the boot method.
750	*/
751	static int pcbiosBootFromCfg(PPDMDEVINS pDevIns, PCFGMNODE pCfgHandle, const char pszParam, DEVPCBIOSBOOT penmBoot)
752	{
753	char *psz;
754	int rc = CFGMR3QueryStringAlloc(pCfgHandle, pszParam, &psz);
755	if (VBOX_FAILURE(rc))
756	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
757	N_("Configuration error: Querying \"%s\" as a string failed"),
758	pszParam);
759	if (!strcmp(psz, "DVD") \|\| !strcmp(psz, "CDROM"))
760	*penmBoot = DEVPCBIOSBOOT_DVD;
761	else if (!strcmp(psz, "IDE"))
762	*penmBoot = DEVPCBIOSBOOT_HD;
763	else if (!strcmp(psz, "FLOPPY"))
764	*penmBoot = DEVPCBIOSBOOT_FLOPPY;
765	else if (!strcmp(psz, "LAN"))
766	*penmBoot = DEVPCBIOSBOOT_LAN;
767	else if (!strcmp(psz, "NONE"))
768	*penmBoot = DEVPCBIOSBOOT_NONE;
769	else
770	{
771	PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
772	N_("Configuration error: The \"%s\" value \"%s\" is unknown.\n"),
773	pszParam, psz);
774	rc = VERR_INTERNAL_ERROR;
775	}
776	MMR3HeapFree(psz);
777	return rc;
778	}
779
780	#define STRCPY(p, s) do { memcpy (p, s, sizeof(s)); p += sizeof(s); } while (0)
781	static void pcbiosPlantDMITable(uint8_t *table)
782	{
783	char pszStr = (char)table;
784	int iStrNr;
785
786	PDMIBIOSINF pBIOSInf = (PDMIBIOSINF)pszStr;
787	pszStr = (char*)(pBIOSInf+1);
788	iStrNr = 1;
789	pBIOSInf->header.u8Type = 0; /* BIOS Information */
790	pBIOSInf->header.u8Length = sizeof(*pBIOSInf);
791	pBIOSInf->header.u16Handle = 0x0000;
792	pBIOSInf->u8Vendor = iStrNr++;
793	STRCPY(pszStr, "InnoTek Systemberatung GmbH");
794	pBIOSInf->u8Version = iStrNr++;
795	STRCPY(pszStr, "VirtualBox");
796	pBIOSInf->u16Start = 0xE000;
797	pBIOSInf->u8Release = iStrNr++;
798	STRCPY(pszStr, "12/01/2006");
799	pBIOSInf->u8ROMSize = 1; /* 128K */
800	pBIOSInf->u64Characteristics = BIT(4) /* ISA is supported */
801	\| BIT(7) /* PCI is supported */
802	\| BIT(15) /* Boot from CD is supported */
803	\| BIT(16) /* Selectable Boot is supported */
804	\| BIT(27) /* Int 9h, 8042 Keyboard services supported */
805	\| BIT(30) /* Int 10h, CGA/Mono Video Services supported */
806	/* any more?? */
807	;
808	pBIOSInf->u8CharacteristicsByte1 = BIT(0) /* ACPI is supported */
809	/* any more?? */
810	;
811	pBIOSInf->u8CharacteristicsByte2 = 0
812	/* any more?? */
813	;
814	*pszStr++ = '\0';
815
816
817	PDMISYSTEMINF pSystemInf = (PDMISYSTEMINF)pszStr;
818	pszStr = (char*)(pSystemInf+1);
819	iStrNr = 1;
820	pSystemInf->header.u8Type = 1; /* System Information */
821	pSystemInf->header.u8Length = sizeof(*pSystemInf);
822	pSystemInf->header.u16Handle = 0x0001;
823	pSystemInf->u8Manufacturer = iStrNr++;
824	STRCPY(pszStr, "InnoTek Systemberatung GmbH");
825	pSystemInf->u8ProductName = iStrNr++;
826	STRCPY(pszStr, "VirtualBox");
827	pSystemInf->u8Version = iStrNr++;
828	STRCPY(pszStr, "1.2");
829	pSystemInf->u8SerialNumber = iStrNr++;
830	STRCPY(pszStr, "0");
831	pSystemInf->u8WakeupType = 6; /* Power Switch */
832	pSystemInf->u8SKUNumber = 0;
833	pSystemInf->u8Family = iStrNr++;
834	STRCPY(pszStr, "Virtual Machine");
835	*pszStr++ = '\0';
836
837	AssertMsg(pszStr - (char*)table == VBOX_DMI_TABLE_SIZE,
838	("VBOX_DMI_TABLE_SIZE=%d, actual DMI table size is %d",
839	VBOX_DMI_TABLE_SIZE, pszStr - (char*)table));
840	}
841
842	AssertCompile(VBOX_DMI_TABLE_ENTR == 2);
843
844
845	/**
846	* Construct a device instance for a VM.
847	*
848	* @returns VBox status.
849	* @param pDevIns The device instance data.
850	* If the registration structure is needed, pDevIns->pDevReg points to it.
851	* @param iInstance Instance number. Use this to figure out which registers and such to use.
852	* The device number is also found in pDevIns->iInstance, but since it's
853	* likely to be freqently used PDM passes it as parameter.
854	* @param pCfgHandle Configuration node handle for the device. Use this to obtain the configuration
855	* of the device instance. It's also found in pDevIns->pCfgHandle, but like
856	* iInstance it's expected to be used a bit in this function.
857	*/
858	static DECLCALLBACK(int) pcbiosConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
859	{
860	unsigned i;
861	PDEVPCBIOS pData = PDMINS2DATA(pDevIns, PDEVPCBIOS);
862	int rc;
863	int cb;
864	// char *psz;
865
866	Assert(iInstance == 0);
867
868	/*
869	* Validate configuration.
870	*/
871	if (!CFGMR3AreValuesValid(pCfgHandle,
872	"BootDevice0\0"
873	"BootDevice1\0"
874	"BootDevice2\0"
875	"BootDevice3\0"
876	"RamSize\0"
877	"HardDiskDevice\0"
878	"FloppyDevice\0"
879	"FadeIn\0"
880	"FadeOut\0"
881	"LogoTime\0"
882	"LogoFile\0"
883	"ShowBootMenu\0"
884	"DelayBoot\0"
885	"LanBootRom\0"))
886	return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
887	N_("Invalid configuraton for device pcbios device"));
888
889	/*
890	* Init the data.
891	*/
892	rc = CFGMR3QueryU64(pCfgHandle, "RamSize", &pData->cbRam);
893	if (VBOX_FAILURE(rc))
894	return PDMDEV_SET_ERROR(pDevIns, rc,
895	N_("Configuration error: Querying \"RamSize\" as integer failed"));
896
897	static const char * const s_apszBootDevices[] = { "BootDevice0", "BootDevice1", "BootDevice2", "BootDevice3" };
898	Assert(ELEMENTS(s_apszBootDevices) == ELEMENTS(pData->aenmBootDevice));
899	for (i = 0; i < ELEMENTS(pData->aenmBootDevice); i++)
900	{
901	rc = pcbiosBootFromCfg(pDevIns, pCfgHandle, s_apszBootDevices[i], &pData->aenmBootDevice[i]);
902	if (VBOX_FAILURE(rc))
903	return rc;
904	}
905
906	rc = CFGMR3QueryStringAlloc(pCfgHandle, "HardDiskDevice", &pData->pszHDDevice);
907	if (VBOX_FAILURE(rc))
908	return PDMDEV_SET_ERROR(pDevIns, rc,
909	N_("Configuration error: Querying \"HardDiskDevice\" as a string failed"));
910
911	rc = CFGMR3QueryStringAlloc(pCfgHandle, "FloppyDevice", &pData->pszFDDevice);
912	if (VBOX_FAILURE(rc))
913	return PDMDEV_SET_ERROR(pDevIns, rc,
914	N_("Configuration error: Querying \"FloppyDevice\" as a string failed"));
915
916	/*
917	* Register I/O Ports and PC BIOS.
918	*/
919	rc = PDMDevHlpIOPortRegister(pDevIns, 0x400, 4, NULL, pcbiosIOPortWrite, pcbiosIOPortRead,
920	NULL, NULL, "Bochs PC BIOS - Panic & Debug");
921	if (VBOX_FAILURE(rc))
922	return rc;
923	rc = PDMDevHlpIOPortRegister(pDevIns, 0x8900, 1, NULL, pcbiosIOPortWrite, pcbiosIOPortRead,
924	NULL, NULL, "Bochs PC BIOS - Shutdown");
925	if (VBOX_FAILURE(rc))
926	return rc;
927
928	pcbiosPlantDMITable(pData->au8DMIPage);
929
930	rc = PDMDevHlpROMRegister(pDevIns, VBOX_DMI_TABLE_BASE, 0x1000, pData->au8DMIPage, "DMI tables");
931	if (VBOX_FAILURE(rc))
932	return rc;
933
934	/*
935	* Map the BIOS into memory.
936	* There are two mappings:
937	* 1. 0x000e0000 to 0x000fffff contains the last 128 kb of the bios.
938	* The bios code might be 64 kb in size, and will then start at 0xf0000.
939	* 2. 0xfffxxxxx to 0xffffffff contains the entire bios.
940	*/
941	AssertReleaseMsg(g_cbPcBiosBinary >= _64K, ("g_cbPcBiosBinary=%#x\n", g_cbPcBiosBinary));
942	AssertReleaseMsg(RT_ALIGN_Z(g_cbPcBiosBinary, _64K) == g_cbPcBiosBinary,
943	("g_cbPcBiosBinary=%#x\n", g_cbPcBiosBinary));
944	cb = RT_MIN(g_cbPcBiosBinary, 128 * _1K);
945	rc = PDMDevHlpROMRegister(pDevIns, 0x00100000 - cb, cb,
946	&g_abPcBiosBinary[g_cbPcBiosBinary - cb], "PC BIOS - 0xfffff");
947	if (VBOX_FAILURE(rc))
948	return rc;
949	rc = PDMDevHlpROMRegister(pDevIns, (uint32_t)-g_cbPcBiosBinary, g_cbPcBiosBinary,
950	&g_abPcBiosBinary[0], "PC BIOS - 0xffffffff");
951	if (VBOX_FAILURE(rc))
952	return rc;
953
954	/*
955	* Register the MMIO region for the BIOS Logo: 0x000d0000 to 0x000dffff (64k)
956	*/
957	rc = PDMDevHlpMMIORegister(pDevIns, 0x000d0000, 0x00010000, 0,
958	logoMMIOWrite, logoMMIORead, NULL, "PC BIOS - Logo Buffer");
959	if (VBOX_FAILURE(rc))
960	return rc;
961
962	/*
963	* Construct the logo header.
964	*/
965	LOGOHDR LogoHdr = { LOGOHDR_MAGIC, 0, 0, 0, 0, 0 };
966
967	rc = CFGMR3QueryU8(pCfgHandle, "FadeIn", &LogoHdr.u8FadeIn);
968	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
969	LogoHdr.u8FadeIn = 1;
970	else if (VBOX_FAILURE(rc))
971	return PDMDEV_SET_ERROR(pDevIns, rc,
972	N_("Configuration error: Querying \"FadeIn\" as integer failed"));
973
974	rc = CFGMR3QueryU8(pCfgHandle, "FadeOut", &LogoHdr.u8FadeOut);
975	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
976	LogoHdr.u8FadeOut = 1;
977	else if (VBOX_FAILURE(rc))
978	return PDMDEV_SET_ERROR(pDevIns, rc,
979	N_("Configuration error: Querying \"FadeOut\" as integer failed"));
980
981	rc = CFGMR3QueryU16(pCfgHandle, "LogoTime", &LogoHdr.u16LogoMillies);
982	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
983	LogoHdr.u16LogoMillies = 1;
984	else if (VBOX_FAILURE(rc))
985	return PDMDEV_SET_ERROR(pDevIns, rc,
986	N_("Configuration error: Querying \"LogoTime\" as integer failed"));
987
988	rc = CFGMR3QueryU8(pCfgHandle, "ShowBootMenu", &LogoHdr.u8ShowBootMenu);
989	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
990	LogoHdr.u8ShowBootMenu = 0;
991	else if (VBOX_FAILURE(rc))
992	return PDMDEV_SET_ERROR(pDevIns, rc,
993	N_("Configuration error: Querying \"ShowBootMenu\" as integer failed"));
994
995	/*
996	* Get the Logo file name.
997	*/
998	rc = CFGMR3QueryStringAlloc(pCfgHandle, "LogoFile", &pData->pszLogoFile);
999	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1000	pData->pszLogoFile = NULL;
1001	else if (VBOX_FAILURE(rc))
1002	return PDMDEV_SET_ERROR(pDevIns, rc,
1003	N_("Configuration error: Querying \"LogoFile\" as a string failed"));
1004	else if (!*pData->pszLogoFile)
1005	{
1006	MMR3HeapFree(pData->pszLogoFile);
1007	pData->pszLogoFile = NULL;
1008	}
1009
1010	/*
1011	* Determine the logo size, open any specified logo file in the process.
1012	*/
1013	LogoHdr.cbLogo = g_cbPcDefBiosLogo;
1014	RTFILE FileLogo = NIL_RTFILE;
1015	if (pData->pszLogoFile)
1016	{
1017	rc = RTFileOpen(&FileLogo, pData->pszLogoFile,
1018	RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1019	if (VBOX_SUCCESS(rc))
1020	{
1021	uint64_t cbFile;
1022	rc = RTFileGetSize(FileLogo, &cbFile);
1023	if (VBOX_SUCCESS(rc))
1024	{
1025	if ( cbFile > 0
1026	&& cbFile < ((LOGO_BANK_LAST + 1) * LOGO_BANK_SIZE) - sizeof(LogoHdr))
1027	LogoHdr.cbLogo = (uint32_t)cbFile;
1028	else
1029	rc = VERR_TOO_MUCH_DATA;
1030	}
1031	}
1032	if (VBOX_FAILURE(rc))
1033	{
1034	/*
1035	* Ignore failure and fall back to the default logo.
1036	*/
1037	LogRel(("pcbiosConstruct: Failed to open logo file '%s', rc=%Vrc!\n", pData->pszLogoFile, rc));
1038	RTFileClose(FileLogo);
1039	FileLogo = NIL_RTFILE;
1040	MMR3HeapFree(pData->pszLogoFile);
1041	pData->pszLogoFile = NULL;
1042	}
1043	}
1044
1045	/*
1046	* Allocate buffer for the logo data.
1047	* RT_MAX() is applied to let us fall back to default logo on read failure.
1048	*/
1049	pData->cbLogo = sizeof(LogoHdr) + LogoHdr.cbLogo;
1050	pData->pu8Logo = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, RT_MAX(pData->cbLogo, g_cbPcDefBiosLogo + sizeof(LogoHdr)));
1051	if (pData->pu8Logo)
1052	{
1053	/*
1054	* Write the logo header.
1055	*/
1056	PLOGOHDR pLogoHdr = (PLOGOHDR)pData->pu8Logo;
1057	*pLogoHdr = LogoHdr;
1058
1059	/*
1060	* Write the logo bitmap.
1061	*/
1062	if (pData->pszLogoFile)
1063	{
1064	rc = RTFileRead(FileLogo, pLogoHdr + 1, LogoHdr.cbLogo, NULL);
1065	if (VBOX_FAILURE(rc))
1066	{
1067	AssertMsgFailed(("RTFileRead(,,%d,NULL) -> %Vrc\n", LogoHdr.cbLogo, rc));
1068	pLogoHdr->cbLogo = LogoHdr.cbLogo = g_cbPcDefBiosLogo;
1069	memcpy(pLogoHdr + 1, g_abPcDefBiosLogo, LogoHdr.cbLogo);
1070	}
1071	}
1072	else
1073	memcpy(pLogoHdr + 1, g_abPcDefBiosLogo, LogoHdr.cbLogo);
1074
1075	/*
1076	* Call reset to set values and stuff.
1077	*/
1078	pcbiosReset(pDevIns);
1079	rc = VINF_SUCCESS;
1080	}
1081	else
1082	rc = VERR_NO_MEMORY;
1083
1084	/* cleanup */
1085	if (FileLogo != NIL_RTFILE)
1086	RTFileClose(FileLogo);
1087
1088	/*
1089	* Get the LAN boot ROM file name.
1090	*/
1091	rc = CFGMR3QueryStringAlloc(pCfgHandle, "LanBootRom", &pData->pszLanBootFile);
1092	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1093	{
1094	pData->pszLanBootFile = NULL;
1095	rc = VINF_SUCCESS;
1096	}
1097	else if (VBOX_FAILURE(rc))
1098	return PDMDEV_SET_ERROR(pDevIns, rc,
1099	N_("Configuration error: Querying \"LanBootRom\" as a string failed"));
1100	else if (!*pData->pszLanBootFile)
1101	{
1102	MMR3HeapFree(pData->pszLanBootFile);
1103	pData->pszLanBootFile = NULL;
1104	}
1105
1106	const uint8_t *pu8LanBoot = NULL;
1107	uint64_t cbFileLanBoot;
1108	#ifdef VBOX_DO_NOT_LINK_LANBOOT
1109	/*
1110	* Determine the LAN boot ROM size, open specified ROM file in the process.
1111	*/
1112	RTFILE FileLanBoot = NIL_RTFILE;
1113	if (pData->pszLanBootFile)
1114	{
1115	rc = RTFileOpen(&FileLanBoot, pData->pszLanBootFile,
1116	RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1117	if (VBOX_SUCCESS(rc))
1118	{
1119	rc = RTFileGetSize(FileLanBoot, &cbFileLanBoot);
1120	if (VBOX_SUCCESS(rc))
1121	{
1122	if ( RT_ALIGN(cbFileLanBoot, _4K) != cbFileLanBoot
1123	\|\| cbFileLanBoot > _32K)
1124	rc = VERR_TOO_MUCH_DATA;
1125	}
1126	}
1127	if (VBOX_FAILURE(rc))
1128	{
1129	/*
1130	* Ignore failure and fall back to no LAN boot ROM.
1131	*/
1132	Log(("pcbiosConstruct: Failed to open LAN boot ROM file '%s', rc=%Vrc!\n", pData->pszLanBootFile, rc));
1133	RTFileClose(FileLanBoot);
1134	FileLanBoot = NIL_RTFILE;
1135	MMR3HeapFree(pData->pszLanBootFile);
1136	pData->pszLanBootFile = NULL;
1137	}
1138	}
1139
1140	/*
1141	* Get the LAN boot ROM data.
1142	*/
1143	if (pData->pszLanBootFile)
1144	{
1145	/*
1146	* Allocate buffer for the LAN boot ROM data.
1147	*/
1148	pu8LanBoot = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, cbFileLanBoot);
1149	pData->pu8LanBoot = pu8LanBoot;
1150	if (pu8LanBoot)
1151	{
1152	rc = RTFileRead(FileLanBoot, pData->pu8LanBoot, cbFileLanBoot, NULL);
1153	if (VBOX_FAILURE(rc))
1154	{
1155	AssertMsgFailed(("RTFileRead(,,%d,NULL) -> %Vrc\n", cbFileLanBoot, rc));
1156	MMR3HeapFree(pu8LanBoot);
1157	pu8LanBoot = NULL;
1158	pData->pu8LanBoot = NULL;
1159	}
1160	rc = VINF_SUCCESS;
1161	}
1162	else
1163	rc = VERR_NO_MEMORY;
1164	}
1165	else
1166	pData->pu8LanBoot = NULL;
1167
1168	/* cleanup */
1169	if (FileLanBoot != NIL_RTFILE)
1170	RTFileClose(FileLanBoot);
1171
1172	#else /* !VBOX_DO_NOT_LINK_LANBOOT */
1173	pData->pu8LanBoot = NULL;
1174	pu8LanBoot = g_abNetBiosBinary;
1175	cbFileLanBoot = g_cbNetBiosBinary;
1176	#endif /* !VBOX_DO_NOT_LINK_LANBOOT */
1177
1178	/*
1179	* Map the Network Boot ROM into memory.
1180	* Currently there is a fixed mapping: 0x000c8000 to 0x000cffff contains
1181	* the (up to) 32 kb ROM image.
1182	*/
1183	if (pu8LanBoot)
1184	rc = PDMDevHlpROMRegister(pDevIns, VBOX_LANBOOT_SEG << 4, cbFileLanBoot, pu8LanBoot, "Net Boot ROM");
1185
1186	rc = CFGMR3QueryU8(pCfgHandle, "DelayBoot", &pData->uBootDelay);
1187	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1188	{
1189	pData->uBootDelay = 0;
1190	rc = VINF_SUCCESS;
1191	}
1192	else
1193	{
1194	if (VBOX_FAILURE(rc))
1195	return PDMDEV_SET_ERROR(pDevIns, rc,
1196	N_("Configuration error: Querying \"DelayBoot\" as integer failed"));
1197	if (pData->uBootDelay > 15)
1198	pData->uBootDelay = 15;
1199	}
1200
1201	return rc;
1202	}
1203
1204
1205	/**
1206	* The device registration structure.
1207	*/
1208	const PDMDEVREG g_DevicePcBios =
1209	{
1210	/* u32Version */
1211	PDM_DEVREG_VERSION,
1212	/* szDeviceName */
1213	"pcbios",
1214	/* szGCMod */
1215	"",
1216	/* szR0Mod */
1217	"",
1218	/* pszDescription */
1219	"Bochs PC BIOS",
1220	/* fFlags */
1221	PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_GUEST_BITS_32_64,
1222	/* fClass */
1223	PDM_DEVREG_CLASS_ARCH_BIOS,
1224	/* cMaxInstances */
1225	1,
1226	/* cbInstance */
1227	sizeof(DEVPCBIOS),
1228	/* pfnConstruct */
1229	pcbiosConstruct,
1230	/* pfnDestruct */
1231	pcbiosDestruct,
1232	/* pfnRelocate */
1233	NULL,
1234	/* pfnIOCtl */
1235	NULL,
1236	/* pfnPowerOn */
1237	NULL,
1238	/* pfnReset */
1239	pcbiosReset,
1240	/* pfnSuspend */
1241	NULL,
1242	/* pfnResume */
1243	NULL,
1244	/* pfnAttach */
1245	NULL,
1246	/* pfnDetach */
1247	NULL,
1248	/* pfnQueryInterface. */
1249	NULL,
1250	/* pfnInitComplete. */
1251	pcbiosInitComplete
1252	};
1253

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

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

Download in other formats: