able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/boot/efi/port.c

1262 lines
34 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
port.c
Abstract:
This modules implements com port code to support reading/writing from com ports.
Author:
Allen M. Kay (allen.m.kay@intel.com) 27-Jan-2000
Revision History:
--*/
#include "bldr.h"
#include "string.h"
#include "stdlib.h"
#include "stdio.h"
#include "ntverp.h"
#include "efi.h"
#include "efip.h"
#include "bldria64.h"
#include "acpitabl.h"
#include "extern.h"
#if DBG
extern EFI_SYSTEM_TABLE *EfiST;
#define DBG_TRACE(_X) EfiST->ConOut->OutputString(EfiST->ConOut, (_X))
#else
#define DBG_TRACE(_X)
#endif // for FORCE_CD_BOOT
//
// Headless boot defines
//
ULONG BlTerminalDeviceId = 0;
BOOLEAN BlTerminalConnected = FALSE;
ULONG BlTerminalDelay = 0;
HEADLESS_LOADER_BLOCK LoaderRedirectionInformation;
//
// Define COM Port registers.
//
#define COM_DAT 0x00
#define COM_IEN 0x01 // interrupt enable register
#define COM_LCR 0x03 // line control registers
#define COM_MCR 0x04 // modem control reg
#define COM_LSR 0x05 // line status register
#define COM_MSR 0x06 // modem status register
#define COM_DLL 0x00 // divisor latch least sig
#define COM_DLM 0x01 // divisor latch most sig
#define COM_BI 0x10
#define COM_FE 0x08
#define COM_PE 0x04
#define COM_OE 0x02
#define LC_DLAB 0x80 // divisor latch access bit
#define CLOCK_RATE 0x1C200 // USART clock rate
#define MC_DTRRTS 0x03 // Control bits to assert DTR and RTS
#define MS_DSRCTSCD 0xB0 // Status bits for DSR, CTS and CD
#define MS_CD 0x80
#define COM_OUTRDY 0x20
#define COM_DATRDY 0x01
//
// Define Serial IO Protocol
//
EFI_GUID EfiSerialIoProtocol = SERIAL_IO_PROTOCOL;
SERIAL_IO_INTERFACE *SerialIoInterface;
//
// Define debugger port initial state.
//
typedef struct _CPPORT {
PUCHAR Address;
ULONG Baud;
USHORT Flags;
} CPPORT, *PCPPORT;
#define PORT_DEFAULTRATE 0x0001 // baud rate not specified, using default
#define PORT_MODEMCONTROL 0x0002 // using modem controls
CPPORT Port[4] = {
{NULL, 0, PORT_DEFAULTRATE},
{NULL, 0, PORT_DEFAULTRATE},
{NULL, 0, PORT_DEFAULTRATE},
{NULL, 0, PORT_DEFAULTRATE}
};
//
// This is how we find table information from
// the ACPI table index.
//
extern PDESCRIPTION_HEADER
BlFindACPITable(
IN PCHAR TableName,
IN ULONG TableLength
);
LOGICAL
BlRetrieveBIOSRedirectionInformation(
VOID
)
/*++
Routine Description:
This functions retrieves the COM port information from the ACPI
table.
Arguments:
We'll be filling in the LoaderRedirectionInformation structure.
Returned Value:
TRUE - If a debug port is found.
--*/
{
PDEBUG_PORT_TABLE pPortTable = NULL;
LOGICAL ReturnValue = FALSE;
LOGICAL FoundIt = FALSE;
EFI_DEVICE_PATH *DevicePath = NULL;
EFI_DEVICE_PATH *RootDevicePath = NULL;
EFI_DEVICE_PATH *StartOfDevicePath = NULL;
EFI_STATUS Status = EFI_UNSUPPORTED;
ACPI_HID_DEVICE_PATH *AcpiDevicePath;
UART_DEVICE_PATH *UartDevicePath;
EFI_DEVICE_PATH_ALIGNED DevicePathAligned;
UINTN reqd;
EFI_GUID EfiGlobalVariable = EFI_GLOBAL_VARIABLE;
PUCHAR CurrentAddress = NULL;
UCHAR Checksum;
ULONG i;
ULONG CheckLength;
pPortTable = (PDEBUG_PORT_TABLE)BlFindACPITable( "SPCR",
sizeof(DEBUG_PORT_TABLE) );
if( pPortTable ) {
//
// generate a checksum for later validation.
//
CurrentAddress = (PUCHAR)pPortTable;
CheckLength = pPortTable->Header.Length;
Checksum = 0;
for( i = 0; i < CheckLength; i++ ) {
Checksum += CurrentAddress[i];
}
if(
// checksum is okay?
(Checksum == 0) &&
// device address defined?
((UCHAR UNALIGNED *)pPortTable->BaseAddress.Address.QuadPart != (UCHAR *)NULL) &&
// he better be in system or memory I/O
// note: 0 - systemI/O
// 1 - memory mapped I/O
((pPortTable->BaseAddress.AddressSpaceID == 0) ||
(pPortTable->BaseAddress.AddressSpaceID == 1))
) {
if( pPortTable->BaseAddress.AddressSpaceID == 0 ) {
LoaderRedirectionInformation.IsMMIODevice = TRUE;
} else {
LoaderRedirectionInformation.IsMMIODevice = FALSE;
}
//
// We got the table. Now dig out the information we want.
// See definitiion of DEBUG_PORT_TABLE (acpitabl.h)
//
LoaderRedirectionInformation.UsedBiosSettings = TRUE;
LoaderRedirectionInformation.PortNumber = 3;
LoaderRedirectionInformation.PortAddress = (UCHAR UNALIGNED *)(pPortTable->BaseAddress.Address.QuadPart);
if( pPortTable->BaudRate == 7 ) {
LoaderRedirectionInformation.BaudRate = BD_115200;
} else if( pPortTable->BaudRate == 6 ) {
LoaderRedirectionInformation.BaudRate = BD_57600;
} else if( pPortTable->BaudRate == 4 ) {
LoaderRedirectionInformation.BaudRate = BD_19200;
} else {
LoaderRedirectionInformation.BaudRate = BD_9600;
}
LoaderRedirectionInformation.Parity = pPortTable->Parity;
LoaderRedirectionInformation.StopBits = pPortTable->StopBits;
LoaderRedirectionInformation.TerminalType = pPortTable->TerminalType;
//
// If this is a new DEBUG_PORT_TABLE, then it's got the PCI device
// information.
//
if( pPortTable->Header.Length >= sizeof(DEBUG_PORT_TABLE) ) {
LoaderRedirectionInformation.PciDeviceId = *((USHORT UNALIGNED *)(&pPortTable->PciDeviceId));
LoaderRedirectionInformation.PciVendorId = *((USHORT UNALIGNED *)(&pPortTable->PciVendorId));
LoaderRedirectionInformation.PciBusNumber = (UCHAR)pPortTable->PciBusNumber;
LoaderRedirectionInformation.PciSlotNumber = (UCHAR)pPortTable->PciSlotNumber;
LoaderRedirectionInformation.PciFunctionNumber = (UCHAR)pPortTable->PciFunctionNumber;
LoaderRedirectionInformation.PciFlags = *((ULONG UNALIGNED *)(&pPortTable->PciFlags));
} else {
//
// There's no PCI device information in this table.
//
LoaderRedirectionInformation.PciDeviceId = (USHORT)0xFFFF;
LoaderRedirectionInformation.PciVendorId = (USHORT)0xFFFF;
LoaderRedirectionInformation.PciBusNumber = 0;
LoaderRedirectionInformation.PciSlotNumber = 0;
LoaderRedirectionInformation.PciFunctionNumber = 0;
LoaderRedirectionInformation.PciFlags = 0;
}
return TRUE;
}
}
//
// We didn't get anything from the ACPI table. Look
// for the ConsoleOutHandle and see if someone configured
// the EFI firmware to redirect. If so, we can pickup
// those settings and carry them forward.
//
//
// EFI requires all calls in physical mode.
//
FlipToPhysical();
DBG_TRACE( L"BlRetrieveBIOSRedirectionInformation: didn't find SPCR table\r\n");
FoundIt = FALSE;
//
// Get the CONSOLE Device Paths.
//
reqd = 0;
Status = EfiST->RuntimeServices->GetVariable(
L"ConOut",
&EfiGlobalVariable,
NULL,
&reqd,
NULL );
if( Status == EFI_BUFFER_TOO_SMALL ) {
DBG_TRACE( L"BlRetrieveBIOSRedirectionInformation: GetVariable(ConOut) success\r\n");
#ifndef DONT_USE_EFI_MEMORY
Status = EfiBS->AllocatePool(
EfiLoaderData,
reqd,
(VOID **) &StartOfDevicePath);
if( Status != EFI_SUCCESS ) {
WCHAR DebugBuffer[120];
wsprintf( DebugBuffer, L"BlRetreiveBIOSRedirectionInformation: AllocatePool returned (%x)\r\n", Status );
DBG_TRACE( DebugBuffer );
StartOfDevicePath = NULL;
}
#else
//
// go back to virtual mode to allocate some memory
//
FlipToVirtual();
StartOfDevicePath = BlAllocateHeapAligned( (ULONG)reqd );
if( StartOfDevicePath ) {
//
// convert the address into a physical address
//
StartOfDevicePath = (EFI_DEVICE_PATH *) ((ULONGLONG)StartOfDevicePath & ~KSEG0_BASE);
}
//
// go back into physical mode
//
FlipToPhysical();
#endif
if (StartOfDevicePath) {
DBG_TRACE( L"BlRetrieveBIOSRedirectionInformation: allocated pool for variable\r\n");
Status = EfiST->RuntimeServices->GetVariable(
L"ConOut",
&EfiGlobalVariable,
NULL,
&reqd,
(VOID *)StartOfDevicePath);
DBG_TRACE( L"BlRetrieveBIOSRedirectionInformation: GetVariable returned\r\n");
} else {
DBG_TRACE( L"BlRetrieveBIOSRedirectionInformation: Failed to allocate memory for CONOUT variable.\r\n");
}
} else {
WCHAR DebugBuffer[120];
wsprintf( DebugBuffer, L"BlRetreiveBIOSRedirectionInformation: GetVariable returned (%x)\r\n", Status );
DBG_TRACE( DebugBuffer );
Status = EFI_BAD_BUFFER_SIZE;
}
if( !EFI_ERROR(Status) ) {
DBG_TRACE( L"BlRetrieveBIOSRedirectionInformation: retrieved ConOut successfully\r\n");
//
// Preserve StartOfDevicePath so we can free the memory later.
//
DevicePath = StartOfDevicePath;
EfiAlignDp(&DevicePathAligned,
DevicePath,
DevicePathNodeLength(DevicePath));
//
// Keep looking until we get to the end of the entire Device Path.
//
while( !((DevicePathAligned.DevPath.Type == END_DEVICE_PATH_TYPE) &&
(DevicePathAligned.DevPath.SubType == END_ENTIRE_DEVICE_PATH_SUBTYPE)) &&
(!FoundIt) ) {
//
// Remember the address he's holding. This is the root
// of this device path and we may need to look at this
// guy again if down the path we find a UART.
//
RootDevicePath = DevicePath;
//
// Keep looking until we get to the end of this subpath.
//
while( !((DevicePathAligned.DevPath.Type == END_DEVICE_PATH_TYPE) &&
((DevicePathAligned.DevPath.SubType == END_ENTIRE_DEVICE_PATH_SUBTYPE) ||
(DevicePathAligned.DevPath.SubType == END_INSTANCE_DEVICE_PATH_SUBTYPE))) ) {
if( (DevicePathAligned.DevPath.Type == MESSAGING_DEVICE_PATH) &&
(DevicePathAligned.DevPath.SubType == MSG_UART_DP) &&
(FoundIt == FALSE) ) {
//
// We got a UART. Pickup the settings.
//
UartDevicePath = (UART_DEVICE_PATH *)&DevicePathAligned;
LoaderRedirectionInformation.BaudRate = (ULONG)UartDevicePath->BaudRate;
LoaderRedirectionInformation.Parity = (BOOLEAN)UartDevicePath->Parity;
LoaderRedirectionInformation.StopBits = (UCHAR)UartDevicePath->StopBits;
//
// Fixup BaudRate if necessary. If it's 0, then we're
// supposed to use the default for this h/w. We're going
// to override to 9600 though.
//
if( LoaderRedirectionInformation.BaudRate == 0 ) {
LoaderRedirectionInformation.BaudRate = BD_9600;
}
if( LoaderRedirectionInformation.BaudRate > BD_115200 ) {
LoaderRedirectionInformation.BaudRate = BD_115200;
}
DBG_TRACE(L"BlRetrieveBIOSRedirectionInformation: found a UART\r\n");
//
// Remember that we found a UART and quit searching.
//
FoundIt = TRUE;
}
if( (FoundIt == TRUE) && // we already found a UART, so we're on the right track.
(DevicePathAligned.DevPath.Type == MESSAGING_DEVICE_PATH) &&
(DevicePathAligned.DevPath.SubType == MSG_VENDOR_DP) ) {
VENDOR_DEVICE_PATH *VendorDevicePath = (VENDOR_DEVICE_PATH *)&DevicePathAligned;
EFI_GUID PcAnsiGuid = DEVICE_PATH_MESSAGING_PC_ANSI;
//
// See if the UART is a VT100 or ANSI or whatever.
//
if( memcmp( &VendorDevicePath->Guid, &PcAnsiGuid, sizeof(EFI_GUID)) == 0 ) {
LoaderRedirectionInformation.TerminalType = 3;
} else {
// Default to VT100
LoaderRedirectionInformation.TerminalType = 0;
}
}
//
// Get the next structure in our packed array.
//
DevicePath = NextDevicePathNode( DevicePath );
EfiAlignDp(&DevicePathAligned,
DevicePath,
DevicePathNodeLength(DevicePath));
}
//
// Do we need to keep going? Check to make sure we're not at the
// end of the entire packed array of device paths.
//
if( !((DevicePathAligned.DevPath.Type == END_DEVICE_PATH_TYPE) &&
(DevicePathAligned.DevPath.SubType == END_ENTIRE_DEVICE_PATH_SUBTYPE)) ) {
//
// Yes. Get the next entry.
//
DevicePath = NextDevicePathNode( DevicePath );
EfiAlignDp(&DevicePathAligned,
DevicePath,
DevicePathNodeLength(DevicePath));
}
}
} else {
DBG_TRACE( L"BlRetrieveBIOSRedirectionInformation: failed to get CONOUT variable\r\n");
}
if( FoundIt ) {
//
// We found a UART, but we were already too far down the list
// in the device map to get the address, which is really what
// we're after. Start looking at the device map again from the
// root of the path where we found the UART.
//
DevicePath = RootDevicePath;
//
// Reset this guy so we'll know if we found a reasonable
// ACPI_DEVICE_PATH entry.
//
FoundIt = FALSE;
EfiAlignDp(&DevicePathAligned,
RootDevicePath,
DevicePathNodeLength(DevicePath));
//
// Keep looking until we get to the end, or until we run
// into our UART again.
//
while( (DevicePathAligned.DevPath.Type != END_DEVICE_PATH_TYPE) &&
(!FoundIt) ) {
if( DevicePathAligned.DevPath.Type == ACPI_DEVICE_PATH ) {
//
// Remember the address he's holding.
//
AcpiDevicePath = (ACPI_HID_DEVICE_PATH *)&DevicePathAligned;
if( AcpiDevicePath->UID ) {
LoaderRedirectionInformation.PortAddress = (PUCHAR)ULongToPtr(AcpiDevicePath->UID);
LoaderRedirectionInformation.PortNumber = 3;
FoundIt = TRUE;
}
}
//
// Get the next structure in our packed array.
//
DevicePath = NextDevicePathNode( DevicePath );
EfiAlignDp(&DevicePathAligned,
DevicePath,
DevicePathNodeLength(DevicePath));
}
}
if( FoundIt ) {
DBG_TRACE( L"BlRetrieveBIOSRedirectionInformation: returning TRUE\r\n");
ReturnValue = TRUE;
}
#ifndef DONT_USE_EFI_MEMORY
//
// Free the memory we allocated for StartOfDevicePath.
//
if( StartOfDevicePath != NULL ) {
EfiBS->FreePool( (VOID *)StartOfDevicePath );
}
#endif
//
// Restore the processor to virtual mode.
//
FlipToVirtual();
return( ReturnValue );
}
LOGICAL
BlPortInitialize(
IN ULONG BaudRate,
IN ULONG PortNumber,
IN PUCHAR PortAddress OPTIONAL,
IN BOOLEAN ReInitialize,
OUT PULONG BlFileId
)
/*++
Routine Description:
This functions initializes the com port.
Arguments:
BaudRate - Supplies an optional baud rate.
PortNumber - supplies an optinal port number.
ReInitialize - Set to TRUE if we already have this port open, but for some
reason need to completely reset the port. Otw it should be FALSE.
BlFileId - A place to store a fake file Id, if successful.
Returned Value:
TRUE - If a debug port is found, and BlFileId will point to a location within Port[].
--*/
{
UCHAR DebugMessage[80];
LOGICAL Found = FALSE;
ULONG HandleCount;
EFI_HANDLE *SerialIoHandles;
EFI_HANDLE DeviceHandle = NULL;
EFI_DEVICE_PATH *DevicePath;
EFI_DEVICE_PATH_ALIGNED DevicePathAligned;
ACPI_HID_DEVICE_PATH *AcpiDevicePath;
ULONG i;
ULONG Control;
EFI_STATUS Status;
ARC_STATUS ArcStatus;
ArcStatus = BlGetEfiProtocolHandles(
&EfiSerialIoProtocol,
&SerialIoHandles,
&HandleCount
);
if (ArcStatus != ESUCCESS) {
return FALSE;
}
//
// If the baud rate is not specified, then default the baud rate to 19.2.
//
if (BaudRate == 0) {
BaudRate = BD_19200;
}
//
// If the user didn't send us a port address, then
// guess based on the COM port number.
//
if( PortAddress == 0 ) {
switch (PortNumber) {
case 1:
PortAddress = (PUCHAR)COM1_PORT;
break;
case 2:
PortAddress = (PUCHAR)COM2_PORT;
break;
case 3:
PortAddress = (PUCHAR)COM3_PORT;
break;
default:
PortNumber = 4;
PortAddress = (PUCHAR)COM4_PORT;
}
}
//
// EFI requires all calls in physical mode.
//
FlipToPhysical();
//
// Get the device path
//
for (i = 0; i < HandleCount; i++) {
DBG_TRACE( L"About to HandleProtocol\r\n");
Status = EfiBS->HandleProtocol (
SerialIoHandles[i],
&EfiDevicePathProtocol,
&DevicePath
);
if (EFI_ERROR(Status)) {
DBG_TRACE( L"HandleProtocol failed\r\n");
Found = FALSE;
goto e0;
}
EfiAlignDp(&DevicePathAligned,
DevicePath,
DevicePathNodeLength(DevicePath));
AcpiDevicePath = (ACPI_HID_DEVICE_PATH *) &DevicePathAligned;
if (PortNumber = 0) {
Found = TRUE;
break;
} else if (AcpiDevicePath->UID == PtrToUlong(PortAddress)) {
Found = TRUE;
break;
}
}
if (Found == TRUE) {
DBG_TRACE( L"found the port device\r\n");
//
// Check if the port is already in use, and this is a first init.
//
if (!ReInitialize && (Port[PortNumber].Address != NULL)) {
DBG_TRACE( L"found the port device but it's already in use\r\n");
Found = FALSE;
goto e0;
}
//
// Check if someone tries to reinit a port that is not open.
//
if (ReInitialize && (Port[PortNumber].Address == NULL)) {
DBG_TRACE( L"found the port device but we're reinitializing a port that hasn't been opened\r\n");
Found = FALSE;
goto e0;
}
DBG_TRACE( L"about to HandleProtocol for SerialIO\r\n");
//
// Get the interface for the serial IO protocol.
//
Status = EfiBS->HandleProtocol(SerialIoHandles[i],
&EfiSerialIoProtocol,
&SerialIoInterface
);
if (EFI_ERROR(Status)) {
DBG_TRACE( L"HandleProtocol for SerialIO failed\r\n");
Found = FALSE;
goto e0;
}
Status = SerialIoInterface->SetAttributes(SerialIoInterface,
BaudRate,
0,
0,
DefaultParity,
0,
DefaultStopBits
);
if (EFI_ERROR(Status)) {
DBG_TRACE( L"SerialIO: SetAttributes failed\r\n");
Found = FALSE;
goto e0;
}
Control = EFI_SERIAL_DATA_TERMINAL_READY | EFI_SERIAL_CLEAR_TO_SEND;
Status = SerialIoInterface->SetControl(SerialIoInterface,
Control
);
if (EFI_ERROR(Status)) {
DBG_TRACE( L"SerialIO: SetControl failed\r\n");
Found = FALSE;
goto e0;
}
} else {
DBG_TRACE( L"didn't find a port device\r\n");
Found = FALSE;
goto e0;
}
//
// Initialize Port[] structure.
//
Port[PortNumber].Address = PortAddress;
Port[PortNumber].Baud = BaudRate;
*BlFileId = PortNumber;
DBG_TRACE( L"success, we're done.\r\n");
e0:
//
// Restore the processor to virtual mode.
//
FlipToVirtual();
BlFreeDescriptor( (ULONG)((ULONGLONG)SerialIoHandles >> PAGE_SHIFT) );
return Found;
}
VOID
BlInitializeHeadlessPort(
VOID
)
/*++
Routine Description:
Does x86-specific initialization of a dumb terminal connected to a serial port. Currently,
it assumes baud rate and com port are pre-initialized, but this can be changed in the future
by reading the values from boot.ini or someplace.
Arguments:
None.
Return Value:
None.
--*/
{
UINTN reqd;
EFI_GUID EfiGlobalVariable = EFI_GLOBAL_VARIABLE;
EFI_STATUS Status = EFI_UNSUPPORTED;
if( (LoaderRedirectionInformation.PortNumber == 0) ||
!(LoaderRedirectionInformation.PortAddress) ) {
//
// This means that no one has filled in the LoaderRedirectionInformation
// structure, which means that we aren't redirecting right now.
// See if the BIOS was redirecting. If so, pick up those settings
// and use them.
//
BlRetrieveBIOSRedirectionInformation();
if( LoaderRedirectionInformation.PortNumber ) {
//
// We don't need to even bother telling anyone else in the
// loader that we're going to need to redirect because if
// EFI is redirecting, then the loader will be redirecting (as
// it's just an EFI app).
//
BlTerminalConnected = FALSE;
//
// We really need to make sure there's an address associated with
// this port and not just a port number.
//
if( LoaderRedirectionInformation.PortAddress == NULL ) {
switch( LoaderRedirectionInformation.PortNumber ) {
case 4:
LoaderRedirectionInformation.PortAddress = (PUCHAR)COM4_PORT;
break;
case 3:
LoaderRedirectionInformation.PortAddress = (PUCHAR)COM3_PORT;
break;
case 2:
LoaderRedirectionInformation.PortAddress = (PUCHAR)COM2_PORT;
break;
case 1:
default:
LoaderRedirectionInformation.PortAddress = (PUCHAR)COM1_PORT;
break;
}
}
//
// Load in the machine's GUID
//
FlipToPhysical();
reqd = sizeof(GUID);
Status = EfiST->RuntimeServices->GetVariable( L"SystemGUID",
&EfiGlobalVariable,
NULL,
&reqd,
(VOID *)&LoaderRedirectionInformation.SystemGUID);
FlipToVirtual();
} else {
BlTerminalConnected = FALSE;
}
}
}
LOGICAL
BlTerminalAttached(
IN ULONG DeviceId
)
/*++
Routine Description:
This routine will attempt to discover if a terminal is attached.
Arguments:
DeviceId - Value returned by BlPortInitialize()
Return Value:
TRUE - Port seems to have something attached.
FALSE - Port doesn't seem to have anything attached.
--*/
{
ULONG Control;
ULONG Flags;
EFI_STATUS Status;
BOOLEAN ReturnValue;
//
// EFI requires all calls in physical mode.
//
FlipToPhysical();
Status = SerialIoInterface->GetControl(SerialIoInterface,
&Control
);
if (EFI_ERROR(Status)) {
FlipToVirtual();
return FALSE;
}
Flags = EFI_SERIAL_DATA_SET_READY |
EFI_SERIAL_CLEAR_TO_SEND |
EFI_SERIAL_CARRIER_DETECT;
ReturnValue = ((Control & Flags) == Flags);
//
// Restore the processor to virtual mode.
//
FlipToVirtual();
return ReturnValue;
}
VOID
BlSetHeadlessRestartBlock(
IN PTFTP_RESTART_BLOCK RestartBlock
)
/*++
Routine Description:
This routine will fill in the areas of the restart block that are appropriate
for the headless server effort.
Arguments:
RestartBlock - The magic structure for holding restart information from oschoice
to setupldr.
Return Value:
None.
--*/
{
if( LoaderRedirectionInformation.PortNumber ) {
RestartBlock->HeadlessUsedBiosSettings = (ULONG)LoaderRedirectionInformation.UsedBiosSettings;
RestartBlock->HeadlessPortNumber = (ULONG)LoaderRedirectionInformation.PortNumber;
RestartBlock->HeadlessPortAddress = (PUCHAR)LoaderRedirectionInformation.PortAddress;
RestartBlock->HeadlessBaudRate = (ULONG)LoaderRedirectionInformation.BaudRate;
RestartBlock->HeadlessParity = (ULONG)LoaderRedirectionInformation.Parity;
RestartBlock->HeadlessStopBits = (ULONG)LoaderRedirectionInformation.StopBits;
RestartBlock->HeadlessTerminalType = (ULONG)LoaderRedirectionInformation.TerminalType;
RestartBlock->HeadlessPciDeviceId = LoaderRedirectionInformation.PciDeviceId;
RestartBlock->HeadlessPciVendorId = LoaderRedirectionInformation.PciVendorId;
RestartBlock->HeadlessPciBusNumber = LoaderRedirectionInformation.PciBusNumber;
RestartBlock->HeadlessPciSlotNumber = LoaderRedirectionInformation.PciSlotNumber;
RestartBlock->HeadlessPciFunctionNumber = LoaderRedirectionInformation.PciFunctionNumber;
RestartBlock->HeadlessPciFlags = LoaderRedirectionInformation.PciFlags;
}
}
VOID
BlGetHeadlessRestartBlock(
IN PTFTP_RESTART_BLOCK RestartBlock,
IN BOOLEAN RestartBlockValid
)
/*++
Routine Description:
This routine will get all the information from a restart block
for the headless server effort.
Arguments:
RestartBlock - The magic structure for holding restart information from oschoice
to setupldr.
RestartBlockValid - Is this block valid (full of good info)?
Return Value:
None.
--*/
{
LoaderRedirectionInformation.UsedBiosSettings = (BOOLEAN)RestartBlock->HeadlessUsedBiosSettings;
LoaderRedirectionInformation.DataBits = 0;
LoaderRedirectionInformation.StopBits = (UCHAR)RestartBlock->HeadlessStopBits;
LoaderRedirectionInformation.Parity = (BOOLEAN)RestartBlock->HeadlessParity;
LoaderRedirectionInformation.BaudRate = (ULONG)RestartBlock->HeadlessBaudRate;;
LoaderRedirectionInformation.PortNumber = (ULONG)RestartBlock->HeadlessPortNumber;
LoaderRedirectionInformation.PortAddress = (PUCHAR)RestartBlock->HeadlessPortAddress;
LoaderRedirectionInformation.TerminalType = (UCHAR)RestartBlock->HeadlessTerminalType;
LoaderRedirectionInformation.PciDeviceId = (USHORT)RestartBlock->HeadlessPciDeviceId;
LoaderRedirectionInformation.PciVendorId = (USHORT)RestartBlock->HeadlessPciVendorId;
LoaderRedirectionInformation.PciBusNumber = (UCHAR)RestartBlock->HeadlessPciBusNumber;
LoaderRedirectionInformation.PciSlotNumber = (UCHAR)RestartBlock->HeadlessPciSlotNumber;
LoaderRedirectionInformation.PciFunctionNumber = (UCHAR)RestartBlock->HeadlessPciFunctionNumber;
LoaderRedirectionInformation.PciFlags = (ULONG)RestartBlock->HeadlessPciFlags;
}
ULONG
BlPortGetByte (
IN ULONG BlFileId,
OUT PUCHAR Input
)
/*++
Routine Description:
Fetch a byte from the port and return it.
Arguments:
BlFileId - The port to read from.
Input - Returns the data byte.
Return Value:
CP_GET_SUCCESS is returned if a byte is successfully read from the
kernel debugger line.
CP_GET_ERROR is returned if error encountered during reading.
CP_GET_NODATA is returned if timeout.
--*/
{
ULONGLONG BufferSize = 1;
EFI_STATUS Status;
//
// EFI requires all calls in physical mode.
//
FlipToPhysical();
Status = SerialIoInterface->Read(SerialIoInterface,
&BufferSize,
Input
);
//
// Restore the processor to virtual mode.
//
FlipToVirtual();
switch (Status) {
case EFI_SUCCESS:
return CP_GET_SUCCESS;
case EFI_TIMEOUT:
return CP_GET_NODATA;
default:
return CP_GET_ERROR;
}
}
VOID
BlPortPutByte (
IN ULONG BlFileId,
IN UCHAR Output
)
/*++
Routine Description:
Write a byte to the port.
Arguments:
BlFileId - The port to write to.
Output - Supplies the output data byte.
Return Value:
None.
--*/
{
ULONGLONG BufferSize = 1;
ULONG Control;
EFI_STATUS Status;
//
// EFI requires all calls in physical mode.
//
FlipToPhysical();
Status = SerialIoInterface->Write(SerialIoInterface,
&BufferSize,
&Output
);
//
// Restore the processor to virtual mode.
//
FlipToVirtual();
}
ULONG
BlPortPollByte (
IN ULONG BlFileId,
OUT PUCHAR Input
)
/*++
Routine Description:
Fetch a byte from the port and return it if one is available.
Arguments:
BlFileId - The port to poll.
Input - Returns the data byte.
Return Value:
CP_GET_SUCCESS is returned if a byte is successfully read.
CP_GET_ERROR is returned if error encountered during reading.
CP_GET_NODATA is returned if timeout.
--*/
{
ULONGLONG BufferSize = 1;
ULONG Control;
EFI_STATUS Status;
//
// EFI requires all calls in physical mode.
//
FlipToPhysical();
Status = SerialIoInterface->GetControl(SerialIoInterface,
&Control
);
if (EFI_ERROR(Status)) {
FlipToVirtual();
return CP_GET_ERROR;
}
if (Control & EFI_SERIAL_INPUT_BUFFER_EMPTY) {
FlipToVirtual();
return CP_GET_NODATA;
} else {
Status = SerialIoInterface->Read(SerialIoInterface,
&BufferSize,
Input
);
FlipToVirtual();
switch (Status) {
case EFI_SUCCESS:
return CP_GET_SUCCESS;
case EFI_TIMEOUT:
return CP_GET_NODATA;
default:
return CP_GET_ERROR;
}
}
}
ULONG
BlPortPollOnly (
IN ULONG BlFileId
)
/*++
Routine Description:
Check if a byte is available
Arguments:
BlFileId - The port to poll.
Return Value:
CP_GET_SUCCESS is returned if a byte is ready.
CP_GET_ERROR is returned if error encountered.
CP_GET_NODATA is returned if timeout.
--*/
{
EFI_STATUS Status;
ULONG Control;
ULONG RetVal;
//
// EFI requires all calls in physical mode.
//
FlipToPhysical();
Status = SerialIoInterface->GetControl(SerialIoInterface,
&Control
);
//
// Restore the processor to virtual mode.
//
FlipToVirtual();
switch (Status) {
case EFI_SUCCESS:
if (Control & EFI_SERIAL_INPUT_BUFFER_EMPTY)
return CP_GET_NODATA;
else
return CP_GET_SUCCESS;
case EFI_TIMEOUT:
return CP_GET_NODATA;
default:
return CP_GET_ERROR;
}
}
Reference in a new issue Copy permalink