sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

IntelFrameworkModulePkg: Add Compatibility Support Module (CSM) drivers

Browse Source 
Added these drivers:
* LegacyBiosDxe
* BlockIoDxe
* KeyboardDxe
* Snp16Dxe
* VideoDxe

Signed-off-by: jljusten
Reviewed-by: mdkinney
Reviewed-by: geekboy15a

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@11905 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
jljusten
2011-06-27 23:32:56 +00:00
parent a7a0f78bd6
commit bcecde140a
46 changed files with 30571 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3507
IntelFrameworkModulePkg/Csm/BiosThunk/Snp16Dxe/BiosSnp16.c Normal file
View File

File diff suppressed because it is too large Load Diff

1655
IntelFrameworkModulePkg/Csm/BiosThunk/Snp16Dxe/BiosSnp16.h Normal file
View File

File diff suppressed because it is too large Load Diff

309
IntelFrameworkModulePkg/Csm/BiosThunk/Snp16Dxe/ComponentName.c Normal file
View File

@@ -0,0 +1,309 @@
/** @file
Copyright (c) 1999 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions
of the BSD License which accompanies this distribution. The
full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "BiosSnp16.h"
/**
Retrieves a Unicode string that is the user readable name of the driver.
This function retrieves the user readable name of a driver in the form of a
Unicode string. If the driver specified by This has a user readable name in
the language specified by Language, then a pointer to the driver name is
returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
by This does not support the language specified by Language,
then EFI_UNSUPPORTED is returned.
@param This[in] A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
EFI_COMPONENT_NAME_PROTOCOL instance.
@param Language[in] A pointer to a Null-terminated ASCII string
array indicating the language. This is the
language of the driver name that the caller is
requesting, and it must match one of the
languages specified in SupportedLanguages. The
number of languages supported by a driver is up
to the driver writer. Language is specified
in RFC 4646 or ISO 639-2 language code format.
@param DriverName[out] A pointer to the Unicode string to return.
This Unicode string is the name of the
driver specified by This in the language
specified by Language.
@retval EFI_SUCCESS The Unicode string for the Driver specified by
This and the language specified by Language was
returned in DriverName.
@retval EFI_INVALID_PARAMETER Language is NULL.
@retval EFI_INVALID_PARAMETER DriverName is NULL.
@retval EFI_UNSUPPORTED The driver specified by This does not support
the language specified by Language.
**/
EFI_STATUS
EFIAPI
BiosSnp16ComponentNameGetDriverName (
IN EFI_COMPONENT_NAME_PROTOCOL *This,
IN CHAR8 *Language,
OUT CHAR16 **DriverName
);
/**
Retrieves a Unicode string that is the user readable name of the controller
that is being managed by a driver.
This function retrieves the user readable name of the controller specified by
ControllerHandle and ChildHandle in the form of a Unicode string. If the
driver specified by This has a user readable name in the language specified by
Language, then a pointer to the controller name is returned in ControllerName,
and EFI_SUCCESS is returned. If the driver specified by This is not currently
managing the controller specified by ControllerHandle and ChildHandle,
then EFI_UNSUPPORTED is returned. If the driver specified by This does not
support the language specified by Language, then EFI_UNSUPPORTED is returned.
@param This[in] A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
EFI_COMPONENT_NAME_PROTOCOL instance.
@param ControllerHandle[in] The handle of a controller that the driver
specified by This is managing. This handle
specifies the controller whose name is to be
returned.
@param ChildHandle[in] The handle of the child controller to retrieve
the name of. This is an optional parameter that
may be NULL. It will be NULL for device
drivers. It will also be NULL for a bus drivers
that wish to retrieve the name of the bus
controller. It will not be NULL for a bus
driver that wishes to retrieve the name of a
child controller.
@param Language[in] A pointer to a Null-terminated ASCII string
array indicating the language. This is the
language of the driver name that the caller is
requesting, and it must match one of the
languages specified in SupportedLanguages. The
number of languages supported by a driver is up
to the driver writer. Language is specified in
RFC 4646 or ISO 639-2 language code format.
@param ControllerName[out] A pointer to the Unicode string to return.
This Unicode string is the name of the
controller specified by ControllerHandle and
ChildHandle in the language specified by
Language from the point of view of the driver
specified by This.
@retval EFI_SUCCESS The Unicode string for the user readable name in
the language specified by Language for the
driver specified by This was returned in
DriverName.
@retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
@retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
EFI_HANDLE.
@retval EFI_INVALID_PARAMETER Language is NULL.
@retval EFI_INVALID_PARAMETER ControllerName is NULL.
@retval EFI_UNSUPPORTED The driver specified by This is not currently
managing the controller specified by
ControllerHandle and ChildHandle.
@retval EFI_UNSUPPORTED The driver specified by This does not support
the language specified by Language.
**/
EFI_STATUS
EFIAPI
BiosSnp16ComponentNameGetControllerName (
IN EFI_COMPONENT_NAME_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_HANDLE ChildHandle OPTIONAL,
IN CHAR8 *Language,
OUT CHAR16 **ControllerName
);
//
// EFI Component Name Protocol
//
GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL gBiosSnp16ComponentName = {
BiosSnp16ComponentNameGetDriverName,
BiosSnp16ComponentNameGetControllerName,
"eng"
};
//
// EFI Component Name 2 Protocol
//
GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gBiosSnp16ComponentName2 = {
(EFI_COMPONENT_NAME2_GET_DRIVER_NAME) BiosSnp16ComponentNameGetDriverName,
(EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) BiosSnp16ComponentNameGetControllerName,
"en"
};
GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mBiosSnp16DriverNameTable[] = {
{
"eng;en",
L"BIOS[UNDI] Simple Network Protocol Driver"
},
{
NULL,
NULL
}
};
/**
Retrieves a Unicode string that is the user readable name of the driver.
This function retrieves the user readable name of a driver in the form of a
Unicode string. If the driver specified by This has a user readable name in
the language specified by Language, then a pointer to the driver name is
returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
by This does not support the language specified by Language,
then EFI_UNSUPPORTED is returned.
@param This[in] A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
EFI_COMPONENT_NAME_PROTOCOL instance.
@param Language[in] A pointer to a Null-terminated ASCII string
array indicating the language. This is the
language of the driver name that the caller is
requesting, and it must match one of the
languages specified in SupportedLanguages. The
number of languages supported by a driver is up
to the driver writer. Language is specified
in RFC 4646 or ISO 639-2 language code format.
@param DriverName[out] A pointer to the Unicode string to return.
This Unicode string is the name of the
driver specified by This in the language
specified by Language.
@retval EFI_SUCCESS The Unicode string for the Driver specified by
This and the language specified by Language was
returned in DriverName.
@retval EFI_INVALID_PARAMETER Language is NULL.
@retval EFI_INVALID_PARAMETER DriverName is NULL.
@retval EFI_UNSUPPORTED The driver specified by This does not support
the language specified by Language.
**/
EFI_STATUS
EFIAPI
BiosSnp16ComponentNameGetDriverName (
IN EFI_COMPONENT_NAME_PROTOCOL *This,
IN CHAR8 *Language,
OUT CHAR16 **DriverName
)
{
return LookupUnicodeString2 (
Language,
This->SupportedLanguages,
mBiosSnp16DriverNameTable,
DriverName,
(BOOLEAN)(This == &gBiosSnp16ComponentName)
);
}
/**
Retrieves a Unicode string that is the user readable name of the controller
that is being managed by a driver.
This function retrieves the user readable name of the controller specified by
ControllerHandle and ChildHandle in the form of a Unicode string. If the
driver specified by This has a user readable name in the language specified by
Language, then a pointer to the controller name is returned in ControllerName,
and EFI_SUCCESS is returned. If the driver specified by This is not currently
managing the controller specified by ControllerHandle and ChildHandle,
then EFI_UNSUPPORTED is returned. If the driver specified by This does not
support the language specified by Language, then EFI_UNSUPPORTED is returned.
@param This[in] A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
EFI_COMPONENT_NAME_PROTOCOL instance.
@param ControllerHandle[in] The handle of a controller that the driver
specified by This is managing. This handle
specifies the controller whose name is to be
returned.
@param ChildHandle[in] The handle of the child controller to retrieve
the name of. This is an optional parameter that
may be NULL. It will be NULL for device
drivers. It will also be NULL for a bus drivers
that wish to retrieve the name of the bus
controller. It will not be NULL for a bus
driver that wishes to retrieve the name of a
child controller.
@param Language[in] A pointer to a Null-terminated ASCII string
array indicating the language. This is the
language of the driver name that the caller is
requesting, and it must match one of the
languages specified in SupportedLanguages. The
number of languages supported by a driver is up
to the driver writer. Language is specified in
RFC 4646 or ISO 639-2 language code format.
@param ControllerName[out] A pointer to the Unicode string to return.
This Unicode string is the name of the
controller specified by ControllerHandle and
ChildHandle in the language specified by
Language from the point of view of the driver
specified by This.
@retval EFI_SUCCESS The Unicode string for the user readable name in
the language specified by Language for the
driver specified by This was returned in
DriverName.
@retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
@retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
EFI_HANDLE.
@retval EFI_INVALID_PARAMETER Language is NULL.
@retval EFI_INVALID_PARAMETER ControllerName is NULL.
@retval EFI_UNSUPPORTED The driver specified by This is not currently
managing the controller specified by
ControllerHandle and ChildHandle.
@retval EFI_UNSUPPORTED The driver specified by This does not support
the language specified by Language.
**/
EFI_STATUS
EFIAPI
BiosSnp16ComponentNameGetControllerName (
IN EFI_COMPONENT_NAME_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_HANDLE ChildHandle OPTIONAL,
IN CHAR8 *Language,
OUT CHAR16 **ControllerName
)
{
return EFI_UNSUPPORTED;
}

