Snp.h

Go to the documentation of this file.

 
#ifndef _SNP_H_
#define _SNP_H_
 
#include <Uefi.h>
 
#include <Protocol/SimpleNetwork.h>
#include <Protocol/PciIo.h>
#include <Protocol/NetworkInterfaceIdentifier.h>
#include <Protocol/DevicePath.h>
 
#include <Guid/EventGroup.h>
 
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/BaseLib.h>
#include <Library/UefiLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/PrintLib.h>
#include <Library/PcdLib.h>
 
#include <IndustryStandard/Pci.h>
#include <IndustryStandard/Acpi.h>
 
#define FOUR_GIGABYTES  (UINT64) 0x100000000ULL
 
#define SNP_DRIVER_SIGNATURE  SIGNATURE_32 ('s', 'n', 'd', 's')
#define MAX_MAP_LENGTH        100
 
#define PCI_BAR_IO_MASK  0x00000003
#define PCI_BAR_IO_MODE  0x00000001
 
#define PCI_BAR_MEM_MASK   0x0000000F
#define PCI_BAR_MEM_MODE   0x00000000
#define PCI_BAR_MEM_64BIT  0x00000004
 
#define SNP_TX_BUFFER_INCREASEMENT  MAX_XMIT_BUFFERS
#define SNP_MAX_TX_BUFFER_NUM       65536
 
typedef
EFI_STATUS
(EFIAPI *ISSUE_UNDI32_COMMAND)(
  UINT64         Cdb
  );
 
typedef struct {
  UINT32                         Signature;
  EFI_LOCK                       Lock;
 
  EFI_SIMPLE_NETWORK_PROTOCOL    Snp;
  EFI_SIMPLE_NETWORK_MODE        Mode;
 
  EFI_HANDLE                     DeviceHandle;
  EFI_DEVICE_PATH_PROTOCOL       *DevicePath;
 
  //
  //  Local instance data needed by SNP driver
  //
  //  Pointer to S/W UNDI API entry point
  //  This will be NULL for H/W UNDI
  //
  ISSUE_UNDI32_COMMAND           IssueUndi32Command;
 
  BOOLEAN                        IsSwUndi;
 
  //
  // undi interface number, if one undi manages more nics
  //
  PXE_IFNUM                      IfNum;
 
  //
  //  Allocated tx/rx buffer that was passed to UNDI Initialize.
  //
  UINT32                         TxRxBufferSize;
  VOID                           *TxRxBuffer;
  //
  // mappable buffers for receive and fill header for undi3.0
  // these will be used if the user buffers are above 4GB limit (instead of
  // mapping the user buffers)
  //
  UINT8                          *ReceiveBufffer;
  VOID                           *ReceiveBufferUnmap;
  UINT8                          *FillHeaderBuffer;
  VOID                           *FillHeaderBufferUnmap;
 
  EFI_PCI_IO_PROTOCOL            *PciIo;
  UINT8                          IoBarIndex;
  UINT8                          MemoryBarIndex;
 
  //
  // Buffers for command descriptor block, command parameter block
  // and data block.
  //
  PXE_CDB                        Cdb;
  VOID                           *Cpb;
  VOID                           *CpbUnmap;
  VOID                           *Db;
 
  //
  // UNDI structure, we need to remember the init info for a long time!
  //
  PXE_DB_GET_INIT_INFO           InitInfo;
 
  VOID                           *SnpDriverUnmap;
  //
  // when ever we map an address, we must remember it's address and the un-map
  // cookie so that we can unmap later
  //
  struct MAP_LIST {
    EFI_PHYSICAL_ADDRESS    VirtualAddress;
    VOID                    *MapCookie;
  } MapList[MAX_MAP_LENGTH];
 
  EFI_EVENT    ExitBootServicesEvent;
 
  //
  // Whether UNDI support reporting media status from GET_STATUS command,
  // i.e. PXE_STATFLAGS_GET_STATUS_NO_MEDIA_SUPPORTED or
  //      PXE_STATFLAGS_GET_STATUS_NO_MEDIA_NOT_SUPPORTED
  //
  BOOLEAN      MediaStatusSupported;
 
  //
  // Whether UNDI support cable detect for INITIALIZE command,
  // i.e. PXE_STATFLAGS_CABLE_DETECT_SUPPORTED or
  //      PXE_STATFLAGS_CABLE_DETECT_NOT_SUPPORTED
  //
  BOOLEAN      CableDetectSupported;
 
  //
  // Array of the recycled transmit buffer address from UNDI.
  //
  UINT64       *RecycledTxBuf;
  //
  // The maximum number of recycled buffer pointers in RecycledTxBuf.
  //
  UINT32       MaxRecycledTxBuf;
  //
  // Current number of recycled buffer pointers in RecycledTxBuf.
  //
  UINT32       RecycledTxBufCount;
} SNP_DRIVER;
 
#define EFI_SIMPLE_NETWORK_DEV_FROM_THIS(a)  CR (a, SNP_DRIVER, Snp, SNP_DRIVER_SIGNATURE)
 
//
// Global Variables
//
extern EFI_DRIVER_BINDING_PROTOCOL   gSimpleNetworkDriverBinding;
extern EFI_COMPONENT_NAME_PROTOCOL   gSimpleNetworkComponentName;
extern EFI_COMPONENT_NAME2_PROTOCOL  gSimpleNetworkComponentName2;
 
