add UndiRuntimeDxe from MdeModulePkg to OptionRomPkg.
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8738 6f19259b-4bc3-4df7-8a09-765794883524
diff --git a/OptionRomPkg/UndiRuntimeDxe/Decode.c b/OptionRomPkg/UndiRuntimeDxe/Decode.c
new file mode 100644
index 0000000..670fa18
--- /dev/null
+++ b/OptionRomPkg/UndiRuntimeDxe/Decode.c
@@ -0,0 +1,1477 @@
+/** @file
+ Provides the basic UNID functions.
+
+Copyright (c) 2006 - 2007, Intel Corporation
+All rights reserved. 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 "Undi32.h"
+
+//
+// Global variables defined in this file
+//
+UNDI_CALL_TABLE api_table[PXE_OPCODE_LAST_VALID+1] = { \
+ {PXE_CPBSIZE_NOT_USED,PXE_DBSIZE_NOT_USED,0, (UINT16)(ANY_STATE),UNDI_GetState },\
+ {(UINT16)(DONT_CHECK),PXE_DBSIZE_NOT_USED,0,(UINT16)(ANY_STATE),UNDI_Start },\
+ {PXE_CPBSIZE_NOT_USED,PXE_DBSIZE_NOT_USED,0,MUST_BE_STARTED,UNDI_Stop },\
+ {PXE_CPBSIZE_NOT_USED,sizeof(PXE_DB_GET_INIT_INFO),0,MUST_BE_STARTED, UNDI_GetInitInfo },\
+ {PXE_CPBSIZE_NOT_USED,sizeof(PXE_DB_GET_CONFIG_INFO),0,MUST_BE_STARTED, UNDI_GetConfigInfo },\
+ {sizeof(PXE_CPB_INITIALIZE),(UINT16)(DONT_CHECK),(UINT16)(DONT_CHECK),MUST_BE_STARTED,UNDI_Initialize },\
+ {PXE_CPBSIZE_NOT_USED,PXE_DBSIZE_NOT_USED,(UINT16)(DONT_CHECK), MUST_BE_INITIALIZED,UNDI_Reset },\
+ {PXE_CPBSIZE_NOT_USED,PXE_DBSIZE_NOT_USED,0, MUST_BE_INITIALIZED,UNDI_Shutdown },\
+ {PXE_CPBSIZE_NOT_USED,PXE_DBSIZE_NOT_USED,(UINT16)(DONT_CHECK), MUST_BE_INITIALIZED,UNDI_Interrupt },\
+ {(UINT16)(DONT_CHECK),(UINT16)(DONT_CHECK),(UINT16)(DONT_CHECK), MUST_BE_INITIALIZED, UNDI_RecFilter },\
+ {(UINT16)(DONT_CHECK),(UINT16)(DONT_CHECK),(UINT16)(DONT_CHECK), MUST_BE_INITIALIZED, UNDI_StnAddr },\
+ {PXE_CPBSIZE_NOT_USED, (UINT16)(DONT_CHECK), (UINT16)(DONT_CHECK), MUST_BE_INITIALIZED, UNDI_Statistics },\
+ {sizeof(PXE_CPB_MCAST_IP_TO_MAC),sizeof(PXE_DB_MCAST_IP_TO_MAC), (UINT16)(DONT_CHECK),MUST_BE_INITIALIZED, UNDI_ip2mac },\
+ {(UINT16)(DONT_CHECK),(UINT16)(DONT_CHECK),(UINT16)(DONT_CHECK), MUST_BE_INITIALIZED, UNDI_NVData },\
+ {PXE_CPBSIZE_NOT_USED,(UINT16)(DONT_CHECK),(UINT16)(DONT_CHECK), MUST_BE_INITIALIZED, UNDI_Status },\
+ {(UINT16)(DONT_CHECK),PXE_DBSIZE_NOT_USED,(UINT16)(DONT_CHECK), MUST_BE_INITIALIZED, UNDI_FillHeader },\
+ {(UINT16)(DONT_CHECK),PXE_DBSIZE_NOT_USED,(UINT16)(DONT_CHECK), MUST_BE_INITIALIZED, UNDI_Transmit },\
+ {sizeof(PXE_CPB_RECEIVE),sizeof(PXE_DB_RECEIVE),0,MUST_BE_INITIALIZED, UNDI_Receive } \
+};
+
+//
+// end of global variables
+//
+
+
+/**
+ This routine determines the operational state of the UNDI. It updates the state flags in the
+ Command Descriptor Block based on information derived from the AdapterInfo instance data.
+ To ensure the command has completed successfully, CdbPtr->StatCode will contain the result of
+ the command execution.
+ The CdbPtr->StatFlags will contain a STOPPED, STARTED, or INITIALIZED state once the command
+ has successfully completed.
+ Keep in mind the AdapterInfo->State is the active state of the adapter (based on software
+ interrogation), and the CdbPtr->StateFlags is the passed back information that is reflected
+ to the caller of the UNDI API.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_GetState (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ CdbPtr->StatFlags = (PXE_STATFLAGS) (CdbPtr->StatFlags | AdapterInfo->State);
+ return ;
+}
+
+
+/**
+ This routine is used to change the operational state of the UNDI from stopped to started.
+ It will do this as long as the adapter's state is PXE_STATFLAGS_GET_STATE_STOPPED, otherwise
+ the CdbPtr->StatFlags will reflect a command failure, and the CdbPtr->StatCode will reflect the
+ UNDI as having already been started.
+ This routine is modified to reflect the undi 1.1 specification changes. The
+ changes in the spec are mainly in the callback routines, the new spec adds
+ 3 more callbacks and a unique id.
+ Since this UNDI supports both old and new undi specifications,
+ The NIC's data structure is filled in with the callback routines (depending
+ on the version) pointed to in the caller's CpbPtr. This seeds the Delay,
+ Virt2Phys, Block, and Mem_IO for old and new versions and Map_Mem, UnMap_Mem
+ and Sync_Mem routines and a unique id variable for the new version.
+ This is the function which an external entity (SNP, O/S, etc) would call
+ to provide it's I/O abstraction to the UNDI.
+ It's final action is to change the AdapterInfo->State to PXE_STATFLAGS_GET_STATE_STARTED.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_Start (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ PXE_CPB_START_30 *CpbPtr;
+ PXE_CPB_START_31 *CpbPtr_31;
+
+ //
+ // check if it is already started.
+ //
+ if (AdapterInfo->State != PXE_STATFLAGS_GET_STATE_STOPPED) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_ALREADY_STARTED;
+ return ;
+ }
+
+ if (CdbPtr->CPBsize != sizeof(PXE_CPB_START_30) &&
+ CdbPtr->CPBsize != sizeof(PXE_CPB_START_31)) {
+
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ CpbPtr = (PXE_CPB_START_30 *) (UINTN) (CdbPtr->CPBaddr);
+ CpbPtr_31 = (PXE_CPB_START_31 *) (UINTN) (CdbPtr->CPBaddr);
+
+ if (AdapterInfo->VersionFlag == 0x30) {
+ AdapterInfo->Delay_30 = (bsptr_30) (UINTN) CpbPtr->Delay;
+ AdapterInfo->Virt2Phys_30 = (virtphys_30) (UINTN) CpbPtr->Virt2Phys;
+ AdapterInfo->Block_30 = (block_30) (UINTN) CpbPtr->Block;
+ //
+ // patch for old buggy 3.0 code:
+ // In EFI1.0 undi used to provide the full (absolute) I/O address to the
+ // i/o calls and SNP used to provide a callback that used GlobalIoFncs and
+ // everything worked fine! In EFI 1.1, UNDI is not using the full
+ // i/o or memory address to access the device, The base values for the i/o
+ // and memory address is abstracted by the device specific PciIoFncs and
+ // UNDI only uses the offset values. Since UNDI3.0 cannot provide any
+ // identification to SNP, SNP cannot use nic specific PciIoFncs callback!
+ //
+ // To fix this and make undi3.0 work with SNP in EFI1.1 we
+ // use a TmpMemIo function that is defined in init.c
+ // This breaks the runtime driver feature of undi, but what to do
+ // if we have to provide the 3.0 compatibility (including the 3.0 bugs)
+ //
+ // This TmpMemIo function also takes a UniqueId parameter
+ // (as in undi3.1 design) and so initialize the UniqueId as well here
+ // Note: AdapterInfo->Mem_Io_30 is just filled for consistency with other
+ // parameters but never used, we only use Mem_Io field in the In/Out routines
+ // inside e100b.c.
+ //
+ AdapterInfo->Mem_Io_30 = (mem_io_30) (UINTN) CpbPtr->Mem_IO;
+ AdapterInfo->Mem_Io = (mem_io) (UINTN) TmpMemIo;
+ AdapterInfo->Unique_ID = (UINT64) (UINTN) AdapterInfo;
+
+ } else {
+ AdapterInfo->Delay = (bsptr) (UINTN) CpbPtr_31->Delay;
+ AdapterInfo->Virt2Phys = (virtphys) (UINTN) CpbPtr_31->Virt2Phys;
+ AdapterInfo->Block = (block) (UINTN) CpbPtr_31->Block;
+ AdapterInfo->Mem_Io = (mem_io) (UINTN) CpbPtr_31->Mem_IO;
+
+ AdapterInfo->Map_Mem = (map_mem) (UINTN) CpbPtr_31->Map_Mem;
+ AdapterInfo->UnMap_Mem = (unmap_mem) (UINTN) CpbPtr_31->UnMap_Mem;
+ AdapterInfo->Sync_Mem = (sync_mem) (UINTN) CpbPtr_31->Sync_Mem;
+ AdapterInfo->Unique_ID = CpbPtr_31->Unique_ID;
+ }
+
+ AdapterInfo->State = PXE_STATFLAGS_GET_STATE_STARTED;
+
+ return ;
+}
+
+
+/**
+ This routine is used to change the operational state of the UNDI from started to stopped.
+ It will not do this if the adapter's state is PXE_STATFLAGS_GET_STATE_INITIALIZED, otherwise
+ the CdbPtr->StatFlags will reflect a command failure, and the CdbPtr->StatCode will reflect the
+ UNDI as having already not been shut down.
+ The NIC's data structure will have the Delay, Virt2Phys, and Block, pointers zero'd out..
+ It's final action is to change the AdapterInfo->State to PXE_STATFLAGS_GET_STATE_STOPPED.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_Stop (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ if (AdapterInfo->State == PXE_STATFLAGS_GET_STATE_INITIALIZED) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_NOT_SHUTDOWN;
+ return ;
+ }
+
+ AdapterInfo->Delay_30 = 0;
+ AdapterInfo->Virt2Phys_30 = 0;
+ AdapterInfo->Block_30 = 0;
+
+ AdapterInfo->Delay = 0;
+ AdapterInfo->Virt2Phys = 0;
+ AdapterInfo->Block = 0;
+
+ AdapterInfo->Map_Mem = 0;
+ AdapterInfo->UnMap_Mem = 0;
+ AdapterInfo->Sync_Mem = 0;
+
+ AdapterInfo->State = PXE_STATFLAGS_GET_STATE_STOPPED;
+
+ return ;
+}
+
+
+/**
+ This routine is used to retrieve the initialization information that is needed by drivers and
+ applications to initialize the UNDI. This will fill in data in the Data Block structure that is
+ pointed to by the caller's CdbPtr->DBaddr. The fields filled in are as follows:
+ MemoryRequired, FrameDataLen, LinkSpeeds[0-3], NvCount, NvWidth, MediaHeaderLen, HWaddrLen,
+ MCastFilterCnt, TxBufCnt, TxBufSize, RxBufCnt, RxBufSize, IFtype, Duplex, and LoopBack.
+ In addition, the CdbPtr->StatFlags ORs in that this NIC supports cable detection. (APRIORI knowledge)
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_GetInitInfo (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ PXE_DB_GET_INIT_INFO *DbPtr;
+
+ DbPtr = (PXE_DB_GET_INIT_INFO *) (UINTN) (CdbPtr->DBaddr);
+
+ DbPtr->MemoryRequired = MEMORY_NEEDED;
+ DbPtr->FrameDataLen = PXE_MAX_TXRX_UNIT_ETHER;
+ DbPtr->LinkSpeeds[0] = 10;
+ DbPtr->LinkSpeeds[1] = 100;
+ DbPtr->LinkSpeeds[2] = DbPtr->LinkSpeeds[3] = 0;
+ DbPtr->NvCount = MAX_EEPROM_LEN;
+ DbPtr->NvWidth = 4;
+ DbPtr->MediaHeaderLen = PXE_MAC_HEADER_LEN_ETHER;
+ DbPtr->HWaddrLen = PXE_HWADDR_LEN_ETHER;
+ DbPtr->MCastFilterCnt = MAX_MCAST_ADDRESS_CNT;
+
+ DbPtr->TxBufCnt = TX_BUFFER_COUNT;
+ DbPtr->TxBufSize = sizeof (TxCB);
+ DbPtr->RxBufCnt = RX_BUFFER_COUNT;
+ DbPtr->RxBufSize = sizeof (RxFD);
+
+ DbPtr->IFtype = PXE_IFTYPE_ETHERNET;
+ DbPtr->SupportedDuplexModes = PXE_DUPLEX_ENABLE_FULL_SUPPORTED |
+ PXE_DUPLEX_FORCE_FULL_SUPPORTED;
+ DbPtr->SupportedLoopBackModes = PXE_LOOPBACK_INTERNAL_SUPPORTED |
+ PXE_LOOPBACK_EXTERNAL_SUPPORTED;
+
+ CdbPtr->StatFlags |= PXE_STATFLAGS_CABLE_DETECT_SUPPORTED;
+ return ;
+}
+
+
+/**
+ This routine is used to retrieve the configuration information about the NIC being controlled by
+ this driver. This will fill in data in the Data Block structure that is pointed to by the caller's CdbPtr->DBaddr.
+ The fields filled in are as follows:
+ DbPtr->pci.BusType, DbPtr->pci.Bus, DbPtr->pci.Device, and DbPtr->pci.
+ In addition, the DbPtr->pci.Config.Dword[0-63] grabs a copy of this NIC's PCI configuration space.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_GetConfigInfo (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ UINT16 Index;
+ PXE_DB_GET_CONFIG_INFO *DbPtr;
+
+ DbPtr = (PXE_DB_GET_CONFIG_INFO *) (UINTN) (CdbPtr->DBaddr);
+
+ DbPtr->pci.BusType = PXE_BUSTYPE_PCI;
+ DbPtr->pci.Bus = AdapterInfo->Bus;
+ DbPtr->pci.Device = AdapterInfo->Device;
+ DbPtr->pci.Function = AdapterInfo->Function;
+
+ for (Index = 0; Index < MAX_PCI_CONFIG_LEN; Index++) {
+ DbPtr->pci.Config.Dword[Index] = AdapterInfo->Config[Index];
+ }
+
+ return ;
+}
+
+
+/**
+ This routine resets the network adapter and initializes the UNDI using the parameters supplied in
+ the CPB. This command must be issued before the network adapter can be setup to transmit and
+ receive packets.
+ Once the memory requirements of the UNDI are obtained by using the GetInitInfo command, a block
+ of non-swappable memory may need to be allocated. The address of this memory must be passed to
+ UNDI during the Initialize in the CPB. This memory is used primarily for transmit and receive buffers.
+ The fields CableDetect, LinkSpeed, Duplex, LoopBack, MemoryPtr, and MemoryLength are set with information
+ that was passed in the CPB and the NIC is initialized.
+ If the NIC initialization fails, the CdbPtr->StatFlags are updated with PXE_STATFLAGS_COMMAND_FAILED
+ Otherwise, AdapterInfo->State is updated with PXE_STATFLAGS_GET_STATE_INITIALIZED showing the state of
+ the UNDI is now initialized.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_Initialize (
+ IN PXE_CDB *CdbPtr,
+ NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ PXE_CPB_INITIALIZE *CpbPtr;
+
+ if ((CdbPtr->OpFlags != PXE_OPFLAGS_INITIALIZE_DETECT_CABLE) &&
+ (CdbPtr->OpFlags != PXE_OPFLAGS_INITIALIZE_DO_NOT_DETECT_CABLE)) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ //
+ // check if it is already initialized
+ //
+ if (AdapterInfo->State == PXE_STATFLAGS_GET_STATE_INITIALIZED) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_ALREADY_INITIALIZED;
+ return ;
+ }
+
+ CpbPtr = (PXE_CPB_INITIALIZE *) (UINTN) CdbPtr->CPBaddr;
+
+ if (CpbPtr->MemoryLength < (UINT32) MEMORY_NEEDED) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CPB;
+ return ;
+ }
+
+ //
+ // default behaviour is to detect the cable, if the 3rd param is 1,
+ // do not do that
+ //
+ AdapterInfo->CableDetect = (UINT8) ((CdbPtr->OpFlags == (UINT16) PXE_OPFLAGS_INITIALIZE_DO_NOT_DETECT_CABLE) ? (UINT8) 0 : (UINT8) 1);
+ AdapterInfo->LinkSpeedReq = (UINT16) CpbPtr->LinkSpeed;
+ AdapterInfo->DuplexReq = CpbPtr->DuplexMode;
+ AdapterInfo->LoopBack = CpbPtr->LoopBackMode;
+ AdapterInfo->MemoryPtr = CpbPtr->MemoryAddr;
+ AdapterInfo->MemoryLength = CpbPtr->MemoryLength;
+
+ CdbPtr->StatCode = (PXE_STATCODE) E100bInit (AdapterInfo);
+
+ if (CdbPtr->StatCode != PXE_STATCODE_SUCCESS) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ } else {
+ AdapterInfo->State = PXE_STATFLAGS_GET_STATE_INITIALIZED;
+ }
+
+ return ;
+}
+
+
+/**
+ This routine resets the network adapter and initializes the UNDI using the parameters supplied in
+ the CPB. The transmit and receive queues are emptied and any pending interrupts are cleared.
+ If the NIC reset fails, the CdbPtr->StatFlags are updated with PXE_STATFLAGS_COMMAND_FAILED
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_Reset (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ if (CdbPtr->OpFlags != PXE_OPFLAGS_NOT_USED &&
+ CdbPtr->OpFlags != PXE_OPFLAGS_RESET_DISABLE_INTERRUPTS &&
+ CdbPtr->OpFlags != PXE_OPFLAGS_RESET_DISABLE_FILTERS ) {
+
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ CdbPtr->StatCode = (UINT16) E100bReset (AdapterInfo, CdbPtr->OpFlags);
+
+ if (CdbPtr->StatCode != PXE_STATCODE_SUCCESS) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ }
+}
+
+
+/**
+ This routine resets the network adapter and leaves it in a safe state for another driver to
+ initialize. Any pending transmits or receives are lost. Receive filters and external
+ interrupt enables are disabled. Once the UNDI has been shutdown, it can then be stopped
+ or initialized again.
+ If the NIC reset fails, the CdbPtr->StatFlags are updated with PXE_STATFLAGS_COMMAND_FAILED
+ Otherwise, AdapterInfo->State is updated with PXE_STATFLAGS_GET_STATE_STARTED showing the state of
+ the NIC as being started.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_Shutdown (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ //
+ // do the shutdown stuff here
+ //
+ CdbPtr->StatCode = (UINT16) E100bShutdown (AdapterInfo);
+
+ if (CdbPtr->StatCode != PXE_STATCODE_SUCCESS) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ } else {
+ AdapterInfo->State = PXE_STATFLAGS_GET_STATE_STARTED;
+ }
+
+ return ;
+}
+
+
+/**
+ This routine can be used to read and/or change the current external interrupt enable
+ settings. Disabling an external interrupt enable prevents and external (hardware)
+ interrupt from being signaled by the network device. Internally the interrupt events
+ can still be polled by using the UNDI_GetState command.
+ The resulting information on the interrupt state will be passed back in the CdbPtr->StatFlags.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_Interrupt (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ UINT8 IntMask;
+
+ IntMask = (UINT8)(UINTN)(CdbPtr->OpFlags & (PXE_OPFLAGS_INTERRUPT_RECEIVE |
+ PXE_OPFLAGS_INTERRUPT_TRANSMIT |
+ PXE_OPFLAGS_INTERRUPT_COMMAND |
+ PXE_OPFLAGS_INTERRUPT_SOFTWARE));
+
+ switch (CdbPtr->OpFlags & PXE_OPFLAGS_INTERRUPT_OPMASK) {
+ case PXE_OPFLAGS_INTERRUPT_READ:
+ break;
+
+ case PXE_OPFLAGS_INTERRUPT_ENABLE:
+ if (IntMask == 0) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ AdapterInfo->int_mask = IntMask;
+ E100bSetInterruptState (AdapterInfo);
+ break;
+
+ case PXE_OPFLAGS_INTERRUPT_DISABLE:
+ if (IntMask != 0) {
+ AdapterInfo->int_mask = (UINT16) (AdapterInfo->int_mask & ~(IntMask));
+ E100bSetInterruptState (AdapterInfo);
+ break;
+ }
+
+ //
+ // else fall thru.
+ //
+ default:
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ if ((AdapterInfo->int_mask & PXE_OPFLAGS_INTERRUPT_RECEIVE) != 0) {
+ CdbPtr->StatFlags |= PXE_STATFLAGS_INTERRUPT_RECEIVE;
+
+ }
+
+ if ((AdapterInfo->int_mask & PXE_OPFLAGS_INTERRUPT_TRANSMIT) != 0) {
+ CdbPtr->StatFlags |= PXE_STATFLAGS_INTERRUPT_TRANSMIT;
+
+ }
+
+ if ((AdapterInfo->int_mask & PXE_OPFLAGS_INTERRUPT_COMMAND) != 0) {
+ CdbPtr->StatFlags |= PXE_STATFLAGS_INTERRUPT_COMMAND;
+
+ }
+
+ return ;
+}
+
+
+/**
+ This routine is used to read and change receive filters and, if supported, read
+ and change multicast MAC address filter list.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_RecFilter (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ UINT16 NewFilter;
+ UINT16 OpFlags;
+ PXE_DB_RECEIVE_FILTERS *DbPtr;
+ UINT8 *MacAddr;
+ UINTN MacCount;
+ UINT16 Index;
+ UINT16 copy_len;
+ UINT8 *ptr1;
+ UINT8 *ptr2;
+ OpFlags = CdbPtr->OpFlags;
+ NewFilter = (UINT16) (OpFlags & 0x1F);
+
+ switch (OpFlags & PXE_OPFLAGS_RECEIVE_FILTER_OPMASK) {
+ case PXE_OPFLAGS_RECEIVE_FILTER_READ:
+
+ //
+ // not expecting a cpb, not expecting any filter bits
+ //
+ if ((NewFilter != 0) || (CdbPtr->CPBsize != 0)) {
+ goto BadCdb;
+
+ }
+
+ if ((NewFilter & PXE_OPFLAGS_RECEIVE_FILTER_RESET_MCAST_LIST) == 0) {
+ goto JustRead;
+
+ }
+
+ NewFilter = (UINT16) (NewFilter | AdapterInfo->Rx_Filter);
+ //
+ // all other flags are ignored except mcast_reset
+ //
+ break;
+
+ case PXE_OPFLAGS_RECEIVE_FILTER_ENABLE:
+ //
+ // there should be atleast one other filter bit set.
+ //
+ if (NewFilter == 0) {
+ //
+ // nothing to enable
+ //
+ goto BadCdb;
+ }
+
+ if (CdbPtr->CPBsize != 0) {
+ //
+ // this must be a multicast address list!
+ // don't accept the list unless selective_mcast is set
+ // don't accept confusing mcast settings with this
+ //
+ if (((NewFilter & PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST) == 0) ||
+ ((NewFilter & PXE_OPFLAGS_RECEIVE_FILTER_RESET_MCAST_LIST) != 0) ||
+ ((NewFilter & PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST) != 0) ||
+ ((CdbPtr->CPBsize % sizeof (PXE_MAC_ADDR)) != 0) ) {
+ goto BadCdb;
+ }
+
+ MacAddr = (UINT8 *) ((UINTN) (CdbPtr->CPBaddr));
+ MacCount = CdbPtr->CPBsize / sizeof (PXE_MAC_ADDR);
+
+ for (; MacCount-- != 0; MacAddr += sizeof (PXE_MAC_ADDR)) {
+ if (MacAddr[0] != 0x01 || MacAddr[1] != 0x00 || MacAddr[2] != 0x5E || (MacAddr[3] & 0x80) != 0) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CPB;
+ return ;
+ }
+ }
+ }
+
+ //
+ // check selective mcast case enable case
+ //
+ if ((OpFlags & PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST) != 0) {
+ if (((OpFlags & PXE_OPFLAGS_RECEIVE_FILTER_RESET_MCAST_LIST) != 0) ||
+ ((OpFlags & PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST) != 0) ) {
+ goto BadCdb;
+
+ }
+ //
+ // if no cpb, make sure we have an old list
+ //
+ if ((CdbPtr->CPBsize == 0) && (AdapterInfo->mcast_list.list_len == 0)) {
+ goto BadCdb;
+ }
+ }
+ //
+ // if you want to enable anything, you got to have unicast
+ // and you have what you already enabled!
+ //
+ NewFilter = (UINT16) (NewFilter | (PXE_OPFLAGS_RECEIVE_FILTER_UNICAST | AdapterInfo->Rx_Filter));
+
+ break;
+
+ case PXE_OPFLAGS_RECEIVE_FILTER_DISABLE:
+
+ //
+ // mcast list not expected, i.e. no cpb here!
+ //
+ if (CdbPtr->CPBsize != PXE_CPBSIZE_NOT_USED) {
+ goto BadCdb;
+ }
+
+ NewFilter = (UINT16) ((~(CdbPtr->OpFlags & 0x1F)) & AdapterInfo->Rx_Filter);
+
+ break;
+
+ default:
+ goto BadCdb;
+ }
+
+ if ((OpFlags & PXE_OPFLAGS_RECEIVE_FILTER_RESET_MCAST_LIST) != 0) {
+ AdapterInfo->mcast_list.list_len = 0;
+ NewFilter &= (~PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST);
+ }
+
+ E100bSetfilter (AdapterInfo, NewFilter, CdbPtr->CPBaddr, CdbPtr->CPBsize);
+
+JustRead:
+ //
+ // give the current mcast list
+ //
+ if ((CdbPtr->DBsize != 0) && (AdapterInfo->mcast_list.list_len != 0)) {
+ //
+ // copy the mc list to db
+ //
+
+ DbPtr = (PXE_DB_RECEIVE_FILTERS *) (UINTN) CdbPtr->DBaddr;
+ ptr1 = (UINT8 *) (&DbPtr->MCastList[0]);
+
+ //
+ // DbPtr->mc_count = AdapterInfo->mcast_list.list_len;
+ //
+ copy_len = (UINT16) (AdapterInfo->mcast_list.list_len * PXE_MAC_LENGTH);
+
+ if (copy_len > CdbPtr->DBsize) {
+ copy_len = CdbPtr->DBsize;
+
+ }
+
+ ptr2 = (UINT8 *) (&AdapterInfo->mcast_list.mc_list[0]);
+ for (Index = 0; Index < copy_len; Index++) {
+ ptr1[Index] = ptr2[Index];
+ }
+ }
+ //
+ // give the stat flags here
+ //
+ if (AdapterInfo->Receive_Started) {
+ CdbPtr->StatFlags = (PXE_STATFLAGS) (CdbPtr->StatFlags | AdapterInfo->Rx_Filter);
+
+ }
+
+ return ;
+
+BadCdb:
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+}
+
+
+/**
+ This routine is used to get the current station and broadcast MAC addresses, and to change the
+ current station MAC address.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_StnAddr (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ PXE_CPB_STATION_ADDRESS *CpbPtr;
+ PXE_DB_STATION_ADDRESS *DbPtr;
+ UINT16 Index;
+
+ if (CdbPtr->OpFlags == PXE_OPFLAGS_STATION_ADDRESS_RESET) {
+ //
+ // configure the permanent address.
+ // change the AdapterInfo->CurrentNodeAddress field.
+ //
+ if (CompareMem (
+ &AdapterInfo->CurrentNodeAddress[0],
+ &AdapterInfo->PermNodeAddress[0],
+ PXE_MAC_LENGTH
+ ) != 0) {
+ for (Index = 0; Index < PXE_MAC_LENGTH; Index++) {
+ AdapterInfo->CurrentNodeAddress[Index] = AdapterInfo->PermNodeAddress[Index];
+ }
+
+ E100bSetupIAAddr (AdapterInfo);
+ }
+ }
+
+ if (CdbPtr->CPBaddr != (UINT64) 0) {
+ CpbPtr = (PXE_CPB_STATION_ADDRESS *) (UINTN) (CdbPtr->CPBaddr);
+ //
+ // configure the new address
+ //
+ for (Index = 0; Index < PXE_MAC_LENGTH; Index++) {
+ AdapterInfo->CurrentNodeAddress[Index] = CpbPtr->StationAddr[Index];
+ }
+
+ E100bSetupIAAddr (AdapterInfo);
+ }
+
+ if (CdbPtr->DBaddr != (UINT64) 0) {
+ DbPtr = (PXE_DB_STATION_ADDRESS *) (UINTN) (CdbPtr->DBaddr);
+ //
+ // fill it with the new values
+ //
+ for (Index = 0; Index < PXE_MAC_LENGTH; Index++) {
+ DbPtr->StationAddr[Index] = AdapterInfo->CurrentNodeAddress[Index];
+ DbPtr->BroadcastAddr[Index] = AdapterInfo->BroadcastNodeAddress[Index];
+ DbPtr->PermanentAddr[Index] = AdapterInfo->PermNodeAddress[Index];
+ }
+ }
+
+ return ;
+}
+
+
+/**
+ This routine is used to read and clear the NIC traffic statistics. This command is supported only
+ if the !PXE structure's Implementation flags say so.
+ Results will be parsed out in the following manner:
+ CdbPtr->DBaddr.Data[0] R Total Frames (Including frames with errors and dropped frames)
+ CdbPtr->DBaddr.Data[1] R Good Frames (All frames copied into receive buffer)
+ CdbPtr->DBaddr.Data[2] R Undersize Frames (Frames below minimum length for media <64 for ethernet)
+ CdbPtr->DBaddr.Data[4] R Dropped Frames (Frames that were dropped because receive buffers were full)
+ CdbPtr->DBaddr.Data[8] R CRC Error Frames (Frames with alignment or CRC errors)
+ CdbPtr->DBaddr.Data[A] T Total Frames (Including frames with errors and dropped frames)
+ CdbPtr->DBaddr.Data[B] T Good Frames (All frames copied into transmit buffer)
+ CdbPtr->DBaddr.Data[C] T Undersize Frames (Frames below minimum length for media <64 for ethernet)
+ CdbPtr->DBaddr.Data[E] T Dropped Frames (Frames that were dropped because of collisions)
+ CdbPtr->DBaddr.Data[14] T Total Collision Frames (Total collisions on this subnet)
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_Statistics (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ if ((CdbPtr->OpFlags &~(PXE_OPFLAGS_STATISTICS_RESET)) != 0) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ if ((CdbPtr->OpFlags & PXE_OPFLAGS_STATISTICS_RESET) != 0) {
+ //
+ // Reset the statistics
+ //
+ CdbPtr->StatCode = (UINT16) E100bStatistics (AdapterInfo, 0, 0);
+ } else {
+ CdbPtr->StatCode = (UINT16) E100bStatistics (AdapterInfo, CdbPtr->DBaddr, CdbPtr->DBsize);
+ }
+
+ return ;
+}
+
+
+/**
+ This routine is used to translate a multicast IP address to a multicast MAC address.
+ This results in a MAC address composed of 25 bits of fixed data with the upper 23 bits of the IP
+ address being appended to it. Results passed back in the equivalent of CdbPtr->DBaddr->MAC[0-5].
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_ip2mac (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ PXE_CPB_MCAST_IP_TO_MAC *CpbPtr;
+ PXE_DB_MCAST_IP_TO_MAC *DbPtr;
+ UINT8 *TmpPtr;
+
+ CpbPtr = (PXE_CPB_MCAST_IP_TO_MAC *) (UINTN) CdbPtr->CPBaddr;
+ DbPtr = (PXE_DB_MCAST_IP_TO_MAC *) (UINTN) CdbPtr->DBaddr;
+
+ if ((CdbPtr->OpFlags & PXE_OPFLAGS_MCAST_IPV6_TO_MAC) != 0) {
+ //
+ // for now this is not supported
+ //
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_UNSUPPORTED;
+ return ;
+ }
+
+ TmpPtr = (UINT8 *) (&CpbPtr->IP.IPv4);
+ //
+ // check if the ip given is a mcast IP
+ //
+ if ((TmpPtr[0] & 0xF0) != 0xE0) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CPB;
+ }
+ //
+ // take the last 23 bits in IP.
+ // be very careful. accessing word on a non-word boundary will hang motherboard codenamed Big Sur
+ // casting the mac array (in the middle) to a UINT32 pointer and accessing
+ // the UINT32 content hung the system...
+ //
+ DbPtr->MAC[0] = 0x01;
+ DbPtr->MAC[1] = 0x00;
+ DbPtr->MAC[2] = 0x5e;
+ DbPtr->MAC[3] = (UINT8) (TmpPtr[1] & 0x7f);
+ DbPtr->MAC[4] = (UINT8) TmpPtr[2];
+ DbPtr->MAC[5] = (UINT8) TmpPtr[3];
+
+ return ;
+}
+
+
+/**
+ This routine is used to read and write non-volatile storage on the NIC (if supported). The NVRAM
+ could be EEPROM, FLASH, or battery backed RAM.
+ This is an optional function according to the UNDI specification (or will be......)
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_NVData (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ PXE_DB_NVDATA *DbPtr;
+ UINT16 Index;
+
+ if ((CdbPtr->OpFlags == PXE_OPFLAGS_NVDATA_READ) != 0) {
+
+ if ((CdbPtr->DBsize == PXE_DBSIZE_NOT_USED) != 0) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ DbPtr = (PXE_DB_NVDATA *) (UINTN) CdbPtr->DBaddr;
+
+ for (Index = 0; Index < MAX_PCI_CONFIG_LEN; Index++) {
+ DbPtr->Data.Dword[Index] = AdapterInfo->NVData[Index];
+
+ }
+
+ } else {
+ //
+ // no write for now
+ //
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_UNSUPPORTED;
+ }
+
+ return ;
+}
+
+
+/**
+ This routine returns the current interrupt status and/or the transmitted buffer addresses.
+ If the current interrupt status is returned, pending interrupts will be acknowledged by this
+ command. Transmitted buffer addresses that are written to the DB are removed from the transmit
+ buffer queue.
+ Normally, this command would be polled with interrupts disabled.
+ The transmit buffers are returned in CdbPtr->DBaddr->TxBufer[0 - NumEntries].
+ The interrupt status is returned in CdbPtr->StatFlags.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_Status (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ PXE_DB_GET_STATUS *DbPtr;
+ PXE_DB_GET_STATUS TmpGetStatus;
+ UINT16 Index;
+ UINT16 Status;
+ UINT16 NumEntries;
+ RxFD *RxPtr;
+
+ //
+ // Fill in temporary GetStatus storage.
+ //
+ RxPtr = &AdapterInfo->rx_ring[AdapterInfo->cur_rx_ind];
+
+ if ((RxPtr->cb_header.status & RX_COMPLETE) != 0) {
+ TmpGetStatus.RxFrameLen = RxPtr->ActualCount & 0x3fff;
+ } else {
+ TmpGetStatus.RxFrameLen = 0;
+ }
+
+ TmpGetStatus.reserved = 0;
+
+ //
+ // Fill in size of next available receive packet and
+ // reserved field in caller's DB storage.
+ //
+ DbPtr = (PXE_DB_GET_STATUS *) (UINTN) CdbPtr->DBaddr;
+
+ if (CdbPtr->DBsize > 0 && CdbPtr->DBsize < sizeof (UINT32) * 2) {
+ CopyMem (DbPtr, &TmpGetStatus, CdbPtr->DBsize);
+ } else {
+ CopyMem (DbPtr, &TmpGetStatus, sizeof (UINT32) * 2);
+ }
+
+ //
+ //
+ //
+ if ((CdbPtr->OpFlags & PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS) != 0) {
+ //
+ // DBsize of zero is invalid if Tx buffers are requested.
+ //
+ if (CdbPtr->DBsize == 0) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ //
+ // remember this b4 we overwrite
+ //
+ NumEntries = (UINT16) (CdbPtr->DBsize - sizeof (UINT64));
+
+ //
+ // We already filled in 2 UINT32s.
+ //
+ CdbPtr->DBsize = sizeof (UINT32) * 2;
+
+ //
+ // will claim any hanging free CBs
+ //
+ CheckCBList (AdapterInfo);
+
+ if (AdapterInfo->xmit_done_head == AdapterInfo->xmit_done_tail) {
+ CdbPtr->StatFlags |= PXE_STATFLAGS_GET_STATUS_TXBUF_QUEUE_EMPTY;
+ } else {
+ for (Index = 0; NumEntries >= sizeof (UINT64); Index++, NumEntries -= sizeof (UINT64)) {
+ if (AdapterInfo->xmit_done_head != AdapterInfo->xmit_done_tail) {
+ DbPtr->TxBuffer[Index] = AdapterInfo->xmit_done[AdapterInfo->xmit_done_head];
+ AdapterInfo->xmit_done_head = next (AdapterInfo->xmit_done_head);
+ CdbPtr->DBsize += sizeof (UINT64);
+ } else {
+ break;
+ }
+ }
+ }
+
+ if (AdapterInfo->xmit_done_head != AdapterInfo->xmit_done_tail) {
+ CdbPtr->StatFlags |= PXE_STATFLAGS_DB_WRITE_TRUNCATED;
+
+ }
+ //
+ // check for a receive buffer and give it's size in db
+ //
+ }
+ //
+ //
+ //
+ if ((CdbPtr->OpFlags & PXE_OPFLAGS_GET_INTERRUPT_STATUS) != 0) {
+
+ Status = InWord (AdapterInfo, AdapterInfo->ioaddr + SCBStatus);
+ AdapterInfo->Int_Status = (UINT16) (AdapterInfo->Int_Status | Status);
+
+ //
+ // acknoledge the interrupts
+ //
+ OutWord (AdapterInfo, (UINT16) (Status & 0xfc00), (UINT32) (AdapterInfo->ioaddr + SCBStatus));
+
+ //
+ // report all the outstanding interrupts
+ //
+ Status = AdapterInfo->Int_Status;
+ if ((Status & SCB_STATUS_FR) != 0) {
+ CdbPtr->StatFlags |= PXE_STATFLAGS_GET_STATUS_RECEIVE;
+ }
+
+ if ((Status & SCB_STATUS_SWI) != 0) {
+ CdbPtr->StatFlags |= PXE_STATFLAGS_GET_STATUS_SOFTWARE;
+ }
+ }
+
+ return ;
+}
+
+
+/**
+ This routine is used to fill media header(s) in transmit packet(s).
+ Copies the MAC address into the media header whether it is dealing
+ with fragmented or non-fragmented packets.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_FillHeader (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+ PXE_CPB_FILL_HEADER *Cpb;
+ PXE_CPB_FILL_HEADER_FRAGMENTED *Cpbf;
+ EtherHeader *MacHeader;
+ UINTN Index;
+
+ if (CdbPtr->CPBsize == PXE_CPBSIZE_NOT_USED) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ if ((CdbPtr->OpFlags & PXE_OPFLAGS_FILL_HEADER_FRAGMENTED) != 0) {
+ Cpbf = (PXE_CPB_FILL_HEADER_FRAGMENTED *) (UINTN) CdbPtr->CPBaddr;
+
+ //
+ // assume 1st fragment is big enough for the mac header
+ //
+ if ((Cpbf->FragCnt == 0) || (Cpbf->FragDesc[0].FragLen < PXE_MAC_HEADER_LEN_ETHER)) {
+ //
+ // no buffers given
+ //
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ MacHeader = (EtherHeader *) (UINTN) Cpbf->FragDesc[0].FragAddr;
+ //
+ // we don't swap the protocol bytes
+ //
+ MacHeader->type = Cpbf->Protocol;
+
+ for (Index = 0; Index < PXE_HWADDR_LEN_ETHER; Index++) {
+ MacHeader->dest_addr[Index] = Cpbf->DestAddr[Index];
+ MacHeader->src_addr[Index] = Cpbf->SrcAddr[Index];
+ }
+ } else {
+ Cpb = (PXE_CPB_FILL_HEADER *) (UINTN) CdbPtr->CPBaddr;
+
+ MacHeader = (EtherHeader *) (UINTN) Cpb->MediaHeader;
+ //
+ // we don't swap the protocol bytes
+ //
+ MacHeader->type = Cpb->Protocol;
+
+ for (Index = 0; Index < PXE_HWADDR_LEN_ETHER; Index++) {
+ MacHeader->dest_addr[Index] = Cpb->DestAddr[Index];
+ MacHeader->src_addr[Index] = Cpb->SrcAddr[Index];
+ }
+ }
+
+ return ;
+}
+
+
+/**
+ This routine is used to place a packet into the transmit queue. The data buffers given to
+ this command are to be considered locked and the application or network driver loses
+ ownership of these buffers and must not free or relocate them until the ownership returns.
+ When the packets are transmitted, a transmit complete interrupt is generated (if interrupts
+ are disabled, the transmit interrupt status is still set and can be checked using the UNDI_Status
+ command.
+ Some implementations and adapters support transmitting multiple packets with one transmit
+ command. If this feature is supported, the transmit CPBs can be linked in one transmit
+ command.
+ All UNDIs support fragmented frames, now all network devices or protocols do. If a fragmented
+ frame CPB is given to UNDI and the network device does not support fragmented frames
+ (see !PXE.Implementation flag), the UNDI will have to copy the fragments into a local buffer
+ before transmitting.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_Transmit (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+
+ if (CdbPtr->CPBsize == PXE_CPBSIZE_NOT_USED) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ CdbPtr->StatCode = (PXE_STATCODE) E100bTransmit (AdapterInfo, CdbPtr->CPBaddr, CdbPtr->OpFlags);
+
+ if (CdbPtr->StatCode != PXE_STATCODE_SUCCESS) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ }
+
+ return ;
+}
+
+
+/**
+ When the network adapter has received a frame, this command is used to copy the frame
+ into the driver/application storage location. Once a frame has been copied, it is
+ removed from the receive queue.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+VOID
+UNDI_Receive (
+ IN PXE_CDB *CdbPtr,
+ IN NIC_DATA_INSTANCE *AdapterInfo
+ )
+{
+
+ //
+ // check if RU has started...
+ //
+ if (!AdapterInfo->Receive_Started) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_NOT_INITIALIZED;
+ return ;
+ }
+
+
+ CdbPtr->StatCode = (UINT16) E100bReceive (AdapterInfo, CdbPtr->CPBaddr, CdbPtr->DBaddr);
+ if (CdbPtr->StatCode != PXE_STATCODE_SUCCESS) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+
+ }
+
+ return ;
+}
+
+
+
+/**
+ This is the main SW UNDI API entry using the newer nii protocol.
+ The parameter passed in is a 64 bit flat model virtual
+ address of the cdb. We then jump into the common routine for both old and
+ new nii protocol entries.
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+// TODO: cdb - add argument and description to function comment
+VOID
+UNDI_APIEntry_new (
+ IN UINT64 cdb
+ )
+{
+ PXE_CDB *CdbPtr;
+ NIC_DATA_INSTANCE *AdapterInfo;
+
+ if (cdb == (UINT64) 0) {
+ return ;
+
+ }
+
+ CdbPtr = (PXE_CDB *) (UINTN) cdb;
+
+ if (CdbPtr->IFnum >= pxe_31->IFcnt) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+ }
+
+ AdapterInfo = &(UNDI32DeviceList[CdbPtr->IFnum]->NicInfo);
+ //
+ // entering from older entry point
+ //
+ AdapterInfo->VersionFlag = 0x31;
+ UNDI_APIEntry_Common (cdb);
+}
+
+
+/**
+ This is the common routine for both old and new entry point procedures.
+ The parameter passed in is a 64 bit flat model virtual
+ address of the cdb. We then jump into the service routine pointed to by the
+ Api_Table[OpCode].
+
+ @param CdbPtr Pointer to the command descriptor block.
+ @param AdapterInfo Pointer to the NIC data structure information which
+ the UNDI driver is layering on..
+
+ @return None
+
+**/
+// TODO: cdb - add argument and description to function comment
+VOID
+UNDI_APIEntry_Common (
+ IN UINT64 cdb
+ )
+{
+ PXE_CDB *CdbPtr;
+ NIC_DATA_INSTANCE *AdapterInfo;
+ UNDI_CALL_TABLE *tab_ptr;
+
+ CdbPtr = (PXE_CDB *) (UINTN) cdb;
+
+ //
+ // check the OPCODE range
+ //
+ if ((CdbPtr->OpCode > PXE_OPCODE_LAST_VALID) ||
+ (CdbPtr->StatCode != PXE_STATCODE_INITIALIZE) ||
+ (CdbPtr->StatFlags != PXE_STATFLAGS_INITIALIZE) ||
+ (CdbPtr->IFnum >= pxe_31->IFcnt) ) {
+ goto badcdb;
+
+ }
+
+ if (CdbPtr->CPBsize == PXE_CPBSIZE_NOT_USED) {
+ if (CdbPtr->CPBaddr != PXE_CPBADDR_NOT_USED) {
+ goto badcdb;
+ }
+ } else if (CdbPtr->CPBaddr == PXE_CPBADDR_NOT_USED) {
+ goto badcdb;
+ }
+
+ if (CdbPtr->DBsize == PXE_DBSIZE_NOT_USED) {
+ if (CdbPtr->DBaddr != PXE_DBADDR_NOT_USED) {
+ goto badcdb;
+ }
+ } else if (CdbPtr->DBaddr == PXE_DBADDR_NOT_USED) {
+ goto badcdb;
+ }
+
+ //
+ // check if cpbsize and dbsize are as needed
+ // check if opflags are as expected
+ //
+ tab_ptr = &api_table[CdbPtr->OpCode];
+
+ if (tab_ptr->cpbsize != (UINT16) (DONT_CHECK) && tab_ptr->cpbsize != CdbPtr->CPBsize) {
+ goto badcdb;
+ }
+
+ if (tab_ptr->dbsize != (UINT16) (DONT_CHECK) && tab_ptr->dbsize != CdbPtr->DBsize) {
+ goto badcdb;
+ }
+
+ if (tab_ptr->opflags != (UINT16) (DONT_CHECK) && tab_ptr->opflags != CdbPtr->OpFlags) {
+ goto badcdb;
+
+ }
+
+ AdapterInfo = &(UNDI32DeviceList[CdbPtr->IFnum]->NicInfo);
+
+ //
+ // check if UNDI_State is valid for this call
+ //
+ if (tab_ptr->state != (UINT16) (-1)) {
+ //
+ // should atleast be started
+ //
+ if (AdapterInfo->State == PXE_STATFLAGS_GET_STATE_STOPPED) {
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_NOT_STARTED;
+ return ;
+ }
+ //
+ // check if it should be initialized
+ //
+ if (tab_ptr->state == 2) {
+ if (AdapterInfo->State != PXE_STATFLAGS_GET_STATE_INITIALIZED) {
+ CdbPtr->StatCode = PXE_STATCODE_NOT_INITIALIZED;
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ return ;
+ }
+ }
+ }
+ //
+ // set the return variable for success case here
+ //
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_COMPLETE;
+ CdbPtr->StatCode = PXE_STATCODE_SUCCESS;
+
+ tab_ptr->api_ptr (CdbPtr, AdapterInfo);
+ return ;
+ //
+ // %% AVL - check for command linking
+ //
+badcdb:
+ CdbPtr->StatFlags = PXE_STATFLAGS_COMMAND_FAILED;
+ CdbPtr->StatCode = PXE_STATCODE_INVALID_CDB;
+ return ;
+}
+
+
+/**
+ When called with a null NicPtr, this routine decrements the number of NICs
+ this UNDI is supporting and removes the NIC_DATA_POINTER from the array.
+ Otherwise, it increments the number of NICs this UNDI is supported and
+ updates the pxe.Fudge to ensure a proper check sum results.
+
+ @param NicPtr Pointer to the NIC data structure.
+
+ @return None
+
+**/
+VOID
+PxeUpdate (
+ IN NIC_DATA_INSTANCE *NicPtr,
+ IN PXE_SW_UNDI *PxePtr
+ )
+{
+ if (NicPtr == NULL) {
+ if (PxePtr->IFcnt > 0) {
+ //
+ // number of NICs this undi supports
+ //
+ PxePtr->IFcnt--;
+ }
+
+ PxePtr->Fudge = (UINT8) (PxePtr->Fudge - CalculateSum8 ((VOID *) PxePtr, PxePtr->Len));
+ return ;
+ }
+
+ //
+ // number of NICs this undi supports
+ //
+ PxePtr->IFcnt++;
+ PxePtr->Fudge = (UINT8) (PxePtr->Fudge - CalculateSum8 ((VOID *) PxePtr, PxePtr->Len));
+
+ return ;
+}
+
+
+/**
+ Initialize the !PXE structure
+
+ @param PxePtr Pointer to SW_UNDI data structure.
+
+ @retval EFI_SUCCESS This driver is added to Controller.
+ @retval other This driver does not support this device.
+
+**/
+VOID
+PxeStructInit (
+ IN PXE_SW_UNDI *PxePtr
+ )
+{
+ //
+ // Initialize the !PXE structure
+ //
+ PxePtr->Signature = PXE_ROMID_SIGNATURE;
+ PxePtr->Len = sizeof (PXE_SW_UNDI);
+ //
+ // cksum
+ //
+ PxePtr->Fudge = 0;
+ //
+ // number of NICs this undi supports
+ //
+ PxePtr->IFcnt = 0;
+ PxePtr->Rev = PXE_ROMID_REV;
+ PxePtr->MajorVer = PXE_ROMID_MAJORVER;
+ PxePtr->MinorVer = PXE_ROMID_MINORVER;
+ PxePtr->reserved1 = 0;
+
+ PxePtr->Implementation = PXE_ROMID_IMP_SW_VIRT_ADDR |
+ PXE_ROMID_IMP_FRAG_SUPPORTED |
+ PXE_ROMID_IMP_CMD_LINK_SUPPORTED |
+ PXE_ROMID_IMP_NVDATA_READ_ONLY |
+ PXE_ROMID_IMP_STATION_ADDR_SETTABLE |
+ PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED |
+ PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED |
+ PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED |
+ PXE_ROMID_IMP_FILTERED_MULTICAST_RX_SUPPORTED |
+ PXE_ROMID_IMP_SOFTWARE_INT_SUPPORTED |
+ PXE_ROMID_IMP_PACKET_RX_INT_SUPPORTED;
+
+ PxePtr->EntryPoint = (UINT64) (UINTN) UNDI_APIEntry_new;
+ PxePtr->MinorVer = PXE_ROMID_MINORVER_31;
+
+ PxePtr->reserved2[0] = 0;
+ PxePtr->reserved2[1] = 0;
+ PxePtr->reserved2[2] = 0;
+ PxePtr->BusCnt = 1;
+ PxePtr->BusType[0] = PXE_BUSTYPE_PCI;
+
+ PxePtr->Fudge = (UINT8) (PxePtr->Fudge - CalculateSum8 ((VOID *) PxePtr, PxePtr->Len));
+}
+