warmboot.c

BIOS emulator and interface to Realmode X86 Emulator Library Can emulate a PCI Graphic Controller V

			sprintf(filename,"%s/bios.%02d",PM_getNucleusConfigPath(),device);
			if ((f = fopen(filename,"rb")) != NULL) {
				fread(copyOfBIOS,1,FINAL_BIOSLEN,f);
				fread(VGAInfo[device].LowMem,1,sizeof(VGAInfo[device].LowMem),f);
				fclose(f);
				}
			}

		// Fix up all the secondary PCI base address registers
		// (restores them all from the values we read previously)
		_PCI_fixupSecondaryBARs();

		// Disable the secondary controller and AGP VGA pass-through
		DISABLE_DEVICE(device);
		if (AGPBridge)
			DISABLE_AGP_VGA();
		}

	// Reenable primary display controller and reset AGP bridge control
	if (AGPBridge)
		RESTORE_AGP_VGA();
	ENABLE_DEVICE(0);

	// Free physical BIOS image mapping
	PM_freePhysicalAddr(mappedBIOS,MAX_BIOSLEN-1);

	// Restore the X86 emulator BIOS info to primary controller
	if (!useV86)
		BE_setVGA(&VGAInfo[0]);
	return true;
}

/****************************************************************************
REMARKS:
Enumerates the PCI bus and dumps the PCI configuration information to the
log file.
****************************************************************************/
static void EnumeratePCI(void)
{
	int				i,index;
	PCIBridgeInfo	*info;

	printk("Displaying enumeration of PCI bus (%d devices, %d display devices)\n",
		NumPCI, NumDevices);
	for (index = 0; index < NumDevices; index++)
		printk("  Display device %d is PCI device %d\n",index,DeviceIndex[index]);
	printk("\n");
	printk("Bus Slot Fnc DeviceID  SubSystem Rev Class IRQ Int Cmd\n");
	for (i = 0; i < NumPCI; i++) {
		printk("%2d   %2d  %2d  %04X:%04X %04X:%04X %02X  %02X:%02X %02X  %02X  %04X   ",
			PCI[i].slot.p.Bus,
			PCI[i].slot.p.Device,
			PCI[i].slot.p.Function,
			PCI[i].VendorID,
			PCI[i].DeviceID,
			PCI[i].SubSystemVendorID,
			PCI[i].SubSystemID,
			PCI[i].RevID,
			PCI[i].BaseClass,
			PCI[i].SubClass,
			PCI[i].InterruptLine,
			PCI[i].InterruptPin,
			PCI[i].Command);
		for (index = 0; index < NumDevices; index++) {
			if (DeviceIndex[index] == i)
				break;
			}
		if (index < NumDevices)
			printk("<- %d\n", index);
		else
			printk("\n");
		}
	printk("\n");
	printk("DeviceID  Stat Ifc Cch Lat Hdr BIST\n");
	for (i = 0; i < NumPCI; i++) {
		printk("%04X:%04X %04X  %02X  %02X  %02X  %02X  %02X   ",
			PCI[i].VendorID,
			PCI[i].DeviceID,
			PCI[i].Status,
			PCI[i].Interface,
			PCI[i].CacheLineSize,
			PCI[i].LatencyTimer,
			PCI[i].HeaderType,
			PCI[i].BIST);
		for (index = 0; index < NumDevices; index++) {
			if (DeviceIndex[index] == i)
				break;
			}
		if (index < NumDevices)
			printk("<- %d\n", index);
		else
			printk("\n");
		}
	printk("\n");
	printk("DeviceID  Base10h  Base14h  Base18h  Base1Ch  Base20h  Base24h  ROMBase\n");
	for (i = 0; i < NumPCI; i++) {
		printk("%04X:%04X %08X %08X %08X %08X %08X %08X %08X ",
			PCI[i].VendorID,
			PCI[i].DeviceID,
			PCI[i].BaseAddress10,
			PCI[i].BaseAddress14,
			PCI[i].BaseAddress18,
			PCI[i].BaseAddress1C,
			PCI[i].BaseAddress20,
			PCI[i].BaseAddress24,
			PCI[i].ROMBaseAddress);
		for (index = 0; index < NumDevices; index++) {
			if (DeviceIndex[index] == i)
				break;
			}
		if (index < NumDevices)
			printk("<- %d\n", index);
		else
			printk("\n");
		}
	printk("\n");
	printk("DeviceID  BAR10Len BAR14Len BAR18Len BAR1CLen BAR20Len BAR24Len ROMLen\n");
	for (i = 0; i < NumPCI; i++) {
		printk("%04X:%04X %08X %08X %08X %08X %08X %08X %08X ",
			PCI[i].VendorID,
			PCI[i].DeviceID,
			PCI[i].BaseAddress10Len,
			PCI[i].BaseAddress14Len,
			PCI[i].BaseAddress18Len,
			PCI[i].BaseAddress1CLen,
			PCI[i].BaseAddress20Len,
			PCI[i].BaseAddress24Len,
			PCI[i].ROMBaseAddressLen);
		for (index = 0; index < NumDevices; index++) {
			if (DeviceIndex[index] == i)
				break;
			}
		if (index < NumDevices)
			printk("<- %d\n", index);
		else
			printk("\n");
		}
	printk("\n");
	printk("Displaying enumeration of %d bridge devices\n",NumBridges);
	printk("\n");
	printk("DeviceID  P# S# B# IOB  IOL  MemBase  MemLimit PreBase  PreLimit Ctrl\n");
	for (i = 0; i < NumBridges; i++) {
		info = (PCIBridgeInfo*)&PCI[BridgeIndex[i]];
		printk("%04X:%04X %02X %02X %02X %04X %04X %08X %08X %08X %08X %04X\n",
			info->VendorID,
			info->DeviceID,
			info->PrimaryBusNumber,
			info->SecondayBusNumber,
			info->SubordinateBusNumber,
			((u16)info->IOBase << 8) & 0xF000,
			info->IOLimit ?
				((u16)info->IOLimit << 8) | 0xFFF : 0,
			((u32)info->MemoryBase << 16) & 0xFFF00000,
			info->MemoryLimit ?
				((u32)info->MemoryLimit << 16) | 0xFFFFF : 0,
			((u32)info->PrefetchableMemoryBase << 16) & 0xFFF00000,
			info->PrefetchableMemoryLimit ?
				((u32)info->PrefetchableMemoryLimit << 16) | 0xFFFFF : 0,
			info->BridgeControl);
		}
	printk("\n");
}