EFI_STATUS
PxeStart (
  IN SNP_DRIVER  *Snp
  );
 
EFI_STATUS
PxeStop (
  SNP_DRIVER  *Snp
  );
 
EFI_STATUS
PxeInit (
  SNP_DRIVER  *Snp,
  UINT16      CableDetectFlag
  );
 
EFI_STATUS
PxeShutdown (
  IN SNP_DRIVER  *Snp
  );
 
EFI_STATUS
PxeGetStnAddr (
  SNP_DRIVER  *Snp
  );
 
EFI_STATUS
PxeGetStatus (
  IN     SNP_DRIVER  *Snp,
  OUT UINT32         *InterruptStatusPtr,
  IN     BOOLEAN     GetTransmittedBuf
  );
 
VOID
EFIAPI
SnpUndi32CallbackBlock (
  IN UINT64  UniqueId,
  IN UINT32  Enable
  );
 
VOID
EFIAPI
SnpUndi32CallbackDelay (
  IN UINT64  UniqueId,
  IN UINT64  MicroSeconds
  );
 
VOID
EFIAPI
SnpUndi32CallbackMemio (
  IN UINT64      UniqueId,
  IN UINT8       ReadOrWrite,
  IN UINT8       NumBytes,
  IN UINT64      MemOrPortAddr,
  IN OUT UINT64  BufferPtr
  );
 
VOID
EFIAPI
SnpUndi32CallbackMap (
  IN UINT64      UniqueId,
  IN UINT64      CpuAddr,
  IN UINT32      NumBytes,
  IN UINT32      Direction,
  IN OUT UINT64  DeviceAddrPtr
  );
 
VOID
EFIAPI
SnpUndi32CallbackUnmap (
  IN UINT64  UniqueId,
  IN UINT64  CpuAddr,
  IN UINT32  NumBytes,
  IN UINT32  Direction,
  IN UINT64  DeviceAddr
  );
 
VOID
EFIAPI
SnpUndi32CallbackSync (
  IN UINT64  UniqueId,
  IN UINT64  CpuAddr,
  IN UINT32  NumBytes,
  IN UINT32  Direction,
  IN UINT64  DeviceAddr
  );
 
EFI_STATUS
EFIAPI
SnpUndi32Start (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This
  );
 
EFI_STATUS
EFIAPI
SnpUndi32Stop (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This
  );
 
EFI_STATUS
EFIAPI
SnpUndi32Initialize (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN UINTN                        ExtraRxBufferSize OPTIONAL,
  IN UINTN                        ExtraTxBufferSize OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SnpUndi32Reset (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN BOOLEAN                      ExtendedVerification
  );
 
EFI_STATUS
EFIAPI
SnpUndi32Shutdown (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This
  );
 
EFI_STATUS
EFIAPI
SnpUndi32ReceiveFilters (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN UINT32                       Enable,
  IN UINT32                       Disable,
  IN BOOLEAN                      ResetMCastFilter,
  IN UINTN                        MCastFilterCnt   OPTIONAL,
  IN EFI_MAC_ADDRESS              *MCastFilter     OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SnpUndi32StationAddress (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN BOOLEAN                      Reset,
  IN EFI_MAC_ADDRESS              *New  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SnpUndi32Statistics (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN BOOLEAN                      Reset,
  IN OUT UINTN                    *StatisticsSize   OPTIONAL,
  IN OUT EFI_NETWORK_STATISTICS   *StatisticsTable  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SnpUndi32McastIpToMac (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN BOOLEAN                      IPv6,
  IN EFI_IP_ADDRESS               *IP,
  OUT EFI_MAC_ADDRESS             *MAC
  );
 
EFI_STATUS
EFIAPI
SnpUndi32NvData (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN BOOLEAN                      ReadWrite,
  IN UINTN                        Offset,
  IN UINTN                        BufferSize,
  IN OUT VOID                     *Buffer
  );
 
EFI_STATUS
EFIAPI
SnpUndi32GetStatus (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  OUT UINT32                      *InterruptStatus  OPTIONAL,
  OUT VOID                        **TxBuf           OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SnpUndi32Transmit (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  IN UINTN                        HeaderSize,
  IN UINTN                        BufferSize,
  IN VOID                         *Buffer,
  IN EFI_MAC_ADDRESS              *SrcAddr   OPTIONAL,
  IN EFI_MAC_ADDRESS              *DestAddr  OPTIONAL,
  IN UINT16                       *Protocol  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SnpUndi32Receive (
  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
  OUT UINTN                       *HeaderSize OPTIONAL,
  IN OUT UINTN                    *BufferSize,
  OUT VOID                        *Buffer,
  OUT EFI_MAC_ADDRESS             *SrcAddr OPTIONAL,
  OUT EFI_MAC_ADDRESS             *DestAddr OPTIONAL,
  OUT UINT16                      *Protocol OPTIONAL
  );
 
VOID
EFIAPI
SnpWaitForPacketNotify (
  EFI_EVENT  Event,
  VOID       *SnpPtr
  );
 
#define SNP_MEM_PAGES(x)  (((x) - 1) / 4096 + 1)
 
#endif /*  _SNP_H_  */