/*++ 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; } }