956
IntelFrameworkModulePkg/Csm/BiosThunk/Snp16Dxe/Misc.c Normal file
View File

@@ -0,0 +1,956 @@
/** @file
Helper Routines that use a PXE-enabled NIC option ROM.
Copyright (c) 1999 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions
of the BSD License which accompanies this distribution. The
full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#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 ((UINTN) (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)
);
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;
//
// 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 paramter/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;
}

613
IntelFrameworkModulePkg/Csm/BiosThunk/Snp16Dxe/Pxe.h Normal file
View File

@@ -0,0 +1,613 @@
/** @file
These are PXE Specification 2.1-compliant data structures and defines.
This file relies upon the existence of a PXE-compliant ROM
in memory, as defined by the Preboot Execution Environment
Specification (PXE), Version 2.1, located at
http://developer.intel.com/ial/wfm/wfmspecs.htm
Copyright (c) 1999 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions
of the BSD License which accompanies this distribution. The
full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef _PXEDEF_H_
#define _PXEDEF_H_
#pragma pack(1)
//
// PXE structure signatures
//
#define BC_ROMID_SIG "$BC$"
#define UNDI_ROMID_SIG "UNDI"
#define BUSD_ROMID_SIG "BUSD"
#define PXE_SIG "!PXE"
#define PXENV_SIG "PXENV+"
#define BC_ROMID_REV 0x00
#define UNDI_ROMID_REV 0x00
#define BUSD_ROMID_REV 0x00
#define PXE_REV 0x00
#define PXENV_REV 0x0201
#define PXENV_PTR SIGNATURE_32 ('P', 'X', 'E', 'N')
#define PXE_PTR SIGNATURE_32 ('!', 'P', 'X', 'E')
#define UNDI_ROMID_SIG_PTR SIGNATURE_32 ('U', 'N', 'D', 'I')
typedef UINT16 SEGSEL; // Real mode segment or protected mode selector.
typedef UINT16 OFF16; // Unsigned 16bit offset.
typedef UINT32 ADDR32;
//
// Bus types
//
#define PXENV_BUS_ISA 0
#define PXENV_BUS_EISA 1
#define PXENV_BUS_MCA 2
#define PXENV_BUS_PCI 3
#define PXENV_BUS_VESA 4
#define PXENV_BUS_PCMCIA 5
//
//
// Result codes returned in AX by a PXENV API service.
//
#define PXENV_EXIT_SUCCESS 0x0000
#define PXENV_EXIT_FAILURE 0x0001
//
// Status codes returned in the status word of PXENV API parameter structures.
//
// Generic API errors - these do not match up with the M0x or E0x messages
// that are reported by the loader.
//
#define PXENV_STATUS_SUCCESS 0x00
#define PXENV_STATUS_FAILURE 0x01
#define PXENV_STATUS_BAD_FUNC 0x02
#define PXENV_STATUS_UNSUPPORTED 0x03
#define PXENV_STATUS_KEEP_UNDI 0x04
#define PXENV_STATUS_KEEP_ALL 0x05
#define PXENV_STATUS_OUT_OF_RESOURCES 0x06
typedef enum {
PxeEnvStatus_Success,
PxeEnvStatus_Failure,
PxeEnvStatus_BadFunc,
PxeEnvStatus_Unsupported,
PxeEnvStatus_KeepUndi,
PxeEnvStatus_KeepAll
} EFI_PXE_STATUS;
/* Driver errors (0x60 to 0x6F) */
// These errors are for UNDI compatible NIC drivers.
#define PXENV_STATUS_UNDI_INVALID_FUNCTION 0x60
#define PXENV_STATUS_UNDI_MEDIATEST_FAILED 0x61
#define PXENV_STATUS_UNDI_CANNOT_INIT_NIC_FOR_MCAST 0x62
#define PXENV_STATUS_UNDI_CANNOT_INITIALIZE_NIC 0x63
#define PXENV_STATUS_UNDI_CANNOT_INITIALIZE_PHY 0x64
#define PXENV_STATUS_UNDI_CANNOT_READ_CONFIG_DATA 0x65
#define PXENV_STATUS_UNDI_CANNOT_READ_INIT_DATA 0x66
#define PXENV_STATUS_UNDI_BAD_MAC_ADDR 0x67
#define PXENV_STATUS_UNDI_BAD_EEPROM_CKSUM 0x68
#define PXENV_STATUS_UNDI_ERROR_SETTING_ISR 0x69
#define PXENV_STATUS_UNDI_INVALID_STATE 0x6A
#define PXENV_STATUS_UNDI_TRANSMIT_ERROR 0x6B
#define PXENV_STATUS_UNDI_INVALID_PARAMETER 0x6C
typedef struct {
UINT16 Seg_Addr;
UINT32 Phy_Addr;
UINT16 Seg_Size;
} NEWSEGDESC_T;
typedef struct {
OFF16 Offset;
SEGSEL Segment;
} SEGOFF16;
typedef struct {
UINT8 Signature[4]; ///< Structure signature is not NULL terminated.
UINT8 StructLength; ///< Length of this structure in bytes.
UINT8 StructCksum; ///< Use to make byte checksum of this structure == zero.
UINT8 StructRev; ///< Structure format revision number.
UINT8 UNDI_Rev[3]; ///< API revision number stored in Intel order.
//
// Revision 2.1.0 == 0x00, 0x01, 0x02
//
UINT16 UNDI_Loader; ///< Offset of UNDI loader routine in the option ROM image.
UINT16 StackSize; ///< Minimum stack segment size, in bytes, needed to load and run the UNDI.
UINT16 DataSize; ///< UNDI runtime code and data
UINT16 CodeSize; ///< segment sizes.
UINT8 BusType[4]; ///< 'ISAR', 'EISA', 'PCIR', 'PCCR'
} UNDI_ROMID_T;
typedef struct {
UINT8 Signature[4]; ///< Structure signature is not NULL terminated.
UINT8 StructLength; ///< Length of this structure in bytes.
UINT8 StructCksum; ///< Use to make byte checksum of this structure == zero.
UINT8 StructRev; ///< Structure format revision number.
UINT8 BC_Rev[3]; ///< API revision number stored in Intel order.
//
// Revision 2.1.0 == 0x00, 0x01, 0x02
//
UINT16 BC_Loader; ///< Offset of base-code loader routine in the option ROM image.
UINT16 StackSize; ///< Minimum stack segment size (bytes) needed to load/run base-code.
UINT16 DataSize; ///< Base-code runtime code and data
UINT16 CodeSize; ///< segment sizes.
} BC_ROMID_T;
typedef struct {
UINT8 Signature[4]; ///< Structure signature is not NULL terminated.
UINT8 StructLength; ///< Length of this structure in bytes.
UINT8 StructCksum; ///< Use to make byte checksum of this structure == zero.
UINT8 StructRev; ///< Structure format revision number.
UINT8 Reserved1; ///< must be zero
///
/// UNDI_ROMID_T __FAR *UNDI;// Far pointer to UNDI ROMID
///
SEGOFF16 Undi;
///
/// BC_ROMID_T __FAR *Base; // Far pointer to base-code ROMID
///
SEGOFF16 Base;
///
/// UINT16 (__FAR __CDECL *EntryPointSP)(UINT16 func, VOID __FAR *param);
/// 16bit stack segment API entry point. This will be seg:off in
/// real mode and sel:off in 16:16 protected mode.
///
SEGOFF16 EntryPointSP;
///
/// UINT16 (__FAR __CDECL *EntryPointESP)(UINT16 func, VOID __FAR *param);
/// 32bit stack segment API entry point. This will be sel:off.
/// In real mode, sel == 0
///
SEGOFF16 EntryPointESP;
///
/// UINT16 (__FAR __CDECL *StatusCallout)(UINT16 param);
/// Address of DHCP/TFTP status callout routine.
///
SEGOFF16 StatusCallout;
UINT8 Reserved2; ///< must be zero
UINT8 SegDescCnt; ///< Number of segment descriptors in this structure.
UINT16 FirstSelector; ///< First segment descriptor in GDT assigned to PXE.
NEWSEGDESC_T Stack;
NEWSEGDESC_T UNDIData;
NEWSEGDESC_T UNDICode;
NEWSEGDESC_T UNDICodeWrite;
NEWSEGDESC_T BC_Data;
NEWSEGDESC_T BC_Code;
NEWSEGDESC_T BC_CodeWrite;
} PXE_T;
typedef struct {
CHAR8 Signature[6]; ///< "PXENV+"
UINT16 Version; ///< PXE version number. LSB is minor version. MSB is major version.
UINT8 StructLength; ///< Length of PXE-2.0 Entry Point structure in bytes.
UINT8 StructCksum; ///< Used to make structure checksum equal zero.
UINT32 RMEntry; ///< Real mode API entry point segment:offset.
UINT32 PMEntryOff; ///< Protected mode API entry point
UINT16 PMEntrySeg; ///< segment:offset. This will always be zero. Protected mode API calls
///< must be made through the API entry points in the PXE Runtime ID structure.
UINT16 StackSeg; ///< Real mode stack segment.
UINT16 StackSize; ///< Stack segment size in bytes.
UINT16 BaseCodeSeg; ///< Real mode base-code code segment.
UINT16 BaseCodeSize; ///< Base-code code segment size
UINT16 BaseDataSeg; ///< Real mode base-code data segment.
UINT16 BaseDataSize; ///< Base-code data segment size
UINT16 UNDIDataSeg; ///< Real mode UNDI data segment.
UINT16 UNDIDataSize; ///< UNDI data segment size in bytes.
UINT16 UNDICodeSeg; ///< Real mode UNDI code segment.
UINT16 UNDICodeSize; ///< UNDI code segment size in bytes.
PXE_T *RuntimePtr; ///< Real mode segment:offset pointer to PXE Runtime ID structure.
} PXENV_T;
typedef struct {
OUT UINT16 Status;
IN OUT UINT16 Ax;
IN OUT UINT16 Bx;
IN OUT UINT16 Dx;
IN OUT UINT16 Di;
IN OUT UINT16 Es;
IN OUT UINT16 Undi_Ds;
IN OUT UINT16 Undi_Cs;
OUT SEGOFF16 PXEptr;
OUT SEGOFF16 PXENVptr;
} UNDI_LOADER_T;
//
// Put in some UNDI-specific arguments
//
#define PXENV_START_UNDI 0x0000
#define PXENV_UNDI_STARTUP 0x0001
#define PXENV_UNDI_CLEANUP 0x0002
#define PXENV_UNDI_INITIALIZE 0x0003
#define PXENV_UNDI_RESET_NIC 0x0004
#define PXENV_UNDI_SHUTDOWN 0x0005
#define PXENV_UNDI_OPEN 0x0006
#define PXENV_UNDI_CLOSE 0x0007
#define PXENV_UNDI_TRANSMIT 0x0008
#define PXENV_UNDI_SET_MCAST_ADDR 0x0009
#define PXENV_UNDI_SET_STATION_ADDR 0x000A
#define PXENV_UNDI_SET_PACKET_FILTER 0x000B
#define PXENV_UNDI_GET_INFORMATION 0x000C
#define PXENV_UNDI_GET_STATISTICS 0x000D
#define PXENV_UNDI_CLEAR_STATISTICS 0x000E
#define PXENV_UNDI_INITIATE_DIAGS 0x000F
#define PXENV_UNDI_FORCE_INTERRUPT 0x0010
#define PXENV_UNDI_GET_MCAST_ADDR 0x0011
#define PXENV_UNDI_GET_NIC_TYPE 0x0012
#define PXENV_UNDI_GET_NDIS_INFO 0x0013
#define PXENV_UNDI_ISR 0x0014
#define PXENV_STOP_UNDI 0x0015
#define PXENV_UNDI_GET_STATE 0x0016
#define ADDR_LEN 16
#define MAXNUM_MCADDR 8
#define IPLEN 4 ///< length of an IP address
#define XMT_DESTADDR 0x0000 ///< destination address given
#define XMT_BROADCAST 0x0001 ///< use broadcast address
typedef struct {
UINT16 MCastAddrCount; ///< In: Number of multi-cast
/* addresses. */
UINT8 MCastAddr[MAXNUM_MCADDR][ADDR_LEN]; /* In: */
/* list of multi-cast addresses. */
/* Each address can take up to */
/* ADDR_LEN bytes and a maximum */
/* of MAXNUM_MCADDR address can */
/* be provided*/
} PXENV_UNDI_MCAST_ADDR_T;
/* Definitions of TFTP API parameter structures.
*/
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
IN UINT16 Ax; ///< In: These register fields must be
IN UINT16 Bx; ///< filled in with the same data
IN UINT16 Dx; ///< that was passed to the MLID
IN UINT16 Di; ///< option ROM boot code by the
IN UINT16 Es; ///< system BIOS.
} PXENV_START_UNDI_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
} PXENV_UNDI_STARTUP_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
} PXENV_UNDI_CLEANUP_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
///
/// This is an input parameter and is a 32-bit physical address of
/// a memory copy of the driver module in the protocol.ini file
/// obtained from the Protocol Manager driver(refer to NDIS 2.0
/// specifications). This parameter is basically supported for
/// the universal NDIS driver to pass the information contained in
/// protocol.ini file to the NIC driver for any specific
/// configuration of the NIC. (Note that the module
/// identification in the protocol.ini file was done by NDIS
/// itself.) This value can be NULL for for any other application
/// interfacing to the Universal NIC Driver.
///
IN UINT32 ProtocolIni;
UINT8 Reserved[8];
} PXENV_UNDI_INITIALIZE_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
IN PXENV_UNDI_MCAST_ADDR_T R_Mcast_Buf; ///< multicast address list
/* see note below */
} PXENV_UNDI_RESET_T;
/*++
Note: The NIC driver does not remember the multicast
addresses provided in any call. So the application must
provide the multicast address list with all the calls that
reset the receive unit of the adapter.
--*/
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
} PXENV_UNDI_SHUTDOWN_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
///
/// This is an input parameter and is adapter specific. This is
/// supported for Universal NDIS 2.0 driver to pass down the Open
/// flags provided by the protocol driver (See NDIS 2.0
/// specifications). This can be zero.
///
IN UINT16 OpenFlag; ///< In: See description below
IN UINT16 PktFilter; ///< In: Filter for receiving
/* packet. It takes the following */
/* values, multiple values can be */
/* ORed together. */
#define FLTR_DIRECTED 0x0001 ///< directed/multicast
#define FLTR_BRDCST 0x0002 ///< broadcast packets
#define FLTR_PRMSCS 0x0004 ///< any packet on LAN
#define FLTR_SRC_RTG 0x0008 ///< source routing packet
IN PXENV_UNDI_MCAST_ADDR_T McastBuffer; /* In: */
/* See t_PXENV_UNDI_MCAST_ADDR. */
} PXENV_UNDI_OPEN_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
} PXENV_UNDI_CLOSE_T;
#define MAX_DATA_BLKS 8
typedef struct {
IN UINT16 ImmedLength; ///< In: Data buffer length in
/* bytes. */
UINT16 XmitOffset; ///< 16-bit segment & offset of the
UINT16 XmitSegment; ///< immediate data buffer.
UINT16 DataBlkCount; ///< In: Number of data blocks.
struct DataBlk {
UINT8 TDPtrType; ///< 0 => 32 bit Phys pointer in TDDataPtr, not supported in this version of LSA
///< 1 => seg:offser in TDDataPtr which can be a real mode or 16-bit protected mode pointer
UINT8 TDRsvdByte; ///< Reserved, must be zero.
UINT16 TDDataLen; ///< Data block length in bytes.
UINT16 TDDataPtrOffset; ///< Far pointer to data buffer.
UINT16 TDDataPtrSegment; ///< Far pointer to data buffer.
} DataBlock[MAX_DATA_BLKS];
}
PXENV_UNDI_TBD_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
///
/// This is the protocol of the upper layer that is calling
/// NICTransmit call. If the upper layer has filled the media
/// header this field must be 0.
///
IN UINT8 Protocol;
#define P_UNKNOWN 0
#define P_IP 1
#define P_ARP 2
#define P_RARP 3
///
/// If this flag is 0, the NIC driver expects a pointer to the
/// destination media address in the field DestMediaAddr. If 1,
/// the NIC driver fills the broadcast address for the
/// destination.
///
IN UINT8 XmitFlag;
#define XMT_DESTADDR 0x0000 ///< destination address given
#define XMT_BROADCAST 0x0001 ///< use broadcast address
///
/// This is a pointer to the hardware address of the destination
/// media. It can be null if the destination is not known in
/// which case the XmitFlag contains 1 for broadcast. Destination
/// media address must be obtained by the upper level protocol
/// (with Address Resolution Protocol) and NIC driver does not do
/// any address resolution.
///
IN UINT16 DestAddrOffset; ///< 16-bit segment & offset of the
IN UINT16 DestAddrSegment; ///< destination media address
IN UINT16 TBDOffset; ///< 16-bit segment & offset of the
IN UINT16 TBDSegment; ///< transmit buffer descriptor of type
/// XmitBufferDesc
IN UINT32 Reserved[2];
} PXENV_UNDI_TRANSMIT_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
IN PXENV_UNDI_MCAST_ADDR_T McastBuffer; ///< In:
} PXENV_UNDI_SET_MCAST_ADDR_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
IN UINT8 StationAddress[ADDR_LEN]; ///< new address to be set
} PXENV_UNDI_SET_STATION_ADDR_T;
typedef struct s_PXENV_UNDI_SET_PACKET_FILTER {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
IN UINT8 Filter; ///< In: Receive filter value.
} PXENV_UNDI_SET_PACKET_FILTER_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
OUT UINT16 BaseIo; ///< Out: Adapter's Base IO
OUT UINT16 IntNumber; ///< Out: IRQ number
OUT UINT16 MaxTranUnit; ///< Out: MTU
OUT UINT16 HwType; ///< Out: type of protocol at hardware level
#define ETHER_TYPE 1
#define EXP_ETHER_TYPE 2
#define IEEE_TYPE 6
#define ARCNET_TYPE 7
/*++
other numbers can be obtained from rfc1010 for "Assigned
Numbers". This number may not be validated by the application
and hence adding new numbers to the list should be fine at any
time.
--*/
OUT UINT16 HwAddrLen; ///< Out: actual length of hardware address
OUT UINT8 CurrentNodeAddress[ADDR_LEN]; ///< Out: Current hardware address
OUT UINT8 PermNodeAddress[ADDR_LEN]; ///< Out: Permanent hardware address
OUT UINT16 ROMAddress; ///< Out: ROM address
OUT UINT16 RxBufCt; ///< Out: receive Queue length
OUT UINT16 TxBufCt; ///< Out: Transmit Queue length
} PXENV_UNDI_GET_INFORMATION_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
OUT UINT32 XmtGoodFrames; ///< Out: No. of good transmissions
OUT UINT32 RcvGoodFrames; ///< Out: No. of good frames received
OUT UINT32 RcvCRCErrors; ///< Out: No. of frames with CRC error
OUT UINT32 RcvResourceErrors; ///< Out: no. of frames discarded
/* Out: receive Queue full */
} PXENV_UNDI_GET_STATISTICS_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
} PXENV_UNDI_CLEAR_STATISTICS_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
} PXENV_UNDI_INITIATE_DIAGS_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
} PXENV_UNDI_FORCE_INTERRUPT_T;
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
IN UINT32 InetAddr; ///< In: IP Multicast Address
OUT UINT8 MediaAddr[ADDR_LEN]; ///< Out: corresponding hardware
/* multicast address */
} PXENV_UNDI_GET_MCAST_ADDR_T;
typedef struct {
OUT UINT16 Vendor_ID; ///< OUT:
OUT UINT16 Dev_ID; ///< OUT:
OUT UINT8 Base_Class; ///< OUT:
OUT UINT8 Sub_Class; ///< OUT:
OUT UINT8 Prog_Intf; ///< OUT: program interface
OUT UINT8 Rev; ///< OUT: Revision number
OUT UINT16 BusDevFunc; ///< OUT: Bus, Device & Function numbers
OUT UINT16 SubVendor_ID; ///< OUT:
OUT UINT16 SubDevice_ID; ///< OUT:
} PCI_INFO_T;
typedef struct {
OUT UINT32 EISA_Dev_ID; ///< Out:
OUT UINT8 Base_Class; ///< OUT:
OUT UINT8 Sub_Class; ///< OUT:
OUT UINT8 Prog_Intf; ///< OUT: program interface
OUT UINT16 CardSelNum; ///< OUT: Card Selector Number
OUT UINT8 Reserved; ///< to make it 10 bytes
} PNP_INFO_T;
typedef union {
PCI_INFO_T Pci;
PNP_INFO_T Pnp;
} PCI_PNP_INFO_T;
typedef struct {
OUT UINT16 Status; ///< OUT: PXENV_STATUS_xxx
OUT UINT8 NicType; ///< OUT: 2=PCI, 3=PnP
PCI_PNP_INFO_T PciPnpInfo;
} PXENV_UNDI_GET_NIC_TYPE_T;
typedef struct {
OUT UINT16 Status; ///< OUT: PXENV_STATUS_xxx
OUT UINT8 IfaceType[16]; ///< OUT: Type name of MAC, AsciiZ
/* format. This is used by the */
/* Universal NDIS Driver to fill */
/* the driver type in it's MAC */
/* Service specific */
/* characteristic table */
OUT UINT32 LinkSpeed; ///< OUT:
OUT UINT32 ServiceFlags; ///< OUT: as defined in NDIS Spec 2.0X
OUT UINT32 Reserved[4]; ///< OUT: will be filled with 0s till defined
} PXENV_UNDI_GET_NDIS_INFO_T;
typedef struct {
OUT UINT16 Status; ///< OUT: PXENV_STATUS_xxx
IN OUT UINT16 FuncFlag; ///< In: PXENV_UNDI_ISR_IN_xxx
/* Out: PXENV_UNDI_ISR_OUT_xxx */
OUT UINT16 BufferLength;
OUT UINT16 FrameLength;
OUT UINT16 FrameHeaderLength;
OUT UINT16 FrameOffset;
OUT UINT16 FrameSegSel;
OUT UINT8 ProtType;
OUT UINT8 PktType;
} PXENV_UNDI_ISR_T;
#define PXENV_UNDI_ISR_IN_START 1 /* This function must be first */
/* when an interrupt is received. */
/* It will tell us if the intr */
/* was generated by our device. */
#define PXENV_UNDI_ISR_IN_PROCESS 2 /* Call to start processing one of */
/* our interrupts. */
#define PXENV_UNDI_ISR_IN_GET_NEXT 3 /* Call to start/continue receiving */
/* data from receive buffer(s). */
/*++
Possible responses from PXENV_UNDI_ISR_IN_START
--*/
#define PXENV_UNDI_ISR_OUT_OURS 0 ///< This is our interrupt. Deal with it.
#define PXENV_UNDI_ISR_OUT_NOT_OURS 1 ///< This is not our interrupt.
/*++
Possible responses from PXENV_UNDI_ISR_IN_PROCESS and
PXENV_UNDI_ISR_IN_PROCESS
--*/
#define PXENV_UNDI_ISR_OUT_DONE 0 ///< We are done processing this interrupt.
#define PXENV_UNDI_ISR_OUT_TRANSMIT 2 ///< We completed a transmit interrupt.
#define PXENV_UNDI_ISR_OUT_RECEIVE 3 ///< Get data from receive buffer.
#define PXENV_UNDI_ISR_OUT_BUSY 4 /* ? */
typedef struct {
UINT16 Status; ///< Out: PXENV_STATUS_xxx
} PXENV_STOP_UNDI_T;
#define PXENV_UNDI_STARTED 1 ///< not even initialized
#define PXENV_UNDI_INITIALIZED 2 ///< initialized and closed (not opened)
#define PXENV_UNDI_OPENED 3 ///< initialized & opened
typedef struct {
OUT UINT16 Status; ///< Out: PXENV_STATUS_xxx
UINT16 UNDI_State;
} PXENV_UNDI_GET_STATE_T;
#pragma pack()
#endif