/****************************************************************************
RETURNS:
Number of display devices found.

REMARKS:
This function enumerates the number of available display devices on the
PCI bus, and returns the number found.
****************************************************************************/
static int PCI_enumerateDevices(void)
{
	int				i,j;
	PCIBridgeInfo	*info;

	// If this is the first time we have been called, enumerate all
	// devices on the PCI bus.
	if (NumPCI == -1) {
		for (i = 0; i < MAX_PCI_DEVICES; i++)
			PCI[i].dwSize = sizeof(PCI[i]);
		if ((NumPCI = PCI_enumerate(PCI,MAX_PCI_DEVICES)) == 0)
			return -1;

		// Build a list of all PCI bridge devices
		for (i = 0,NumBridges = 0,BridgeIndex[0] = -1; i < NumPCI; i++) {
			if (PCI[i].BaseClass == PCI_BRIDGE_CLASS) {
				if (NumBridges < MAX_PCI_DEVICES)
					BridgeIndex[NumBridges++] = i;
				}
			}

		// Now build a list of all display class devices
		for (i = 0,NumDevices = 1,DeviceIndex[0] = -1; i < NumPCI; i++) {
			if (((PCI[i].BaseClass == PCI_DISPLAY_CLASS && PCI[i].SubClass == PCI_DISPLAY_VGA_SUBCLASS)
					|| (PCI[i].BaseClass == PCI_EARLY_VGA_CLASS && PCI[i].SubClass == PCI_EARLY_VGA_SUBCLASS))) {
				if ((PCI[i].Command & 0x3) == 0x3) {
					DeviceIndex[0] = i;
					}
				else {
					if (NumDevices < MAX_PCI_DEVICES)
						DeviceIndex[NumDevices++] = i;
					}
				if (PCI[i].slot.p.Bus != 0) {
					// This device is on a different bus than the primary
					// PCI bus, so it is probably an AGP device. Find the
					// AGP bus device that controls that bus so we can
					// control it.
					for (j = 0; j < NumBridges; j++) {
						info = (PCIBridgeInfo*)&PCI[BridgeIndex[j]];
						if (info->SecondayBusNumber == PCI[i].slot.p.Bus) {
							AGPBridge = info;
							break;
							}
						}
					}
				}
			}

		// Enumerate all PCI and bridge devices to log file
		EnumeratePCI();
		}
	return NumDevices;
}

FILE *logfile;

void printk(const char *fmt, ...)
{
	va_list argptr;
	va_start(argptr, fmt);
	vfprintf(logfile, fmt, argptr);
	fflush(logfile);
	va_end(argptr);
}

int main(int argc,char *argv[])
{
	while (argc > 1) {
		if (stricmp(argv[1],"-usev86") == 0) {
			useV86 = true;
			}
		else if (stricmp(argv[1],"-force") == 0) {
			forcePost = true;
			}
#ifdef	DEBUG
		else if (stricmp(argv[1],"-decode") == 0) {
			debugFlags |= DEBUG_DECODE_F;
			}
		else if (stricmp(argv[1],"-iotrace") == 0) {
			debugFlags |= DEBUG_IO_TRACE_F;
			}
#endif
		else {
			printf("Usage: warmboot [-usev86] [-force] [-decode] [-iotrace]\n");
			exit(-1);
			}
		argc--;
		argv++;
		}
	if ((logfile = fopen("warmboot.log","w")) == NULL)
		exit(1);

   	PM_init();
	if (!useV86) {
		// Initialise the x86 BIOS emulator
		BE_init(false,debugFlags,65536,&VGAInfo[0]);
		}

	// Enumerate all devices (which POST's them at the same time)
	if (PCI_enumerateDevices() < 1) {
		printk("No PCI display devices found!\n");
		return -1;
		}

	// Post all the display controller BIOS'es
	PCI_postControllers();

	// Cleanup and exit the emulator
	if (!useV86)
		BE_exit();
	fclose(logfile);
	return 0;
}