600 lines
15 KiB
C
600 lines
15 KiB
C
/*++
|
||
|
||
Copyright (c) 1994 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
x86bios.c
|
||
|
||
Abstract:
|
||
|
||
|
||
This module implements the platform specific interface between a device
|
||
driver and the execution of x86 ROM bios code for the device.
|
||
|
||
Author:
|
||
|
||
David N. Cutler (davec) 17-Jun-1994
|
||
|
||
Environment:
|
||
|
||
Kernel mode only.
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "halp.h"
|
||
#include "pci.h"
|
||
#include "xm86.h"
|
||
#include "x86new.h"
|
||
|
||
//
|
||
// The X86 Emulator built into the HAL is suported on MIPS and PPC,
|
||
// but not ALPHA. If this is an ALPHA system, then don't include the
|
||
// code that uses the X86 emulator in the HAL. Instead, use the X86
|
||
// emulator built in the Firmware if one is available.
|
||
//
|
||
|
||
#ifndef ALPHA
|
||
#define ENABLE_HAL_X86_EMULATOR
|
||
#endif
|
||
|
||
typedef struct FIRMWARE_INT_ARGUMENTS {
|
||
ULONG pEAX;
|
||
ULONG pEBX;
|
||
ULONG pECX;
|
||
ULONG pEDX;
|
||
ULONG pESI;
|
||
ULONG pEDI;
|
||
ULONG pEBP;
|
||
USHORT pES;
|
||
USHORT pDS;
|
||
USHORT pFlags;
|
||
} FIRMWARE_INT_ARGUMENTS, *PFIRMWARE_INT_ARGUMENTS;
|
||
|
||
#ifdef ENABLE_HAL_X86_EMULATOR
|
||
|
||
extern ULONG x86BiosIoSpace;
|
||
ULONG HalpPciConfigAddress;
|
||
|
||
#endif
|
||
|
||
ULONG HalpX86BiosInitialized = FALSE;
|
||
ULONG HalpEnableInt10Calls = FALSE;
|
||
ULONG HalpUseFirmwareX86Emulator = FALSE;
|
||
|
||
typedef
|
||
VOID
|
||
(*PVENDOR_EXECUTE_INT) (
|
||
IN USHORT Type,
|
||
IN PFIRMWARE_INT_ARGUMENTS Context
|
||
);
|
||
|
||
PVENDOR_EXECUTE_INT VendorX86ExecuteInt;
|
||
|
||
VOID HalpInitializeX86DisplayAdapter()
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function performs the initialization required to use an X86 emulator.
|
||
If a firmware level X86 emulator is available, then that emulator will be used.
|
||
Otherwise, we will default to using the emulator built into the HAL if it is
|
||
available.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
XM86_CONTEXT Context;
|
||
PSYSTEM_PARAMETER_BLOCK SystemParameterBlock = SYSTEM_BLOCK;
|
||
PCI_SLOT_NUMBER SlotNumber;
|
||
PPCI_COMMON_CONFIG PciData;
|
||
UCHAR buffer[PCI_COMMON_HDR_LENGTH];
|
||
ULONG PciLength;
|
||
ULONG PciBus;
|
||
ULONG PciDevice;
|
||
ULONG PciFunction;
|
||
ULONG PciVideoAdapterFound;
|
||
|
||
//
|
||
// If EISA I/O Ports or EISA Memory could not be mapped, then leave the
|
||
// X86 BIOS Emulator disabled.
|
||
//
|
||
|
||
if (HalpEisaControlBase[0] == NULL || HalpEisaMemoryBase[0] == NULL) {
|
||
return;
|
||
}
|
||
|
||
//
|
||
// If Firmware level X86 Bios Emulator exists, then use that instead of the
|
||
// one built into the HAL.
|
||
//
|
||
|
||
if ((SystemParameterBlock->VendorVectorLength/4) >= 34) {
|
||
|
||
VendorX86ExecuteInt =
|
||
*(PVENDOR_EXECUTE_INT *)((ULONG)(SystemParameterBlock->VendorVector) + 34*4);
|
||
|
||
if (VendorX86ExecuteInt != NULL) {
|
||
HalpX86BiosInitialized = TRUE;
|
||
HalpUseFirmwareX86Emulator = TRUE;
|
||
HalpEnableInt10Calls = TRUE;
|
||
return;
|
||
}
|
||
}
|
||
|
||
#ifdef ENABLE_HAL_X86_EMULATOR
|
||
|
||
//
|
||
// Attempt to initialize the Display Adapter by executing the Display Adapters
|
||
// initialization code in its BIOS. The standard for PC video adapters is for
|
||
// the BIOS to reside at 0xC000:0000 on the ISA bus.
|
||
//
|
||
|
||
PciVideoAdapterFound = FALSE;
|
||
PciData = (PPCI_COMMON_CONFIG) buffer;
|
||
PciBus = 0;
|
||
do {
|
||
for(PciDevice=0;PciDevice < PCI_MAX_DEVICES;PciDevice++) {
|
||
PciFunction = 0;
|
||
do {
|
||
SlotNumber.u.AsULONG = 0;
|
||
SlotNumber.u.bits.DeviceNumber = PciDevice;
|
||
SlotNumber.u.bits.FunctionNumber = PciFunction;
|
||
|
||
PciLength = HalGetBusData (
|
||
PCIConfiguration,
|
||
PciBus,
|
||
SlotNumber.u.AsULONG,
|
||
PciData,
|
||
PCI_COMMON_HDR_LENGTH
|
||
);
|
||
|
||
if (PciLength==0) {
|
||
break;
|
||
}
|
||
|
||
if (PciData->VendorID == PCI_INVALID_VENDORID) {
|
||
break;
|
||
}
|
||
|
||
if ( (PciData->BaseClass == 0x00 && PciData->SubClass == 0x01) ||
|
||
(PciData->BaseClass == 0x03 && PciData->SubClass == 0x00) ) {
|
||
PciVideoAdapterFound = TRUE;
|
||
break;
|
||
}
|
||
if (PciFunction == 0 && ((PciData->HeaderType & 0x80)==0)) {
|
||
break;
|
||
}
|
||
PciFunction++;
|
||
} while (PciFunction < PCI_MAX_FUNCTION);
|
||
if (PciLength==0 || PciVideoAdapterFound) {
|
||
break;
|
||
}
|
||
}
|
||
if (PciLength==0 || PciVideoAdapterFound) {
|
||
break;
|
||
}
|
||
PciBus++;
|
||
} while (PciLength!=0);
|
||
|
||
if (PciVideoAdapterFound) {
|
||
if (PciBus < HalpSecondPciBridgeBusNumber) {
|
||
x86BiosInitializeBios(HalpPciControlBase[0], HalpPciMemoryBase[0]);
|
||
} else {
|
||
x86BiosInitializeBios(HalpPciControlBase[1], HalpPciMemoryBase[1]);
|
||
}
|
||
Context.Eax = (PciBus<<8) | (PciDevice<<3) | PciFunction;
|
||
} else {
|
||
x86BiosInitializeBios(HalpEisaControlBase[0], HalpEisaMemoryBase[0]);
|
||
Context.Eax = 0;
|
||
}
|
||
HalpX86BiosInitialized = TRUE;
|
||
|
||
Context.Ecx = 0;
|
||
Context.Edx = 0;
|
||
Context.Ebx = 0;
|
||
Context.Ebp = 0;
|
||
Context.Esi = 0;
|
||
Context.Edi = 0;
|
||
|
||
if (x86BiosInitializeAdapter(0xc0000, &Context, NULL, NULL) != XM_SUCCESS) {
|
||
HalpEnableInt10Calls = FALSE;
|
||
return;
|
||
}
|
||
|
||
HalpEnableInt10Calls = TRUE;
|
||
|
||
#endif
|
||
}
|
||
|
||
VOID HalpResetX86DisplayAdapter()
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function invokes the X86 emulator to initialize a text mode 80x25 display.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
XM86_CONTEXT Context;
|
||
|
||
//
|
||
// Make INT 10 call to initialize 80x25 color text mode.
|
||
//
|
||
|
||
Context.Eax = 0x0003; // Function 0, Mode 3
|
||
Context.Ebx = 0;
|
||
Context.Ecx = 0;
|
||
Context.Edx = 0;
|
||
Context.Esi = 0;
|
||
Context.Edi = 0;
|
||
Context.Ebp = 0;
|
||
|
||
HalCallBios(0x10,
|
||
&Context.Eax,
|
||
&Context.Ebx,
|
||
&Context.Ecx,
|
||
&Context.Edx,
|
||
&Context.Esi,
|
||
&Context.Edi,
|
||
&Context.Ebp);
|
||
}
|
||
|
||
|
||
BOOLEAN
|
||
HalCallBios (
|
||
IN ULONG BiosCommand,
|
||
IN OUT PULONG Eax,
|
||
IN OUT PULONG Ebx,
|
||
IN OUT PULONG Ecx,
|
||
IN OUT PULONG Edx,
|
||
IN OUT PULONG Esi,
|
||
IN OUT PULONG Edi,
|
||
IN OUT PULONG Ebp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function provides the platform specific interface between a device
|
||
driver and the execution of the x86 ROM bios code for the specified ROM
|
||
bios command.
|
||
|
||
Arguments:
|
||
|
||
BiosCommand - Supplies the ROM bios command to be emulated.
|
||
|
||
Eax to Ebp - Supplies the x86 emulation context.
|
||
|
||
Return Value:
|
||
|
||
A value of TRUE is returned if the specified function is executed.
|
||
Otherwise, a value of FALSE is returned.
|
||
|
||
--*/
|
||
|
||
{
|
||
FIRMWARE_INT_ARGUMENTS Arguments;
|
||
XM86_CONTEXT Context;
|
||
|
||
//
|
||
// If the X86 BIOS Emulator has not been initialized then fail all INT calls.
|
||
//
|
||
|
||
if (HalpX86BiosInitialized == FALSE) {
|
||
return(FALSE);
|
||
}
|
||
|
||
//
|
||
// If the Video Adapter initialization failed, then we can not make INT 10 calls.
|
||
//
|
||
|
||
if (BiosCommand == 0x10 && HalpEnableInt10Calls == FALSE) {
|
||
return(FALSE);
|
||
}
|
||
|
||
if (HalpUseFirmwareX86Emulator == TRUE) {
|
||
|
||
//
|
||
// Make private vector call to the emulator in the firmware.
|
||
//
|
||
|
||
Arguments.pEAX = *Eax;
|
||
Arguments.pEBX = *Ebx;
|
||
Arguments.pECX = *Ecx;
|
||
Arguments.pEDX = *Edx;
|
||
Arguments.pESI = *Esi;
|
||
Arguments.pEDI = *Edi;
|
||
Arguments.pEBP = *Ebp;
|
||
Arguments.pES = 0;
|
||
Arguments.pDS = 0;
|
||
Arguments.pFlags = 0;
|
||
|
||
HalpAllocateArcsResources();
|
||
|
||
VendorX86ExecuteInt((USHORT)BiosCommand,&Arguments);
|
||
|
||
HalpFreeArcsResources();
|
||
|
||
*Eax = Arguments.pEAX;
|
||
*Ebx = Arguments.pEBX;
|
||
*Ecx = Arguments.pECX;
|
||
*Edx = Arguments.pEDX;
|
||
*Esi = Arguments.pESI;
|
||
*Edi = Arguments.pEDI;
|
||
*Ebp = Arguments.pEBP;
|
||
|
||
}
|
||
else {
|
||
|
||
#ifdef ENABLE_HAL_X86_EMULATOR
|
||
|
||
//
|
||
// Make call to emulator build into HAL
|
||
//
|
||
|
||
Context.Eax = *Eax;
|
||
Context.Ebx = *Ebx;
|
||
Context.Ecx = *Ecx;
|
||
Context.Edx = *Edx;
|
||
Context.Esi = *Esi;
|
||
Context.Edi = *Edi;
|
||
Context.Ebp = *Ebp;
|
||
|
||
if (x86BiosExecuteInterrupt((UCHAR)BiosCommand, &Context, NULL, NULL) != XM_SUCCESS) {
|
||
return FALSE;
|
||
}
|
||
|
||
*Eax = Context.Eax;
|
||
*Ebx = Context.Ebx;
|
||
*Ecx = Context.Ecx;
|
||
*Edx = Context.Edx;
|
||
*Esi = Context.Esi;
|
||
*Edi = Context.Edi;
|
||
*Ebp = Context.Ebp;
|
||
|
||
#endif
|
||
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
#ifdef ENABLE_HAL_X86_EMULATOR
|
||
|
||
ULONG
|
||
x86BiosReadIoSpace (
|
||
IN XM_OPERATION_DATATYPE DataType,
|
||
IN USHORT PortNumber
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function reads from emulated I/O space.
|
||
|
||
Arguments:
|
||
|
||
DataType - Supplies the datatype for the read operation.
|
||
|
||
PortNumber - Supplies the port number in I/O space to read from.
|
||
|
||
Return Value:
|
||
|
||
The value read from I/O space is returned as the function value.
|
||
|
||
N.B. If an aligned operation is specified, then the individual
|
||
bytes are read from the specified port one at a time and
|
||
assembled into the specified datatype.
|
||
|
||
--*/
|
||
|
||
{
|
||
|
||
ULONG Result;
|
||
ULONG PciBusNumber;
|
||
PCI_SLOT_NUMBER SlotNumber;
|
||
|
||
union {
|
||
PUCHAR Byte;
|
||
PUSHORT Word;
|
||
PULONG Long;
|
||
} u;
|
||
|
||
//
|
||
// Compute port address and read port.
|
||
//
|
||
|
||
//
|
||
// If PortNumber is in ISA Motherboard space, then overide the base address of
|
||
// the IO space with ISA space, otherwise, use the base address passed in on
|
||
// initialization.
|
||
//
|
||
|
||
if (PortNumber < 0x1000 && ((PortNumber & 0x3ff) < 0x100)) {
|
||
u.Long = (PULONG)((ULONG)HalpEisaControlBase[0] + PortNumber);
|
||
} else {
|
||
u.Long = (PULONG)(x86BiosIoSpace + PortNumber);
|
||
}
|
||
|
||
if (DataType == BYTE_DATA) {
|
||
Result = READ_REGISTER_UCHAR(u.Byte);
|
||
|
||
} else if (DataType == LONG_DATA) {
|
||
|
||
//
|
||
// If PortNumber is attempting to access the PCI config registers defined for X86 systems,
|
||
// intercept them, and make the appropriate HAL call to get the PCI confoguration data.
|
||
//
|
||
|
||
if (PortNumber == 0xcf8) {
|
||
Result = HalpPciConfigAddress;
|
||
} else if (PortNumber == 0xcfc && (HalpPciConfigAddress & 0x80000000)) {
|
||
PciBusNumber = (HalpPciConfigAddress >> 16) & 0xff;
|
||
SlotNumber.u.AsULONG = 0;
|
||
SlotNumber.u.bits.DeviceNumber = (HalpPciConfigAddress >> 11) & 0x1f;
|
||
SlotNumber.u.bits.FunctionNumber = (HalpPciConfigAddress >> 8) & 0x07;
|
||
HalGetBusDataByOffset (PCIConfiguration,
|
||
PciBusNumber,
|
||
SlotNumber.u.AsULONG,
|
||
&Result,
|
||
HalpPciConfigAddress & 0xfc,
|
||
4
|
||
);
|
||
|
||
} else {
|
||
if (((ULONG)u.Long & 0x3) != 0) {
|
||
Result = (READ_REGISTER_UCHAR(u.Byte + 0)) |
|
||
(READ_REGISTER_UCHAR(u.Byte + 1) << 8) |
|
||
(READ_REGISTER_UCHAR(u.Byte + 2) << 16) |
|
||
(READ_REGISTER_UCHAR(u.Byte + 3) << 24);
|
||
|
||
} else {
|
||
Result = READ_REGISTER_ULONG(u.Long);
|
||
}
|
||
}
|
||
|
||
} else {
|
||
if (((ULONG)u.Word & 0x1) != 0) {
|
||
Result = (READ_REGISTER_UCHAR(u.Byte + 0)) |
|
||
(READ_REGISTER_UCHAR(u.Byte + 1) << 8);
|
||
|
||
} else {
|
||
Result = READ_REGISTER_USHORT(u.Word);
|
||
}
|
||
}
|
||
|
||
return Result;
|
||
}
|
||
|
||
VOID
|
||
x86BiosWriteIoSpace (
|
||
IN XM_OPERATION_DATATYPE DataType,
|
||
IN USHORT PortNumber,
|
||
IN ULONG Value
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function write to emulated I/O space.
|
||
|
||
N.B. If an aligned operation is specified, then the individual
|
||
bytes are written to the specified port one at a time.
|
||
|
||
Arguments:
|
||
|
||
DataType - Supplies the datatype for the write operation.
|
||
|
||
PortNumber - Supplies the port number in I/O space to write to.
|
||
|
||
Value - Supplies the value to write.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG PciBusNumber;
|
||
PCI_SLOT_NUMBER SlotNumber;
|
||
|
||
union {
|
||
PUCHAR Byte;
|
||
PUSHORT Word;
|
||
PULONG Long;
|
||
} u;
|
||
|
||
//
|
||
// Compute port address and read port.
|
||
//
|
||
|
||
//
|
||
// If PortNumber is in ISA Motherboard space, then overide the base address of
|
||
// the IO space with ISA space, otherwise, use the base address passed in on
|
||
// initialization.
|
||
//
|
||
|
||
if (PortNumber < 0x1000 && ((PortNumber & 0x3ff) < 0x100)) {
|
||
u.Long = (PULONG)((ULONG)HalpEisaControlBase[0] + PortNumber);
|
||
} else {
|
||
u.Long = (PULONG)(x86BiosIoSpace + PortNumber);
|
||
}
|
||
|
||
if (DataType == BYTE_DATA) {
|
||
WRITE_REGISTER_UCHAR(u.Byte, (UCHAR)Value);
|
||
|
||
} else if (DataType == LONG_DATA) {
|
||
|
||
//
|
||
// If PortNumber is attempting to access the PCI config registers defined for X86 systems,
|
||
// intercept them, and make the appropriate HAL call to get the PCI confoguration data.
|
||
//
|
||
|
||
if (PortNumber == 0xcf8) {
|
||
HalpPciConfigAddress = Value;
|
||
} else if (PortNumber == 0xcfc) {
|
||
PciBusNumber = (HalpPciConfigAddress >> 16) & 0xff;
|
||
SlotNumber.u.AsULONG = 0;
|
||
SlotNumber.u.bits.DeviceNumber = (HalpPciConfigAddress >> 11) & 0x1f;
|
||
SlotNumber.u.bits.FunctionNumber = (HalpPciConfigAddress >> 8) & 0x07;
|
||
HalSetBusDataByOffset (PCIConfiguration,
|
||
PciBusNumber,
|
||
SlotNumber.u.AsULONG,
|
||
&Value,
|
||
HalpPciConfigAddress & 0xfc,
|
||
4
|
||
);
|
||
|
||
} else {
|
||
if (((ULONG)u.Long & 0x3) != 0) {
|
||
WRITE_REGISTER_UCHAR(u.Byte + 0, (UCHAR)(Value));
|
||
WRITE_REGISTER_UCHAR(u.Byte + 1, (UCHAR)(Value >> 8));
|
||
WRITE_REGISTER_UCHAR(u.Byte + 2, (UCHAR)(Value >> 16));
|
||
WRITE_REGISTER_UCHAR(u.Byte + 3, (UCHAR)(Value >> 24));
|
||
|
||
} else {
|
||
WRITE_REGISTER_ULONG(u.Long, Value);
|
||
}
|
||
}
|
||
|
||
} else {
|
||
if (((ULONG)u.Word & 0x1) != 0) {
|
||
WRITE_REGISTER_UCHAR(u.Byte + 0, (UCHAR)(Value));
|
||
WRITE_REGISTER_UCHAR(u.Byte + 1, (UCHAR)(Value >> 8));
|
||
|
||
} else {
|
||
WRITE_REGISTER_USHORT(u.Word, (USHORT)Value);
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
#endif
|