1254
IntelFrameworkModulePkg/Csm/BiosThunk/Snp16Dxe/PxeUndi.c Normal file
View File

File diff suppressed because it is too large Load Diff

67
IntelFrameworkModulePkg/Csm/BiosThunk/Snp16Dxe/Snp16Dxe.inf Normal file
View File

@@ -0,0 +1,67 @@
## @file
# Thunk wrapper UEFI driver to produce EFI SNP protocol based on legacy 16 NIC ROM.
#
# Copyright (c) 1999 - 2010, Intel Corporation. All rights reserved.<BR>
#
# This program and the accompanying materials
# are licensed and made available under the terms and conditions
# of the BSD License which accompanies this distribution. The
# full text of the license may be found at
# http://opensource.org/licenses/bsd-license.php
#
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
#
##
[Defines]
BASE_NAME = BiosSnp16
FILE_GUID = D0CAA91E-2DE4-4b0d-B3DC-09C67E854E34
MODULE_TYPE = UEFI_DRIVER
INF_VERSION = 0x00010005
VERSION_STRING = 1.0
ENTRY_POINT = BiosSnp16DriverEntryPoint
#
# The following information is for reference only and not required by the build tools.
#
# VALID_ARCHITECTURES = IA32 X64 IPF EBC
#
# DRIVER_BINDING = gBiosSnp16DriverBinding
# COMPONENT_NAME = gBiosSnp16ComponentName
#
[Sources]
BiosSnp16.h
BiosSnp16.c
Misc.c
Pxe.h
PxeUndi.c
ComponentName.c
[Libraryclasses]
UefiDriverEntryPoint
DebugLib
BaseMemoryLib
UefiBootServicesTableLib
UefiLib
BaseLib
DevicePathLib
MemoryAllocationLib
[Guids]
gEfiEventExitBootServicesGuid
[Protocols]
gEfiNetworkInterfaceIdentifierProtocolGuid
gEfiDevicePathProtocolGuid
gEfiSimpleNetworkProtocolGuid
gEfiPciIoProtocolGuid
gEfiLegacyBiosProtocolGuid
[Packages]
MdePkg/MdePkg.dec
IntelFrameworkPkg/IntelFrameworkPkg.dec