/** @file Helper Routines that use a PXE-enabled NIC option ROM. Copyright (c) 1999 - 2018, Intel Corporation. All rights reserved.<BR> SPDX-License-Identifier: BSD-2-Clause-Patent **/ #include "BiosSnp16.h" #define TO_SEGMENT(x) ((UINT16) (RShiftU64 ((UINT32)(UINTN) (x), 4) & 0xF000)) #define TO_OFFSET(x) ((UINT16) ((UINT32)(UINTN) (x) & 0xFFFF)) #define PARAGRAPH_SIZE 0x10 #define IVT_BASE 0x00000000 #pragma pack(1) typedef struct { UINT16 Signature; ///< 0xaa55 UINT8 ROMlength; ///< size of this ROM in 512 byte blocks UINT8 InitEntryPoint[4]; ///< a jump to the initialization routine UINT8 Reserved[0xf]; ///< various UINT16 PxeRomIdOffset; ///< offset of UNDI, $BC$, or BUSD ROM ID structure UINT16 PcirHeaderOffset; ///< offset of PCI Expansion Header UINT16 PnpHeaderOffset; ///< offset of Plug and Play Expansion Header } OPTION_ROM_HEADER; #pragma pack() UINT32 CachedVectorAddress[0x100]; /** Cache Interrupt verctor address converted from IVT number. @param VectorNumber IVT number @retval EFI_SUCCESS Success to operation. **/ EFI_STATUS CacheVectorAddress ( UINT8 VectorNumber ) { UINT32 *Address; Address = (UINT32 *) ((UINTN) IVT_BASE + VectorNumber * 4); CachedVectorAddress[VectorNumber] = *Address; return EFI_SUCCESS; } /** Get interrupt vector address according to IVT number. @param VectorNumber Given IVT number @return cached interrupt vector address. **/ EFI_STATUS RestoreCachedVectorAddress ( UINT8 VectorNumber ) { UINT32 *Address; Address = (UINT32 *) ((UINTN) IVT_BASE + VectorNumber * 4); *Address = CachedVectorAddress[VectorNumber]; return EFI_SUCCESS; } /** Print Undi loader table. @param UndiLoaderStructure Point to Undi Loader table structure. **/ VOID Print_Undi_Loader_Table ( VOID *UndiLoaderStructure ) { UNDI_LOADER_T *DisplayPointer; DisplayPointer = (UNDI_LOADER_T *) UndiLoaderStructure; DEBUG ((DEBUG_NET, "Before Parsing the table contents, the table itself lives\n")); DEBUG ((DEBUG_NET, "\tat the address 0x%X\n\r", (UINT32)(UINTN) UndiLoaderStructure)); DEBUG ((DEBUG_NET, "\n\rStatus = 0x%X\n\r", DisplayPointer->Status)); DEBUG ((DEBUG_NET, "\t_AX_= 0x%X\n\r", DisplayPointer->Ax)); DEBUG ((DEBUG_NET, "\t_BX_= 0x%X\n\r", DisplayPointer->Bx)); DEBUG ((DEBUG_NET, "\t_DX_= 0x%X\n\r", DisplayPointer->Dx)); DEBUG ((DEBUG_NET, "\t_DI_= 0x%X\n\r", DisplayPointer->Di)); DEBUG ((DEBUG_NET, "\t_ES_= 0x%X\n\r", DisplayPointer->Es)); DEBUG ((DEBUG_NET, "\tUNDI_DS= 0x%X\n\r", DisplayPointer->Undi_Ds)); DEBUG ((DEBUG_NET, "\tUNDI_CS= 0x%X\n\r", DisplayPointer->Undi_Cs)); DEBUG ((DEBUG_NET, "\tPXEptr:SEG= 0x%X\n\r", (UINT16) DisplayPointer->PXEptr.Segment)); DEBUG ((DEBUG_NET, "\tPXEptr:OFF= 0x%X\n\r", (UINT16) DisplayPointer->PXEptr.Offset)); DEBUG ((DEBUG_NET, "\tPXENVptr:SEG= 0x%X\n\r", (UINT16) DisplayPointer->PXENVptr.Segment)); DEBUG ((DEBUG_NET, "\tPXENVptr:OFF= 0x%X\n\r", (UINT16) DisplayPointer->PXENVptr.Offset)); } /** Simple table dumper. The ROMID table is necessary in order to effect the "Early UNDI" trick. Herein, the UNDI layer can be loaded in the pre-boot phase without having to download a Network Boot Program across the wire. It is required in the implementation in that we are not using PXE. @param RomIDStructure Point to RomID structure. **/ VOID Print_ROMID_Table ( IN VOID *RomIDStructure ) { UNDI_ROMID_T *DisplayPointer; DisplayPointer = (UNDI_ROMID_T *) RomIDStructure; DEBUG ((DEBUG_NET, "Before Parsing the table contents, the table itself lives\n")); DEBUG ((DEBUG_NET, "\tat the address 0x%X\n\r", (UINT32)(UINTN) RomIDStructure)); DEBUG ( (DEBUG_NET, "\n\rROMID %c%c%c%c\n\r", DisplayPointer->Signature[0], DisplayPointer->Signature[1], DisplayPointer->Signature[2], DisplayPointer->Signature[3]) ); DEBUG ( (DEBUG_NET, "Length of this structure in bytes = 0x%X\n\r", DisplayPointer->StructLength) ); DEBUG ( (DEBUG_NET, "Use to make byte checksum of this structure == zero is = 0x%X\n\r", DisplayPointer->StructCksum) ); DEBUG ( (DEBUG_NET, "Structure format revision number= 0x%X\n\r", DisplayPointer->StructRev) ); DEBUG ( (DEBUG_NET, "API Revision number = 0x%X 0x%X 0x%X\n\r", DisplayPointer->UNDI_Rev[0], DisplayPointer->UNDI_Rev[1], DisplayPointer->UNDI_Rev[2]) ); DEBUG ( (DEBUG_NET, "Offset of UNDI loader routine in the option ROM image= 0x%X\n\r", DisplayPointer->UNDI_Loader) ); DEBUG ((DEBUG_NET, "From the data above, the absolute entry point of the UNDI loader is\n\r")); DEBUG ( (DEBUG_NET, "\tat address 0x%X\n\r", (UINT32) (DisplayPointer->UNDI_Loader + ((UINT32) (UINTN)(DisplayPointer - 0x20) & 0xFFFF0))) ); DEBUG ((DEBUG_NET, "Minimum stack segment size, in bytes,\n\r")); DEBUG ( (DEBUG_NET, "needed to load and run the UNDI= 0x%X \n\r", DisplayPointer->StackSize) ); DEBUG ( (DEBUG_NET, "UNDI runtime code and data = 0x%X\n\r", DisplayPointer->DataSize) ); DEBUG ( (DEBUG_NET, "Segment size = 0x%X\n\r", DisplayPointer->CodeSize) ); DEBUG ( (DEBUG_NET, "\n\rBus Type = %c%c%c%c\n\r", DisplayPointer->BusType[0], DisplayPointer->BusType[1], DisplayPointer->BusType[2], DisplayPointer->BusType[3]) ); } /** Print PXE table. @param PxeTable Point to PXE table structure **/ VOID Print_PXE_Table ( IN VOID* PxeTable ) { PXE_T *DisplayPointer; UINTN Index; UINT8 *Dptr; DisplayPointer = (PXE_T *) PxeTable; Dptr = (UINT8 *) PxeTable; DEBUG ((DEBUG_NET, "This is the PXE table at address 0x%X\n\r", PxeTable)); DEBUG ((DEBUG_NET, "A dump of the 0x%X bytes is:\n\r", sizeof (PXE_T))); for (Index = 0; Index < sizeof (PXE_T); Index++) { if ((Index % 0x10) == 0) { DEBUG ((DEBUG_NET, "\t\n\r")); } DEBUG ((DEBUG_NET, " 0x%X ", *Dptr++)); } DEBUG ((DEBUG_NET, "\n\r")); DEBUG ( (DEBUG_NET, "\n\rPXE %c%c%c%c%c%c\n\r", DisplayPointer->Signature[0], DisplayPointer->Signature[1], DisplayPointer->Signature[2], DisplayPointer->Signature[3]) ); DEBUG ( (DEBUG_NET, "Length of this structure in bytes = 0x%X\n\r", DisplayPointer->StructLength) ); DEBUG ( (DEBUG_NET, "Use to make byte checksum of this structure == zero is = 0x%X\n\r", DisplayPointer->StructCksum) ); DEBUG ( (DEBUG_NET, "Structure format revision number = 0x%X\n\r", DisplayPointer->StructRev) ); DEBUG ( (DEBUG_NET, "Must be zero, is equal to 0x%X\n\r", DisplayPointer->Reserved1) ); DEBUG ( (DEBUG_NET, "Far pointer to UNDI ROMID = 0x%X\n\r", (UINT32) (DisplayPointer->Undi.Segment << 0x4 | DisplayPointer->Undi.Offset)) ); DEBUG ( (DEBUG_NET, "Far pointer to base-code ROMID = 0x%X\n\r", (UINT32) ((DisplayPointer->Base.Segment << 0x04) | DisplayPointer->Base.Offset)) ); DEBUG ((DEBUG_NET, "16bit stack segment API entry point. This will be seg:off in \n\r")); DEBUG ( (DEBUG_NET, "real mode and sel:off in 16:16 protected mode = 0x%X:0x%X\n\r", DisplayPointer->EntryPointSP.Segment, DisplayPointer->EntryPointSP.Offset) ); DEBUG ((DEBUG_NET, "\n\tNOTE to the implementer\n\tThis is the entry to use for call-ins\n\r")); DEBUG ((DEBUG_NET, "32bit stack Segment API entry point. This will be sel:off. \n\r")); DEBUG ( (DEBUG_NET, "In real mode, sel == 0 = 0x%X:0x%X\n\r", DisplayPointer->EntryPointESP.Segment, DisplayPointer->EntryPointESP.Offset) ); DEBUG ( (DEBUG_NET, "Reserved2 value, must be zero, is equal to 0x%X\n\r", DisplayPointer->Reserved2) ); DEBUG ( (DEBUG_NET, "Number of segment descriptors in this structur = 0x%X\n\r", (UINT8) DisplayPointer->SegDescCnt) ); DEBUG ( (DEBUG_NET, "First segment descriptor in GDT assigned to PXE = 0x%X\n\r", (UINT16) DisplayPointer->FirstSelector) ); DEBUG ( (DEBUG_NET, "The Stack is \n\r\tSegment Addr = 0x%X\n\r\tPhysical Addr = 0x%X\n\r\tSeg Size = 0x%X\n\r", (UINT16) DisplayPointer->Stack.Seg_Addr, (UINT32) DisplayPointer->Stack.Phy_Addr, (UINT16) DisplayPointer->Stack.Seg_Size) ); DEBUG ( (DEBUG_NET, "The UNDIData is \n\r\tSegment Addr = 0x%X\n\r\tPhysical Addr = 0x%X\n\r\tSeg Size = 0x%X\n\r", (UINT16) DisplayPointer->UNDIData.Seg_Addr, (UINT32) DisplayPointer->UNDIData.Phy_Addr, (UINT16) DisplayPointer->UNDIData.Seg_Size) ); DEBUG ( (DEBUG_NET, "The UNDICodeWrite is \n\r\tSegment Addr = 0x%X\n\r\tPhysical Addr = 0x%X\n\r\tSeg Size = 0x%X\n\r", (UINT16) DisplayPointer->UNDICode.Seg_Addr, (UINT32) DisplayPointer->UNDICode.Phy_Addr, (UINT16) DisplayPointer->UNDICode.Seg_Size) ); DEBUG ( (DEBUG_NET, "The Stack is \n\r\tSegment Addr = 0x%X\n\r\tPhysical Addr = 0x%X\n\r\tSeg Size = 0x%X\n\r", (UINT16) DisplayPointer->UNDICodeWrite.Seg_Addr, (UINT32) DisplayPointer->UNDICodeWrite.Phy_Addr, (UINT16) DisplayPointer->UNDICodeWrite.Seg_Size) ); DEBUG ( (DEBUG_NET, "The BC_Data is \n\r\tSegment Addr = 0x%X\n\r\tPhysical Addr = 0x%X\n\r\tSeg Size = 0x%X\n\r", (UINT16) DisplayPointer->BC_Data.Seg_Addr, (UINT32) DisplayPointer->BC_Data.Phy_Addr, (UINT16) DisplayPointer->BC_Data.Seg_Size) ); DEBUG ( (DEBUG_NET, "The BC_Code is \n\r\tSegment Addr = 0x%X\n\r\tPhysical Addr = 0x%X\n\r\tSeg Size = 0x%X\n\r", (UINT16) DisplayPointer->BC_Code.Seg_Addr, (UINT32) DisplayPointer->BC_Code.Phy_Addr, (UINT16) DisplayPointer->BC_Code.Seg_Size) ); DEBUG ( (DEBUG_NET, "The BC_CodeWrite is \n\r\tSegment Addr = 0x%X\n\r\tPhysical Addr = 0x%X\n\r\tSeg Size = 0x%X\n\r", (UINT16) DisplayPointer->BC_CodeWrite.Seg_Addr, (UINT32) DisplayPointer->BC_CodeWrite.Phy_Addr, (UINT16) DisplayPointer->BC_CodeWrite.Seg_Size) ); } /** Print PXENV table. @param PxenvTable Point to PXENV **/ VOID Print_PXENV_Table ( IN VOID *PxenvTable ) { PXENV_T *DisplayPointer; DisplayPointer = (PXENV_T *) PxenvTable; DEBUG ( (DEBUG_NET, "\n\rPXENV+ %c%c%c%c%c%c\n\r", DisplayPointer->Signature[0], DisplayPointer->Signature[1], DisplayPointer->Signature[2], DisplayPointer->Signature[3], DisplayPointer->Signature[4], DisplayPointer->Signature[5]) ); DEBUG ( (DEBUG_NET, "PXE version number. \n\r\tLSB is minor version. \n\r\tMSB is major version = 0x%X\n\r", DisplayPointer->Version) ); DEBUG ( (DEBUG_NET, "Length of PXE-2.0 Entry Point structure in bytes = 0x%X\n\r", DisplayPointer->StructLength) ); DEBUG ((DEBUG_NET, "Used to make structure checksum equal zero is now = 0x%X\n\r", DisplayPointer->StructCksum)); DEBUG ((DEBUG_NET, "Real mode API entry point segment:Offset. = 0x%X\n\r", DisplayPointer->RMEntry)); DEBUG ((DEBUG_NET, "Protected mode API entry point = 0x%X\n\r", DisplayPointer->PMEntryOff)); DEBUG ((DEBUG_NET, " segment:Offset. This will always be zero. \n\r")); DEBUG ((DEBUG_NET, "Protected mode API calls = 0x%X\n\r", DisplayPointer->PMEntrySeg)); DEBUG ((DEBUG_NET, "Real mode stack segment = 0x%X\n\r", DisplayPointer->StackSeg)); DEBUG ((DEBUG_NET, "Stack segment size in bytes = 0x%X\n\r", DisplayPointer->StackSize)); DEBUG ((DEBUG_NET, "Real mode base-code code segment = 0x%X\n\r", DisplayPointer->BaseCodeSeg)); DEBUG ((DEBUG_NET, "Base-code code segment size = 0x%X\n\r", DisplayPointer->BaseCodeSize)); DEBUG ((DEBUG_NET, "Real mode base-code data segment = 0x%X\n\r", DisplayPointer->BaseDataSeg)); DEBUG ((DEBUG_NET, "Base-code data segment size = 0x%X\n\r", DisplayPointer->BaseDataSize)); DEBUG ( (DEBUG_NET, "UNDI code segment size in bytes = 0x%X\n\r", DisplayPointer->UNDICodeSize) ); DEBUG ( (DEBUG_NET, "Real mode segment:Offset pointer \n\r\tto PXE Runtime ID structure, address = 0x%X\n\r", DisplayPointer->RuntimePtr) ); DEBUG ( ( DEBUG_NET, "From above, we have a linear address of 0x%X\n\r", (UINT32) ( ((UINT32)(UINTN)(DisplayPointer->RuntimePtr) & 0xFFFF) + (((UINT32)(UINTN)(DisplayPointer->RuntimePtr) & 0xFFFF0000) >> 12) ) ) ); } #define OPTION_ROM_PTR ((OPTION_ROM_HEADER *) RomAddress) /** If available, launch the BaseCode from a NIC option ROM. This should install the !PXE and PXENV+ structures in memory for subsequent use. @param SimpleNetworkDevice Simple network device instance @param RomAddress The ROM base address for NIC rom. @retval EFI_NOT_FOUND The check sum does not match @retval EFI_NOT_FOUND Rom ID offset is wrong @retval EFI_NOT_FOUND No Rom ID structure is found **/ EFI_STATUS LaunchBaseCode ( EFI_SIMPLE_NETWORK_DEV *SimpleNetworkDevice, UINTN RomAddress ) { EFI_STATUS Status; EFI_IA32_REGISTER_SET InOutRegs; UNDI_ROMID_T *RomIdTableAddress; UNDI_LOADER_T *UndiLoaderTable; UINT16 Segment; UINT16 *StackPointer; VOID *Buffer; UINTN Size; PXE_T *Pxe; UINT32 RomLength; UINTN PciSegment; UINTN Bus; UINTN Device; UINTN Function; BOOLEAN ThunkFailed; DEBUG ((DEBUG_NET, "\n\r\n\rCheck for the UNDI ROMID Signature\n\r")); // // paranoia - check structures for validity // RomLength = OPTION_ROM_PTR->ROMlength << 9; if (CalculateSum8 ((UINT8 *) RomAddress, RomLength) != 0) { DEBUG ((DEBUG_ERROR, "ROM Header Checksum Error\n\r")); return EFI_NOT_FOUND; } RomIdTableAddress = (UNDI_ROMID_T *) (RomAddress + OPTION_ROM_PTR->PxeRomIdOffset); if (((UINT32)OPTION_ROM_PTR->PxeRomIdOffset + RomIdTableAddress->StructLength) > RomLength) { DEBUG ((DEBUG_ERROR, "ROM ID Offset Error\n\r")); return EFI_NOT_FOUND; } // // see if this is a header for an UNDI ROM ID structure (vs. a $BC$ or BUSD type) // if (CompareMem (RomIdTableAddress->Signature, UNDI_ROMID_SIG, sizeof RomIdTableAddress->Signature) != 0) { DEBUG ((DEBUG_ERROR, "No ROM ID Structure found....\n\r")); return EFI_NOT_FOUND; // // its not - keep looking // } if (CalculateSum8 ((UINT8 *) RomIdTableAddress, RomIdTableAddress->StructLength) != 0) { DEBUG ((DEBUG_ERROR, "ROM ID Checksum Error\n\r")); return EFI_NOT_FOUND; } Print_ROMID_Table (RomIdTableAddress); DEBUG ( (DEBUG_NET, "The ROM ID is located at 0x%X\n\r", RomIdTableAddress) ); DEBUG ( (DEBUG_NET, "With an UNDI Loader located at 0x%X\n\r", RomAddress + RomIdTableAddress->UNDI_Loader) ); // // found an UNDI ROM ID structure // SimpleNetworkDevice->Nii.ImageAddr = RomAddress; SimpleNetworkDevice->Nii.ImageSize = RomLength; SimpleNetworkDevice->Nii.MajorVer = RomIdTableAddress->UNDI_Rev[2]; SimpleNetworkDevice->Nii.MinorVer = RomIdTableAddress->UNDI_Rev[1]; DEBUG ((DEBUG_NET, "Allocate area for the UNDI_LOADER_T structure\n\r")); // // Allocate 1 page below 1MB to put real mode thunk code in // // Undi Loader Table is a PXE Specification prescribed data structure // that is used to transfer information into and out of the Undi layer. // Note how it must be located below 1 MB. // SimpleNetworkDevice->UndiLoaderTablePages = EFI_SIZE_TO_PAGES (PARAGRAPH_SIZE + sizeof (UNDI_LOADER_T)); Status = BiosSnp16AllocatePagesBelowOneMb ( SimpleNetworkDevice->UndiLoaderTablePages, &SimpleNetworkDevice->UndiLoaderTable ); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "We had a failure in AllocatePages, status code = 0x%X\n", Status)); return EFI_OUT_OF_RESOURCES; } UndiLoaderTable = SimpleNetworkDevice->UndiLoaderTable; DEBUG ((DEBUG_NET, "Allocate area for the real-mode stack whose sole purpose\n\r")); DEBUG ((DEBUG_NET, "in life right now is to store a SEG:OFFSET combo pair that\n\r")); DEBUG ((DEBUG_NET, "points to an Undi_Loader_t table structure\n\r")); Size = 0x100; Status = gBS->AllocatePool (EfiLoaderData, Size, &Buffer); if (EFI_ERROR (Status)) { return Status; } // // Now we want to put a pointer to the Under Loader Table in our MemPage // Buffer. This will be the argument stack for the call into the Undi Loader // StackPointer = (UINT16 *) Buffer; *StackPointer++ = TO_OFFSET (UndiLoaderTable); // // push the OFFSET // *StackPointer++ = TO_SEGMENT (UndiLoaderTable); // // push the SEGMENT // StackPointer = (UINT16 *) Buffer; // // reset the stack pointer // DEBUG ( (DEBUG_NET, "After the fixups, the stack pointer is 0x%X\n\r", (UINT64)(UINTN) StackPointer) ); // // Allocate memory for the Deployed UNDI. // The UNDI is essentially telling us how much space it needs, and // it is up to the EFI driver to allocate sufficient, boot-time // persistent resources for the call // SimpleNetworkDevice->DestinationDataSegmentPages = EFI_SIZE_TO_PAGES (RomIdTableAddress->DataSize); Status = BiosSnp16AllocatePagesBelowOneMb ( SimpleNetworkDevice->DestinationDataSegmentPages, &SimpleNetworkDevice->DestinationDataSegment ); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "We had a failure in AllocatePages, status code = 0x%X\n", Status)); return Status; } UndiLoaderTable->Undi_Ds = (UINT16) ((UINTN) SimpleNetworkDevice->DestinationDataSegment >> 4); // // Allocate memory for the Deployed UNDI stack // The UNDI is essentially telling us how much space it needs, and // it is up to the EFI driver to allocate sufficient, boot-time // persistent resources for the call // SimpleNetworkDevice->DestinationStackSegmentPages = EFI_SIZE_TO_PAGES (RomIdTableAddress->StackSize); Status = BiosSnp16AllocatePagesBelowOneMb ( SimpleNetworkDevice->DestinationStackSegmentPages, &SimpleNetworkDevice->DestinationStackSegment ); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "We had a failure in AllocatePages, status code = 0x%X\n", Status)); return Status; } // // Allocate memory for the Deployed UNDI. // The UNDI is essentially telling us how much space it needs, and // it is up to the EFI driver to allocate sufficient, boot-time // persistent resources for the call // SimpleNetworkDevice->DestinationCodeSegmentPages = EFI_SIZE_TO_PAGES (RomIdTableAddress->CodeSize); Status = BiosSnp16AllocatePagesBelowOneMb ( SimpleNetworkDevice->DestinationCodeSegmentPages, &SimpleNetworkDevice->DestinationCodeSegment ); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "We had a failure in AllocatePages, status code = 0x%X\n", Status)); return Status; } UndiLoaderTable->Undi_Cs = (UINT16) ((UINTN) SimpleNetworkDevice->DestinationCodeSegment >> 4); // // these are in the Input and Output Parameter to be sent to the UNDI Loader code // UndiLoaderTable->Status = 0xAA55; // // -------------------- Changed by Michael_Huang@3Com.com ----------------- // UndiLoaderTable->_AX is AX value when UNDI ROM is initialized by BIOS, it is the PCI bus device // function of the NIC. Please refer to PXE Spec for detail info. // old code is: // UndiLoaderTable->Ax = 0x0; // ----------------------------------------------------------------------- // SimpleNetworkDevice->PciIo->GetLocation ( SimpleNetworkDevice->PciIo, &PciSegment, &Bus, &Device, &Function ); UndiLoaderTable->Ax = (UINT16) ((Bus << 0x8) | (Device << 0x3) | (Function)); UndiLoaderTable->Bx = 0x0; UndiLoaderTable->Dx = 0x0; UndiLoaderTable->Di = 0x0; UndiLoaderTable->Es = 0x0; // // set these OUT values to zero in order to ensure that // uninitialized memory is not mistaken for display data // UndiLoaderTable->PXEptr.Offset = 0; UndiLoaderTable->PXEptr.Segment = 0; UndiLoaderTable->PXENVptr.Segment = 0; UndiLoaderTable->PXENVptr.Offset = 0; DEBUG ( (DEBUG_INIT, "The NIC is located at Bus 0x%X, Device 0x%X, Function 0x%X\n\r", Bus, Device, Function) ); // // These are the values that set up the ACTUAL IA32 machine state, whether in // Real16 in EFI32 or the IVE for IA64 // register values are unused except for CS:IP and SS:SP // InOutRegs.X.AX = 0; InOutRegs.X.BX = 0; InOutRegs.X.CX = 0; InOutRegs.X.DX = 0; InOutRegs.X.SI = 0; InOutRegs.X.DI = 0; InOutRegs.X.BP = 0; InOutRegs.X.DS = 0; InOutRegs.X.ES = 0; // // just to be clean // DEBUG ((DEBUG_NET, "The way this game works is that the SS:SP +4 should point\n\r")); DEBUG ((DEBUG_NET, "to the contents of the UndiLoaderTable\n\r")); DEBUG ( (DEBUG_NET, "The Undi Loader Table is at address = 0x%X\n\r", (UINT32)(UINTN) UndiLoaderTable) ); DEBUG ( (DEBUG_NET, "The segment and offsets are 0x%X and 0x%X, resp\n", TO_SEGMENT (UndiLoaderTable), TO_OFFSET (UndiLoaderTable)) ); DEBUG ( (DEBUG_NET, "The Linear Address of the UNDI Loader entry is 0x%X\n", RomAddress + RomIdTableAddress->UNDI_Loader) ); DEBUG ( (DEBUG_NET, "The Address offset of the UNDI Loader entry is 0x%X\n", RomIdTableAddress->UNDI_Loader) ); DEBUG ((DEBUG_NET, "Before the call, we have...\n\r")); Print_Undi_Loader_Table (UndiLoaderTable); Segment = ((UINT16) (RShiftU64 (RomAddress, 4) & 0xFFFF)); DEBUG ((DEBUG_NET, "The Segment of the call is 0x%X\n\r", Segment)); // // make the call into the UNDI Code // DEBUG ((DEBUG_INIT, "Make the call into the UNDI code now\n\r")); DEBUG ((DEBUG_NET, "\nThe 20-BIt address of the Call, and the location \n\r")); DEBUG ((DEBUG_NET, "\twhere we should be able to set a breakpoint is \n\r")); DEBUG ( (DEBUG_NET, "\t\t0x%X, from SEG:OFF 0x%X:0x%X\n\r\n\r", Segment * 0x10 + RomIdTableAddress->UNDI_Loader, Segment, RomIdTableAddress->UNDI_Loader) ); ThunkFailed = SimpleNetworkDevice->LegacyBios->FarCall86 ( SimpleNetworkDevice->LegacyBios, Segment, // Input segment (UINT16) RomIdTableAddress->UNDI_Loader, // Offset &InOutRegs, // Ptr to Regs Buffer, // Reference to Stack Size // Size of the Stack ); if (ThunkFailed) { return EFI_ABORTED; } DEBUG ( (DEBUG_NET, "The return code UndiLoaderTable->Status is = 0x%X\n\r", UndiLoaderTable->Status) ); DEBUG ( (DEBUG_NET, "This error code should match eax, which is = 0x%X\n\r", InOutRegs.X.AX) ); if ((UndiLoaderTable->Status != 0) || (InOutRegs.X.AX != PXENV_EXIT_SUCCESS)) { DEBUG ((DEBUG_NET, "LaunchBaseCode exits with error, RomAddress = 0x%X\n\r", RomAddress)); return EFI_ABORTED; } DEBUG ((DEBUG_NET, "Now returned from the UNDI code\n\r")); DEBUG ((DEBUG_NET, "After the call, we have...\n\r")); Print_Undi_Loader_Table (UndiLoaderTable); DEBUG ((DEBUG_NET, "Display the PXENV+ and !PXE tables exported by NIC\n\r")); Print_PXENV_Table ((VOID *)(((UINTN)UndiLoaderTable->PXENVptr.Segment << 4) | UndiLoaderTable->PXENVptr.Offset)); Print_PXE_Table ((VOID *)(((UINTN)UndiLoaderTable->PXEptr.Segment << 4) + UndiLoaderTable->PXEptr.Offset)); Pxe = (PXE_T *)(((UINTN)UndiLoaderTable->PXEptr.Segment << 4) + UndiLoaderTable->PXEptr.Offset); SimpleNetworkDevice->Nii.Id = (UINT64)(UINTN) Pxe; gBS->FreePool (Buffer); // // paranoia - make sure a valid !PXE structure // if (CompareMem (Pxe->Signature, PXE_SIG, sizeof Pxe->Signature) != 0) { DEBUG ((DEBUG_ERROR, "!PXE Structure not found....\n\r")); return EFI_NOT_FOUND; // // its not - keep looking // } if (CalculateSum8 ((UINT8 *) Pxe, Pxe->StructLength) != 0) { DEBUG ((DEBUG_ERROR, "!PXE Checksum Error\n\r")); return EFI_NOT_FOUND; } if (Pxe->StructLength < (UINT8 *) &Pxe->FirstSelector - (UINT8 *) Pxe->Signature) { DEBUG ((DEBUG_ERROR, "!PXE Length Error\n\r")); return EFI_NOT_FOUND; } if ((((UINTN) Pxe->Undi.Segment) << 4) + Pxe->Undi.Offset != (UINTN) RomIdTableAddress) { DEBUG ((DEBUG_ERROR, "!PXE RomId Address Error\n\r")); return EFI_NOT_FOUND; } // // This is the magic to bind the global PXE interface // This dirtiness is for non-protocol shrouded access // SimpleNetworkDevice->PxeEntrySegment = Pxe->EntryPointSP.Segment; if (SimpleNetworkDevice->PxeEntrySegment == 0) { DEBUG ((DEBUG_ERROR, "!PXE EntryPointSP segment Error\n\r")); return EFI_NOT_FOUND; } SimpleNetworkDevice->PxeEntryOffset = Pxe->EntryPointSP.Offset; DEBUG ( ( DEBUG_NET, "The entry point is 0x%X:0x%X\n\r", SimpleNetworkDevice->PxeEntrySegment, SimpleNetworkDevice-> PxeEntryOffset ) ); return EFI_SUCCESS; } /** Effect the Far Call into the PXE Layer Note: When using a 32-bit stack segment do not push 32-bit words onto the stack. The PXE API services will not work, unless there are three 16-bit parameters pushed onto the stack. push DS ;Far pointer to parameter structure push offset pxe_data_call_struct ;is pushed onto stack. push Index ;UINT16 is pushed onto stack. call dword ptr (s_PXE ptr es:[di]).EntryPointSP add sp, 6 ;Caller cleans up stack. @param SimpleNetworkDevice Device instance for simple network @param Table Point to parameter/retun value table for legacy far call @param TableSize The size of parameter/return value table @param CallIndex The index of legacy call. @return EFI_STATUS **/ EFI_STATUS MakePxeCall ( EFI_SIMPLE_NETWORK_DEV *SimpleNetworkDevice, IN OUT VOID *Table, IN UINTN TableSize, IN UINT16 CallIndex ) { EFI_STATUS Status; EFI_IA32_REGISTER_SET InOutRegs; UINT16 *BPtr; VOID *Buffer; UINTN Size; VOID *MemPageAddress; UINTN Index; BOOLEAN ThunkFailed; DEBUG ((DEBUG_NET, "MakePxeCall(CallIndex = %02x, Table = %X, TableSize = %d)\n", CallIndex, Table, TableSize)); if (SimpleNetworkDevice->PxeEntrySegment == 0 && SimpleNetworkDevice->PxeEntryOffset == 0) { return EFI_DEVICE_ERROR; } Status = EFI_SUCCESS; // // Allocate a transient data structure for the argument table // This table needs to have the input XXX_t structure copied into here. // The PXE UNDI can only grab this table when it's below one-MB, and // this implementation will not try to push this table on the stack // (although this is a possible optimization path since EFI always allocates // 4K as a minimum page size...............) // Status = BiosSnp16AllocatePagesBelowOneMb ( TableSize / EFI_PAGE_SIZE + 1, &MemPageAddress ); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "We had a failure in AllocatePages, status code = 0x%X\n", Status)); return Status; } // // Copy the > 1MB pool table to a sub-1MB buffer // CopyMem (MemPageAddress, Table, TableSize); // // Allocate space for IA-32 register context // ZeroMem (&InOutRegs, sizeof (InOutRegs)); InOutRegs.X.ES = SimpleNetworkDevice->PxeEntrySegment; InOutRegs.X.DI = SimpleNetworkDevice->PxeEntryOffset; // // The game here is to build the stack which will subsequently // get copied down below 1 MB by the FarCall primitive. // This is now our working stack // Size = 6; Status = gBS->AllocatePool ( EfiRuntimeServicesData, Size, &Buffer ); if (EFI_ERROR (Status)) { return Status; } BPtr = (UINT16 *) Buffer; *BPtr++ = CallIndex; // // SP + 2 // *BPtr++ = TO_OFFSET (MemPageAddress); *BPtr++ = TO_SEGMENT (MemPageAddress); DEBUG ((DEBUG_NET, "State before FarCall86\n")); DEBUG ((DEBUG_NET, "The Buffer is at 0x%X\n\r", Buffer)); BPtr = (UINT16 *) Buffer; DEBUG ((DEBUG_NET, " Buffer = %04X %04X %04X", *BPtr, *(BPtr + 1), *(BPtr + 2))); DEBUG ((DEBUG_NET, " MemPage = ")); for (Index = 0; Index < TableSize; Index++) { DEBUG ((DEBUG_NET, " %02x", *((UINT8 *) MemPageAddress + Index))); } DEBUG ((DEBUG_NET, "\n")); ThunkFailed = SimpleNetworkDevice->LegacyBios->FarCall86 ( SimpleNetworkDevice->LegacyBios, SimpleNetworkDevice->PxeEntrySegment, // Input segment SimpleNetworkDevice->PxeEntryOffset, &InOutRegs, // Ptr to Regs Buffer, // Reference to Stack 6 // Size of the Stack ); if (ThunkFailed) { return EFI_ABORTED; } DEBUG ((DEBUG_NET, "State after FarCall86\n")); DEBUG ((DEBUG_NET, "The Buffer is at 0x%X\n\r", Buffer)); BPtr = (UINT16 *) Buffer; DEBUG ((DEBUG_NET, " Buffer = %04X %04X %04X", *BPtr, *(BPtr + 1), *(BPtr + 2))); DEBUG ((DEBUG_NET, " MemPage = ")); for (Index = 0; Index < TableSize; Index++) { DEBUG ((DEBUG_NET, " %02x", *((UINT8 *) MemPageAddress + Index))); } DEBUG ((DEBUG_NET, "\n")); // // Copy the sub 1MB table to > 1MB table // CopyMem (Table, MemPageAddress, TableSize); // // For PXE UNDI call, AX contains the return status. // Convert the PXE UNDI Status to EFI_STATUS type // if (InOutRegs.X.AX == PXENV_EXIT_SUCCESS) { Status = EFI_SUCCESS; } else { Status = EFI_DEVICE_ERROR; } // // Clean up house // gBS->FreePool (Buffer); gBS->FreePages ((EFI_PHYSICAL_ADDRESS) (UINTN) MemPageAddress, TableSize / EFI_PAGE_SIZE + 1); return Status; }