Re: [Linaro-uefi] [PATCH v3 2/4] OpenPlatformPkg/MarvellYukonDxe: Marvell Yukon NIC driver

8 Jun 2016

On 7 June 2016 at 01:25, Daniil Egranov daniil.egranov@arm.com wrote:
...
The UEFI driver for Marvell Yukon NIC, part 2
Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Daniil Egranov daniil.egranov@arm.com

Drivers/Net/MarvellYukonDxe/ComponentName.c     | 313 ++++++++++
 Drivers/Net/MarvellYukonDxe/DeviceConfig.c      | 330 +++++++++++
 Drivers/Net/MarvellYukonDxe/DeviceConfig.h      |  98 ++++
 Drivers/Net/MarvellYukonDxe/DriverBinding.c     | 414 +++++++++++++
 Drivers/Net/MarvellYukonDxe/MarvellYukon.h      | 733 ++++++++++++++++++++++++
 Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.dec |  29 +
 Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.inf |  77 +++
 7 files changed, 1994 insertions(+)
 create mode 100644 Drivers/Net/MarvellYukonDxe/ComponentName.c
 create mode 100644 Drivers/Net/MarvellYukonDxe/DeviceConfig.c
 create mode 100644 Drivers/Net/MarvellYukonDxe/DeviceConfig.h
 create mode 100644 Drivers/Net/MarvellYukonDxe/DriverBinding.c
 create mode 100644 Drivers/Net/MarvellYukonDxe/MarvellYukon.h
 create mode 100644 Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.dec
 create mode 100644 Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.inf

diff --git a/Drivers/Net/MarvellYukonDxe/ComponentName.c b/Drivers/Net/MarvellYukonDxe/ComponentName.c
new file mode 100644
index 0000000..c3523a2
--- /dev/null
+++ b/Drivers/Net/MarvellYukonDxe/ComponentName.c
@@ -0,0 +1,313 @@
+/**
+*
+*  Copyright (c) 2011-2016, ARM Limited. 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 "MarvellYukon.h"



+//
+// EFI Component Name Functions
+//
+/**

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.

<at> param  This[in]               A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
                                 EFI_COMPONENT_NAME_PROTOCOL instance.



<at> 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.



<at> 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.



<at> retval EFI_SUCCESS            The Unicode string for the Driver specified by
                                 This and the language specified by Language was


                                 returned in DriverName.



<at> retval EFI_INVALID_PARAMETER  Language is NULL.

<at> retval EFI_INVALID_PARAMETER  DriverName is NULL.

<at> retval EFI_UNSUPPORTED        The driver specified by This does not support
                                 the language specified by Language.




+**/
+EFI_STATUS
+EFIAPI
+SimpleNetworkComponentNameGetDriverName (

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.

<at> param  This[in]               A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
                                 EFI_COMPONENT_NAME_PROTOCOL instance.



<at> 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.



<at> 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.



<at> 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.



<at> 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.



<at> 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.



<at> retval EFI_INVALID_PARAMETER  ControllerHandle is not a valid EFI_HANDLE.

<at> retval EFI_INVALID_PARAMETER  ChildHandle is not NULL and it is not a valid
                                 EFI_HANDLE.



<at> retval EFI_INVALID_PARAMETER  Language is NULL.

<at> retval EFI_INVALID_PARAMETER  ControllerName is NULL.

<at> retval EFI_UNSUPPORTED        The driver specified by This is not currently
                                 managing the controller specified by


                                 ControllerHandle and ChildHandle.



<at> retval EFI_UNSUPPORTED        The driver specified by This does not support
                                 the language specified by Language.




+**/
+EFI_STATUS
+EFIAPI
+SimpleNetworkComponentNameGetControllerName (

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  gSimpleNetworkComponentName = {

SimpleNetworkComponentNameGetDriverName,
SimpleNetworkComponentNameGetControllerName,
"eng"

+};



+//
+// EFI Component Name 2 Protocol
+//
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gSimpleNetworkComponentName2 = {

(EFI_COMPONENT_NAME2_GET_DRIVER_NAME) SimpleNetworkComponentNameGetDriverName,
(EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) SimpleNetworkComponentNameGetControllerName,
"en"

+};




+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mSimpleNetworkDriverNameTable[] = {

{
"eng;en",
L"Marvell Yukon 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.

<at> param  This[in]               A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
                                 EFI_COMPONENT_NAME_PROTOCOL instance.



<at> 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.



<at> 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.



<at> retval EFI_SUCCESS            The Unicode string for the Driver specified by
                                 This and the language specified by Language was


                                 returned in DriverName.



<at> retval EFI_INVALID_PARAMETER  Language is NULL.

<at> retval EFI_INVALID_PARAMETER  DriverName is NULL.

<at> retval EFI_UNSUPPORTED        The driver specified by This does not support
                                 the language specified by Language.




+**/
+EFI_STATUS
+EFIAPI
+SimpleNetworkComponentNameGetDriverName (

IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
IN  CHAR8                        *Language,
OUT CHAR16                       **DriverName
)

+{

return LookupUnicodeString2 (
   Language,


   This->SupportedLanguages,


   mSimpleNetworkDriverNameTable,


   DriverName,


   (BOOLEAN)(This == &gSimpleNetworkComponentName)


   );



+}



+/**

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.
Currently not implemented.

<at> param  This[in]               A pointer to the EFI_COMPONENT_NAME2_PROTOCOL
                                 or EFI_COMPONENT_NAME_PROTOCOL instance.



<at> 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.



<at> 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.



<at> 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.



<at> 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.



<at> 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.



<at> retval EFI_INVALID_PARAMETER  ControllerHandle is not a valid EFI_HANDLE.

<at> retval EFI_INVALID_PARAMETER  ChildHandle is not NULL and it is not a valid
                                 EFI_HANDLE.



<at> retval EFI_INVALID_PARAMETER  Language is NULL.

<at> retval EFI_INVALID_PARAMETER  ControllerName is NULL.

<at> retval EFI_UNSUPPORTED        The driver specified by This is not currently
                                 managing the controller specified by


                                 ControllerHandle and ChildHandle.



<at> retval EFI_UNSUPPORTED        The driver specified by This does not support
                                 the language specified by Language.




+**/
+EFI_STATUS
+EFIAPI
+SimpleNetworkComponentNameGetControllerName (

IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
IN  EFI_HANDLE                                      ControllerHandle,
IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
IN  CHAR8                                           *Language,
OUT CHAR16                                          **ControllerName
)

+{

return EFI_UNSUPPORTED;

+}
diff --git a/Drivers/Net/MarvellYukonDxe/DeviceConfig.c b/Drivers/Net/MarvellYukonDxe/DeviceConfig.c
new file mode 100644
index 0000000..d3edb23
--- /dev/null
+++ b/Drivers/Net/MarvellYukonDxe/DeviceConfig.c
@@ -0,0 +1,330 @@
+/** @file
+*
+*  Copyright (c) 2016, ARM Limited. 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 <ArmPlatform.h>
+#include <Protocol/PciIo.h>
+#include <IndustryStandard/Pci.h>
+#include <Library/IoLib.h>
+#include "MarvellYukon.h"
+#include "miivar.h"
+#include "if_media.h"
+#include "if_mskreg.h"
+#include "if_msk.h"
+#include "DeviceConfig.h"



+/**

Initialize device configuration protocol.

@param DeviceConfigProtocol   A pointer to the protocol structure.

@retval EFI_SUCCESS           Protocol initialized successfully.

+**/



+EFI_STATUS
+EFIAPI
+InitializeDeviceConfigProtocol (

IN OUT  EFI_EMBEDDED_DEVICE_CONFIG_PROTOCOL *DeviceConfigProtocol
)

+{

DeviceConfigProtocol->Revision  = EFI_EMBEDDED_DEVICE_CONFIG_REVISION;
DeviceConfigProtocol->Supported = DeviceConfigSupported;
DeviceConfigProtocol->Get       = DeviceConfigGet;
DeviceConfigProtocol->Set       = DeviceConfigSet;

return RETURN_SUCCESS;

+}



+/**

This function reads or update Marvell Yukon MAC address.

@param Controller         Device handle.
@param ReadMacAddress     If flags set to TRUE - read MAC address, otherwise
                       write new MAC address value.


@param MacAddress         Pointer to MAC address buffer.

@retval MacAddress        Device MAC address.
@retval EFI_SUCCESS       Configuration data is available.
@retval EFI_UNSUPPORTED   Device does not support specified configuration.
@retval EFI_DEVICE_ERROR  Device configuration read error.


+**/
+EFI_STATUS
+EFIAPI
+ConfigMACAddress (

IN EFI_HANDLE          Controller,
IN BOOLEAN             ReadMacAddress,
IN OUT EFI_MAC_ADDRESS *MacAddress
)

+{

EFI_STATUS                    Status;
UINT32                        PciRegBase;
UINT64                        OldPciAttributes;
UINT64                        AttrSupports;
UINT8                         *PciBarAttributes;
UINTN                         AddrIndex;
EFI_PCI_IO_PROTOCOL           *PciIo;

if (MacAddress == NULL) {
DEBUG ((EFI_D_NET, "Marvell Yukon: ConfigMACAddress() failed with Status = %r\n", EFI_INVALID_PARAMETER));
return EFI_INVALID_PARAMETER;
}

Status = gBS->OpenProtocol (
             Controller,


             &gEfiPciIoProtocolGuid,


             (VOID **) &PciIo,


             NULL,


             NULL,


             EFI_OPEN_PROTOCOL_GET_PROTOCOL);



if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR;
}

Status = mskc_probe (PciIo);

if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}

Status = PciIo->Attributes (PciIo,
                         EfiPciIoAttributeOperationGet, 0,


                         &OldPciAttributes);


if (!EFI_ERROR (Status)) {
Status = PciIo->Attributes (PciIo,
                            EfiPciIoAttributeOperationSupported, 0,


                            &AttrSupports);


if (!EFI_ERROR (Status)) {
 AttrSupports &= EFI_PCI_DEVICE_ENABLE;


 Status = PciIo->Attributes ( PciIo,


                              EfiPciIoAttributeOperationEnable,


                              AttrSupports, NULL );


 if(!EFI_ERROR (Status)) {


   Status = PciIo->GetBarAttributes (PciIo, 0, &AttrSupports, (VOID**)&PciBarAttributes);



   if (!EFI_ERROR (Status) &&


       (((EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *)PciBarAttributes)->Desc == ACPI_ADDRESS_SPACE_DESCRIPTOR)) {


     if (((EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *)PciBarAttributes)->ResType == ACPI_ADDRESS_SPACE_TYPE_MEM) {


       if (!(((EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *)PciBarAttributes)->SpecificFlag & ACPI_SPECFLAG_PREFETCHABLE)) {



         PciRegBase = ((EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *)PciBarAttributes)->AddrRangeMin;



         Status = EFI_SUCCESS;



         if (ReadMacAddress) {


           // Read MAC address


           for (AddrIndex = 0; AddrIndex < NET_ETHER_ADDR_LEN; AddrIndex++) {


             MacAddress->Addr[NET_ETHER_ADDR_LEN - AddrIndex - 1] = MmioRead8 (PciRegBase + B2_MAC_1 + AddrIndex);


           }


         } else {


           // Clear Software Reset


           MmioWrite16 (PciRegBase + B0_CTST, CS_RST_CLR);



           // Set MAC Address


           MmioWrite8 (PciRegBase + B2_TST_CTRL1, TST_CFG_WRITE_ON);


           for (AddrIndex = 0; AddrIndex < NET_ETHER_ADDR_LEN; AddrIndex++) {


             MmioWrite8 (PciRegBase + B2_MAC_1 + AddrIndex, MacAddress->Addr[NET_ETHER_ADDR_LEN - AddrIndex - 1]);


           }


           MmioWrite8 (PciRegBase + B2_TST_CTRL1, TST_CFG_WRITE_OFF);



           // Soft reset


           MmioWrite16 (PciRegBase + B0_CTST, CS_RST_SET);


           MmioWrite16 (PciRegBase + B0_CTST, CS_RST_CLR);


         }


       }


     }


   }


 }



 PciIo->Attributes (PciIo,


                     EfiPciIoAttributeOperationSet, OldPciAttributes,


                     NULL);


}
}

return Status;

+}
+/**

This function provides Marvell Yukon configuration support status.

@param This               Instance pointer for this protocol

@retval Buffer            Array of configuration records.
@retval RecordCount       Number of configuration records.
@retval EFI_SUCCESS       Device supports external configuration.
@retval EFI_UNSUPPORTED   Device does not support external configuration.
@retval EFI_DEVICE_ERROR  Device configuration read error.

+**/
+EFI_STATUS
+EFIAPI
+DeviceConfigSupported (

IN  EFI_EMBEDDED_DEVICE_CONFIG_PROTOCOL  *This,
OUT EFI_DEVICE_CONFIGURATION_RECORD      **Buffer,
OUT UINTN                                *RecordCount
)

+{

EFI_STATUS                      Status;
EFI_PCI_IO_PROTOCOL             *PciIo;
UINTN                           HandleCount;
EFI_HANDLE                      *HandleBuffer;
UINTN                           HIndex;
UINTN                           RIndex;
EFI_HANDLE                      *ConfigHandles;

*Buffer = NULL;
*RecordCount = 0;

// Query for all devices supporting PCI IO protocol
Status = gBS->LocateHandleBuffer (
   ByProtocol,


   &gEfiPciIoProtocolGuid,


   NULL,


   &HandleCount,


   &HandleBuffer


   );



if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}

ConfigHandles = AllocateZeroPool (sizeof (EFI_HANDLE) * HandleCount);
if (ConfigHandles == NULL) {
FreePool(HandleBuffer);
return EFI_OUT_OF_RESOURCES;
}

// Loop through all device handles and probe for the Marvel Yukon
for (HIndex = 0; HIndex < HandleCount; ++HIndex) {

Status = gBS->OpenProtocol (
               HandleBuffer[HIndex],


               &gEfiPciIoProtocolGuid,


               (VOID **) &PciIo,


               NULL,


               NULL,


               EFI_OPEN_PROTOCOL_GET_PROTOCOL);



if (!EFI_ERROR (Status)) {
 Status = mskc_probe (PciIo);


 if (EFI_ERROR (Status)) {


   continue;


 }


 ConfigHandles[*RecordCount] = HandleBuffer[HIndex];


 (*RecordCount)++;


}
}

Status = EFI_SUCCESS;

if (*RecordCount != 0) {
*Buffer =
   AllocateZeroPool (sizeof (EFI_DEVICE_CONFIGURATION_RECORD) * (*RecordCount));


if (*Buffer == NULL) {
 Status = EFI_OUT_OF_RESOURCES;


} else {
  for (RIndex = 0; RIndex < *RecordCount; ++RIndex) {


    (*Buffer)[RIndex].Controller = ConfigHandles[RIndex];


    (*Buffer)[RIndex].SupportedConfigs = 0;


    (*Buffer)[RIndex].ConfigList[(*Buffer)[RIndex].SupportedConfigs].Type


                             = EfiConfigMacAddress;


    (*Buffer)[RIndex].ConfigList[(*Buffer)[RIndex].SupportedConfigs].Writable


                             = TRUE;


    (*Buffer)[RIndex].SupportedConfigs++;


 }


}
} else {
Status = EFI_UNSUPPORTED;
}

FreePool(HandleBuffer);
FreePool(ConfigHandles);

return Status;

+}



+/**

This function returns Marvell Yukon device configuration.

@param This               Instance pointer for this protocol
@param Controller         Handle of device to get a configuration.
@param ConfigType         Configuration type to update.

@retval Buffer            Configuration data.
@retval EFI_SUCCESS       Configuration data is available.
@retval EFI_UNSUPPORTED   Device does not support specified configuration.
@retval EFI_DEVICE_ERROR  Device configuration read error.


+**/
+EFI_STATUS
+EFIAPI
+DeviceConfigGet (

IN EFI_EMBEDDED_DEVICE_CONFIG_PROTOCOL  *This,
IN EFI_HANDLE                           Controller,
IN EFI_DEVICE_CONFIGURATION_TYPE        ConfigType,
OUT VOID                                **Buffer
)

+{

EFI_MAC_ADDRESS               *MacAddress;
EFI_STATUS                    Status;

Status = EFI_UNSUPPORTED;

if (ConfigType == EfiConfigMacAddress) {
MacAddress = AllocateZeroPool (sizeof (EFI_MAC_ADDRESS));
if (MacAddress == NULL) {
 Status = EFI_OUT_OF_RESOURCES;


} else {
 Status = ConfigMACAddress (Controller, TRUE, MacAddress);


 if (!EFI_ERROR (Status)) {


   *Buffer = MacAddress;


 }


}
}

return Status;

+}



+/**

This function sets Marvell Yukon configuration.

@param This               Instance pointer for this protocol
@param Controller         Handle of device to configure.
@param ConfigType         Configuration type.
@param Buffer             Configuration data.

@retval EFI_SUCCESS       Device configured successfully.
@retval EFI_UNSUPPORTED   Device does not support specified configuration or
                       device configuration is read only.


@retval EFI_DEVICE_ERROR  Device configuration failed.


+**/
+EFI_STATUS
+EFIAPI
+DeviceConfigSet (

IN EFI_EMBEDDED_DEVICE_CONFIG_PROTOCOL  *This,
IN EFI_HANDLE                           Controller,
IN EFI_DEVICE_CONFIGURATION_TYPE        ConfigType,
IN VOID                                 *Buffer
)

+{

EFI_STATUS                    Status;

Status = EFI_UNSUPPORTED;

if (ConfigType == EfiConfigMacAddress) {
Status = ConfigMACAddress (Controller, FALSE, Buffer);
}

return Status;

+}
diff --git a/Drivers/Net/MarvellYukonDxe/DeviceConfig.h b/Drivers/Net/MarvellYukonDxe/DeviceConfig.h
new file mode 100644
index 0000000..67ce169
--- /dev/null
+++ b/Drivers/Net/MarvellYukonDxe/DeviceConfig.h
@@ -0,0 +1,98 @@
+/** @file
+*
+*  Copyright (c) 2016, ARM Limited. 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.
+*
+**/



+#ifndef __DEVICE_CONFIG_H__
+#define __DEVICE_CONFIG_H__



+#include <Uefi.h>



+/**

Initialize device configuration protocol.

@param DeviceConfigProtocol   A pointer to the protocol structure.

@retval EFI_SUCCESS           Protocol initialized successfully.

+**/



+EFI_STATUS
+EFIAPI
+InitializeDeviceConfigProtocol (

IN OUT  EFI_EMBEDDED_DEVICE_CONFIG_PROTOCOL *DeviceConfigProtocol
);


+/**

This function provides Marvell Yukon configuration support status.

@param This               Instance pointer for this protocol

@retval Buffer            Array of configuration records.
@retval RecordCount       Number of configuration records.
@retval EFI_SUCCESS       Device supports external configuration.
@retval EFI_UNSUPPORTED   Device does not support external configuration.
@retval EFI_DEVICE_ERROR  Device configuration read error.

+**/
+EFI_STATUS
+EFIAPI
+DeviceConfigSupported (

IN  EFI_EMBEDDED_DEVICE_CONFIG_PROTOCOL  *This,
OUT EFI_DEVICE_CONFIGURATION_RECORD      **Buffer,
OUT UINTN                                *RecordCount
);


+/**

This function returns Marvell Yukon device configuration.

@param This               Instance pointer for this protocol
@param Controller         Handle of device to get a configuration.
@param ConfigType         Configuration type to update.

@retval Buffer            Configuration data.
@retval EFI_SUCCESS       Configuration data is available.
@retval EFI_UNSUPPORTED   Device does not support specified configuration.
@retval EFI_DEVICE_ERROR  Device configuration read error.


+**/
+EFI_STATUS
+EFIAPI
+DeviceConfigGet (

IN EFI_EMBEDDED_DEVICE_CONFIG_PROTOCOL  *This,
IN EFI_HANDLE                           Controller,
IN EFI_DEVICE_CONFIGURATION_TYPE        ConfigType,
OUT VOID                                **Buffer
);


+/**

This function sets Marvell Yukon configuration.

@param This               Instance pointer for this protocol
@param Controller         Handle of device to configure.
@param ConfigType         Configuration type.
@param Buffer             Configuration data.

@retval EFI_SUCCESS       Device configured successfully.
@retval EFI_UNSUPPORTED   Device does not support specified configuration or
                       device configuration is read only.


@retval EFI_DEVICE_ERROR  Device configuration failed.


+**/
+EFI_STATUS
+EFIAPI
+DeviceConfigSet (

IN EFI_EMBEDDED_DEVICE_CONFIG_PROTOCOL  *This,
IN EFI_HANDLE                           Controller,
IN EFI_DEVICE_CONFIGURATION_TYPE        ConfigType,
IN VOID                                 *Buffer
);


+#endif // __DEVICE_CONFIG_H__
diff --git a/Drivers/Net/MarvellYukonDxe/DriverBinding.c b/Drivers/Net/MarvellYukonDxe/DriverBinding.c
new file mode 100644
index 0000000..826c042
--- /dev/null
+++ b/Drivers/Net/MarvellYukonDxe/DriverBinding.c
@@ -0,0 +1,414 @@
+/**  <at> file

Implementation of driver entry point and driver binding protocol.


+Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2011 - 2016, ARM Limited. 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 <Library/NetLib.h>
+#include <Library/DevicePathLib.h>
+#include "MarvellYukon.h"
+#include "if_msk.h"
+#include "DeviceConfig.h"



+/**

Test to see if this driver supports ControllerHandle. This service
is called by the EFI boot service ConnectController(). In
order to make drivers as small as possible, there are a few calling
restrictions for this service. ConnectController() must
follow these calling restrictions. If any other agent wishes to call
Supported() it must also follow these calling restrictions.

<at> param  This                   Protocol instance pointer.
<at> param  ControllerHandle       Handle of device to test.
<at> param  RemainingDevicePath    Optional parameter use to pick a specific child
                                                        device to start.



<at> retval EFI_SUCCESS            This driver supports this device.
<at> retval EFI_ALREADY_STARTED    This driver is already running on this device.
<at> retval other                  This driver does not support this device.


+**/
+EFI_STATUS
+EFIAPI
+MarvellYukonDriverSupported (

IN EFI_DRIVER_BINDING_PROTOCOL    *This,
IN EFI_HANDLE                     Controller,
IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
)

+{

EFI_STATUS              Status;
EFI_PCI_IO_PROTOCOL     *PciIo;

//
// Test that the PCI IO Protocol is attached to the controller handle and no other driver is consuming it
//
Status = gBS->OpenProtocol (
   Controller,


   &gEfiPciIoProtocolGuid,


   (VOID **) &PciIo,


   This->DriverBindingHandle,


   Controller,


   EFI_OPEN_PROTOCOL_BY_DRIVER


   );



if (!EFI_ERROR (Status)) {
//
// Test whether the controller is on a supported NIC
//
Status = mskc_probe (PciIo);
if (EFI_ERROR (Status)) {
 Status = EFI_UNSUPPORTED;


}

gBS->CloseProtocol (
     Controller,


     &gEfiPciIoProtocolGuid,


     This->DriverBindingHandle,


     Controller


     );



DEBUG ((EFI_D_INFO, "Marvell Yukon: MarvellYukonDriverSupported: Status = %d, Controller = %p\n", Status, Controller));

Why is this one EFI_D_INFO and not EFI_D_NET like the others?
...

}

return Status;

+}



+/**

Start this driver on Controller by opening PciIo and DevicePath protocols.
Initialize PXE structures, create a copy of the Controller Device Path with the
NIC's MAC address appended to it, install the NetworkInterfaceIdentifier protocol
on the newly created Device Path.

@param [in] pThis                   Protocol instance pointer.
@param [in] Controller              Handle of device to work with.
@param [in] pRemainingDevicePath    Not used, always produce all possible children.

@retval EFI_SUCCESS                 This driver is added to Controller.
@retval other                       This driver does not support this device.


+**/
+EFI_STATUS
+EFIAPI
+MarvellYukonDriverStart (

IN EFI_DRIVER_BINDING_PROTOCOL * pThis,
IN EFI_HANDLE Controller,
IN EFI_DEVICE_PATH_PROTOCOL * pRemainingDevicePath
)

+{


EFI_STATUS                       Status;
UINTN                            LengthInBytes;
EFI_DEVICE_PATH_PROTOCOL         *ParentDevicePath = NULL;
MAC_ADDR_DEVICE_PATH             MacDeviceNode;

YUKON_DRIVER    *YukonDriver;

//int stopD = 1;
//while(stopD);

LengthInBytes = sizeof ( *YukonDriver );
YukonDriver = (YUKON_DRIVER *)AllocateZeroPool (sizeof (YUKON_DRIVER));
if (YukonDriver == NULL) {
return EFI_OUT_OF_RESOURCES;
}

EfiInitializeLock (&YukonDriver->Lock, TPL_NOTIFY);

//
//  Set the structure signature
//
ZeroMem (YukonDriver, LengthInBytes);
YukonDriver->Signature = YUKON_DRIVER_SIGNATURE;

Status = gBS->OpenProtocol (
   Controller,


   &gEfiPciIoProtocolGuid,


   (VOID **) &YukonDriver->PciIo,


   pThis->DriverBindingHandle,


   Controller,


   EFI_OPEN_PROTOCOL_BY_DRIVER


   );



if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Marvell Yukon: OpenProtocol: EFI_PCI_IO_PROTOCOL ERROR Status = %r\n", Status));
gBS->FreePool ( YukonDriver );
return Status;
}

//
//  Initialize the simple network protocol
//
Status = InitializeSNPProtocol ( YukonDriver );

if (EFI_ERROR(Status)){
DEBUG ((EFI_D_ERROR, "Marvell Yukon: InitializeSNPProtocol: ERROR Status = %r\n", Status));
gBS->CloseProtocol (
     Controller,


     &gEfiPciIoProtocolGuid,


     pThis->DriverBindingHandle,


     Controller


     );


}

//
// Set Device Path
//
Status = gBS->OpenProtocol (
   Controller,


   &gEfiDevicePathProtocolGuid,


   (VOID **) &ParentDevicePath,


   pThis->DriverBindingHandle,


   Controller,


   EFI_OPEN_PROTOCOL_BY_DRIVER


   );



if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_ERROR, "Marvell Yukon: OpenProtocol:EFI_DEVICE_PATH_PROTOCOL error. Status = %r\n", Status));

gBS->CloseProtocol (
     Controller,


     &gEfiPciIoProtocolGuid,


     pThis->DriverBindingHandle,


     Controller


     );



gBS->FreePool ( YukonDriver );
return Status;
}

ZeroMem (&MacDeviceNode, sizeof (MAC_ADDR_DEVICE_PATH));
MacDeviceNode.Header.Type = MESSAGING_DEVICE_PATH;
MacDeviceNode.Header.SubType = MSG_MAC_ADDR_DP;

SetDevicePathNodeLength (&MacDeviceNode.Header, sizeof (MAC_ADDR_DEVICE_PATH));

// Initialize Yukon card so we can get the MAC address
Status = mskc_attach (YukonDriver->PciIo, &YukonDriver->SnpMode.PermanentAddress);

if (EFI_ERROR (Status)) {
gBS->FreePool (YukonDriver);
return Status;
}

mskc_detach();

// Assign fields for device path
CopyMem (&YukonDriver->SnpMode.CurrentAddress, &YukonDriver->SnpMode.PermanentAddress, sizeof (EFI_MAC_ADDRESS));
CopyMem (&MacDeviceNode.MacAddress, &YukonDriver->SnpMode.CurrentAddress, PXE_HWADDR_LEN_ETHER);

MacDeviceNode.IfType = YukonDriver->SnpMode.IfType;
YukonDriver->DevicePath = AppendDevicePathNode ( ParentDevicePath,  (EFI_DEVICE_PATH_PROTOCOL *) &MacDeviceNode);
YukonDriver->Controller = NULL;

//
//  Install both the simple network and device path protocols.
//

Status = gBS->InstallMultipleProtocolInterfaces (
   &YukonDriver->Controller,


   &gEfiCallerIdGuid,


   YukonDriver,


   &gEfiSimpleNetworkProtocolGuid,


   &YukonDriver->Snp,


   &gEfiDevicePathProtocolGuid,


   YukonDriver->DevicePath,


   NULL


   );



if (EFI_ERROR(Status)){
DEBUG ((EFI_D_ERROR, "Marvell Yukon: InstallMultipleProtocolInterfaces error. Status = %r\n", Status));

gBS->CloseProtocol (
     Controller,


     &gEfiDevicePathProtocolGuid,


     pThis->DriverBindingHandle,


     Controller);



gBS->CloseProtocol (
     Controller,


     &gEfiPciIoProtocolGuid,


     pThis->DriverBindingHandle,


     Controller


     );



gBS->FreePool (YukonDriver);
return Status;
}

return Status;

+}



+/**

Stop this driver on Controller by removing NetworkInterfaceIdentifier protocol and
closing the DevicePath and PciIo protocols on Controller.

@param [in] pThis                   Protocol instance pointer.
@param [in] Controller              Handle of device to stop driver on.
@param [in] NumberOfChildren        How many children need to be stopped.
@param [in] pChildHandleBuffer      Not used.

@retval EFI_SUCCESS                 This driver is removed Controller.
@retval EFI_DEVICE_ERROR            The device could not be stopped due to a device error.
@retval other                       This driver was not removed from this device.


+**/
+EFI_STATUS
+EFIAPI
+MarvellYukonDriverStop (

IN  EFI_DRIVER_BINDING_PROTOCOL * pThis,
IN  EFI_HANDLE Controller,
IN  UINTN NumberOfChildren,
IN  EFI_HANDLE * ChildHandleBuffer
)

+{

EFI_SIMPLE_NETWORK_PROTOCOL  *SimpleNetwork;
EFI_STATUS                   Status = EFI_SUCCESS;
YUKON_DRIVER                 *YukonDriver;

//
// Complete all outstanding transactions to Controller.
// Don't allow any new transaction to Controller to be started.
//
Status = gBS->OpenProtocol (
   Controller,


   &gEfiSimpleNetworkProtocolGuid,


   (VOID **) &SimpleNetwork,


   pThis->DriverBindingHandle,


   Controller,


   EFI_OPEN_PROTOCOL_GET_PROTOCOL


   );



if (EFI_ERROR(Status)) {
gBS->CloseProtocol (
     Controller,


     &gEfiDevicePathProtocolGuid,


     pThis->DriverBindingHandle,


     Controller


     );


gBS->CloseProtocol (
     Controller,


     &gEfiPciIoProtocolGuid,


     pThis->DriverBindingHandle,


     Controller


     );


return EFI_SUCCESS;
}

YukonDriver = YUKON_DEV_FROM_THIS_SNP ( SimpleNetwork );

Status = gBS->UninstallMultipleProtocolInterfaces (
   Controller,


   &gEfiCallerIdGuid,


   YukonDriver,


   &gEfiSimpleNetworkProtocolGuid,


   &YukonDriver->Snp,


   &gEfiDevicePathProtocolGuid,


   YukonDriver->DevicePath,


   NULL


   );



if (EFI_ERROR (Status)) {
return Status;
}

Status = gBS->CloseProtocol (
   Controller,


   &gEfiDevicePathProtocolGuid,


   pThis->DriverBindingHandle,


   Controller


   );



if (EFI_ERROR(Status)){
DEBUG ((EFI_D_ERROR, "Marvell Yukon: MarvellYukonDriverStop: Close EfiDevicePathProtocol error. Status %r\n", Status));
}

Status = gBS->CloseProtocol (
   Controller,


   &gEfiPciIoProtocolGuid,


   pThis->DriverBindingHandle,


   Controller


   );



if (EFI_ERROR(Status)){
DEBUG ((EFI_D_ERROR, "Marvell Yukon: MarvellYukonDriverStop:Close EfiPciIoProtocol error. Status %r\n", Status));
}

gBS->FreePool (YukonDriver);
return EFI_SUCCESS;

+}



+//
+// Simple Network Protocol Driver Global Variables
+//
+EFI_DRIVER_BINDING_PROTOCOL gMarvellYukonDriverBinding = {

MarvellYukonDriverSupported,
MarvellYukonDriverStart,
MarvellYukonDriverStop,
0xa,
NULL,
NULL

+};



+/**

The Marvell Yukon driver entry point.

<at> param ImageHandle             The driver image handle.
<at> param SystemTable             The system table.

<at> retval EFI_SUCCESS            Initialization routine has found and initialized
                                 hardware successfully.


<at> retval Other                  Return value from HandleProtocol for
                                 DeviceIoProtocol or LoadedImageProtocol




+**/
+EFI_STATUS
+EFIAPI
+InitializeMarvellYukonDriver (

IN EFI_HANDLE       ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)

+{

EFI_HANDLE                           ControllerHandle;
EFI_EMBEDDED_DEVICE_CONFIG_PROTOCOL  *CfgProtocol;
EFI_STATUS                           Status;

DEBUG ((EFI_D_NET, "Marvell Yukon: InitializeMarvellYukonDriver()\n"));
Status = EfiLibInstallDriverBindingComponentName2 (
   ImageHandle,


   SystemTable,


   &gMarvellYukonDriverBinding,


   NULL,


   &gSimpleNetworkComponentName,


   &gSimpleNetworkComponentName2


   );



if (!EFI_ERROR (Status)) {
ControllerHandle = NULL;
if((CfgProtocol = AllocateZeroPool (sizeof (EFI_EMBEDDED_DEVICE_CONFIG_PROTOCOL))) != NULL) {

 InitializeDeviceConfigProtocol(CfgProtocol);


 Status = gBS->InstallProtocolInterface (


                 &ControllerHandle,


                 &gEfiEmbeddedDeviceConfigProtocolGuid,


                 EFI_NATIVE_INTERFACE,


                 CfgProtocol


                 );


} else {
 DEBUG ((EFI_D_NET, "Marvell Yukon: InitializeMarvellYukonDriver(): Device configuration protocol init failed\n"));


}
} else {
DEBUG ((EFI_D_NET, "Marvell Yukon: InitializeMarvellYukonDriver(): Driver binding failed\n"));
}

return Status;

+}
diff --git a/Drivers/Net/MarvellYukonDxe/MarvellYukon.h b/Drivers/Net/MarvellYukonDxe/MarvellYukon.h
new file mode 100644
index 0000000..02edf3a
--- /dev/null
+++ b/Drivers/Net/MarvellYukonDxe/MarvellYukon.h
@@ -0,0 +1,733 @@
+/**
+*
+*  Copyright (c) 2011-2016, ARM Limited. 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.
+*
+**/



+#ifndef _SNP_H_
+#define _SNP_H_




+#include <Uefi.h>



+#include <Protocol/SimpleNetwork.h>
+#include <Protocol/PciIo.h>
+#include <Protocol/DevicePath.h>
+#include <Protocol/EmbeddedDeviceConfig.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/NetLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/PcdLib.h>



+#include <IndustryStandard/Pci.h>



+//#define FOUR_GIGABYTES  (UINT64) 0x100000000ULL




+#define YUKON_DRIVER_SIGNATURE  SIGNATURE_32 ('m', 'y', 'u', 'k')
+/*#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
+*/



+typedef struct {

UINT32                      Signature;
EFI_LOCK                    Lock;

EFI_HANDLE Controller;

EFI_SIMPLE_NETWORK_PROTOCOL          Snp;
EFI_SIMPLE_NETWORK_MODE              SnpMode;

// Transmit Buffer recycle queue
#define TX_QUEUE_DEPTH 16
VOID              *TxQueue[TX_QUEUE_DEPTH];
UINTN             TxQueHead;
UINTN             TxQueTail;

EFI_HANDLE                  DeviceHandle;
EFI_DEVICE_PATH_PROTOCOL*   DevicePath;
EFI_PCI_IO_PROTOCOL*        PciIo;

//
//  Local instance data needed by SNP driver
//
//  EFI_EVENT              ExitBootServicesEvent;


+} YUKON_DRIVER;



+#define YUKON_DEV_FROM_THIS_SNP(a) CR (a, YUKON_DRIVER, Snp, YUKON_DRIVER_SIGNATURE)



+#define SNP_MEM_PAGES(x)  (((x) - 1) / 4096 + 1)



+//
+// Global Variables
+//
+extern EFI_COMPONENT_NAME_PROTOCOL    gSimpleNetworkComponentName;
+extern EFI_COMPONENT_NAME2_PROTOCOL   gSimpleNetworkComponentName2;



+//
+// The SNP driver control functions
+//



+EFI_STATUS
+InitializeSNPProtocol (

IN OUT  YUKON_DRIVER *YukonDriver
);


+/**

Changes the state of a network interface from "stopped" to "started".

This function starts a network interface. If the network interface successfully
starts, then EFI_SUCCESS will be returned.

<at> param  This                   A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.

<at> retval EFI_SUCCESS            The network interface was started.
<at> retval EFI_ALREADY_STARTED    The network interface is already in the started state.
<at> retval EFI_INVALID_PARAMETER  This parameter was NULL or did not point to a valid
                                 EFI_SIMPLE_NETWORK_PROTOCOL structure.


<at> retval EFI_DEVICE_ERROR       The command could not be sent to the network interface.
<at> retval EFI_UNSUPPORTED        This function is not supported by the network interface.


+**/
+EFI_STATUS
+EFIAPI
+SnpStart (

IN EFI_SIMPLE_NETWORK_PROTOCOL *This
);


+/**

Changes the state of a network interface from "started" to "stopped".

This function stops a network interface. This call is only valid if the network
interface is in the started state. If the network interface was successfully
stopped, then EFI_SUCCESS will be returned.

<at> param  This                   A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.


<at> retval EFI_SUCCESS            The network interface was stopped.
<at> retval EFI_NOT_STARTED        The network interface has not been started.
<at> retval EFI_INVALID_PARAMETER  This parameter was NULL or did not point to a valid
                                 EFI_SIMPLE_NETWORK_PROTOCOL structure.


<at> retval EFI_DEVICE_ERROR       The command could not be sent to the network interface.
<at> retval EFI_UNSUPPORTED        This function is not supported by the network interface.


+**/
+EFI_STATUS
+EFIAPI
+SnpStop (

IN EFI_SIMPLE_NETWORK_PROTOCOL *This
);


+//
+// The SNP protocol functions
+//




+/**

Resets a network adapter and allocates the transmit and receive buffers
required by the network interface; optionally, also requests allocation of
additional transmit and receive buffers.

This function allocates the transmit and receive buffers required by the network
interface. If this allocation fails, then EFI_OUT_OF_RESOURCES is returned.
If the allocation succeeds and the network interface is successfully initialized,
then EFI_SUCCESS will be returned.

<at> param This                    A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.

<at> param ExtraRxBufferSize       The size, in bytes, of the extra receive buffer space
                                 that the driver should allocate for the network interface.


                                 Some network interfaces will not be able to use the


                                 extra buffer, and the caller will not know if it is


                                 actually being used.


<at> param ExtraTxBufferSize       The size, in bytes, of the extra transmit buffer space
                                 that the driver should allocate for the network interface.


                                 Some network interfaces will not be able to use the


                                 extra buffer, and the caller will not know if it is


                                 actually being used.



<at> retval EFI_SUCCESS            The network interface was initialized.
<at> retval EFI_NOT_STARTED        The network interface has not been started.
<at> retval EFI_OUT_OF_RESOURCES   There was not enough memory for the transmit and
                                 receive buffers.


<at> retval EFI_INVALID_PARAMETER  This parameter was NULL or did not point to a valid
                                 EFI_SIMPLE_NETWORK_PROTOCOL structure.


<at> retval EFI_DEVICE_ERROR       The command could not be sent to the network interface.
<at> retval EFI_UNSUPPORTED        The increased buffer size feature is not supported.


+**/
+EFI_STATUS
+EFIAPI
+SnpInitialize (

IN EFI_SIMPLE_NETWORK_PROTOCOL *This,
IN UINTN                       ExtraRxBufferSize OPTIONAL,
IN UINTN                       ExtraTxBufferSize OPTIONAL
);


+/**

Resets a network adapter and reinitializes it with the parameters that were
provided in the previous call to Initialize().

This function resets a network adapter and reinitializes it with the parameters
that were provided in the previous call to Initialize(). The transmit and
receive queues are emptied and all pending interrupts are cleared.
Receive filters, the station address, the statistics, and the multicast-IP-to-HW
MAC addresses are not reset by this call. If the network interface was
successfully reset, then EFI_SUCCESS will be returned. If the driver has not
been initialized, EFI_DEVICE_ERROR will be returned.

<at> param This                    A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.
<at> param ExtendedVerification    Indicates that the driver may perform a more
                                 exhaustive verification operation of the device


                                 during reset.



<at> retval EFI_SUCCESS            The network interface was reset.
<at> retval EFI_NOT_STARTED        The network interface has not been started.
<at> retval EFI_INVALID_PARAMETER  One or more of the parameters has an unsupported value.
<at> retval EFI_DEVICE_ERROR       The command could not be sent to the network interface.
<at> retval EFI_UNSUPPORTED        This function is not supported by the network interface.


+**/
+EFI_STATUS
+EFIAPI
+SnpReset (

IN EFI_SIMPLE_NETWORK_PROTOCOL  *This,
IN BOOLEAN                      ExtendedVerification
);


+/**

Resets a network adapter and leaves it in a state that is safe for another
driver to initialize.

This function releases the memory buffers assigned in the Initialize() call.
Pending transmits and receives are lost, and interrupts are cleared and disabled.
After this call, only the Initialize() and Stop() calls may be used. If the
network interface was successfully shutdown, then EFI_SUCCESS will be returned.
If the driver has not been initialized, EFI_DEVICE_ERROR will be returned.

<at> param                         This  A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.

<at> retval EFI_SUCCESS            The network interface was shutdown.
<at> retval EFI_NOT_STARTED        The network interface has not been started.
<at> retval EFI_INVALID_PARAMETER  This parameter was NULL or did not point to a valid
                                 EFI_SIMPLE_NETWORK_PROTOCOL structure.


<at> retval EFI_DEVICE_ERROR       The command could not be sent to the network interface.


+**/
+EFI_STATUS
+EFIAPI
+SnpShutdown (

IN EFI_SIMPLE_NETWORK_PROTOCOL *This
);


+/**

Manages the multicast receive filters of a network interface.

This function is used enable and disable the hardware and software receive
filters for the underlying network device.
The receive filter change is broken down into three steps:

The filter mask bits that are set (ON) in the Enable parameter are added to


the current receive filter settings.

The filter mask bits that are set (ON) in the Disable parameter are subtracted


from the updated receive filter settings.

If the resulting receive filter setting is not supported by the hardware a


more liberal setting is selected.
If the same bits are set in the Enable and Disable parameters, then the bits
in the Disable parameter takes precedence.
If the ResetMCastFilter parameter is TRUE, then the multicast address list
filter is disabled (irregardless of what other multicast bits are set in the
Enable and Disable parameters). The SNP->SnpMode->MCastFilterCount field is set
to zero. The Snp->SnpMode->MCastFilter contents are undefined.
After enabling or disabling receive filter settings, software should verify
the new settings by checking the Snp->SnpMode->ReceiveFilterSettings,
Snp->SnpMode->MCastFilterCount and Snp->SnpMode->MCastFilter fields.
Note: Some network drivers and/or devices will automatically promote receive
filter settings if the requested setting can not be honored. For example, if
a request for four multicast addresses is made and the underlying hardware
only supports two multicast addresses the driver might set the promiscuous
or promiscuous multicast receive filters instead. The receiving software is
responsible for discarding any extra packets that get through the hardware
receive filters.
Note: Note: To disable all receive filter hardware, the network driver must
 be Shutdown() and Stopped(). Calling ReceiveFilters() with Disable set to


 Snp->SnpMode->ReceiveFilterSettings will make it so no more packets are


 returned by the Receive() function, but the receive hardware may still be


 moving packets into system memory before inspecting and discarding them.


 Unexpected system errors, reboots and hangs can occur if an OS is loaded


 and the network devices are not Shutdown() and Stopped().


If ResetMCastFilter is TRUE, then the multicast receive filter list on the
network interface will be reset to the default multicast receive filter list.
If ResetMCastFilter is FALSE, and this network interface allows the multicast
receive filter list to be modified, then the MCastFilterCnt and MCastFilter
are used to update the current multicast receive filter list. The modified
receive filter list settings can be found in the MCastFilter field of
EFI_SIMPLE_NETWORK_MODE. If the network interface does not allow the multicast
receive filter list to be modified, then EFI_INVALID_PARAMETER will be returned.
If the driver has not been initialized, EFI_DEVICE_ERROR will be returned.
If the receive filter mask and multicast receive filter list have been
successfully updated on the network interface, EFI_SUCCESS will be returned.

<at> param This                    A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.
<at> param Enable                  A bit mask of receive filters to enable on the network
                                 interface.


<at> param Disable                 A bit mask of receive filters to disable on the network
                                 interface. For backward compatibility with EFI 1.1


                                 platforms, the EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST bit


                                 must be set when the ResetMCastFilter parameter is TRUE.


<at> param ResetMCastFilter        Set to TRUE to reset the contents of the multicast
                                 receive filters on the network interface to their


                                 default values.


<at> param MCastFilterCnt          Number of multicast HW MAC addresses in the new MCastFilter
                                 list. This value must be less than or equal to the


                                 MCastFilterCnt field of EFI_SIMPLE_NETWORK_MODE.


                                 This field is optional if ResetMCastFilter is TRUE.


<at> param MCastFilter             A pointer to a list of new multicast receive filter HW
                                 MAC addresses. This list will replace any existing


                                 multicast HW MAC address list. This field is optional


                                 if ResetMCastFilter is TRUE.



<at> retval EFI_SUCCESS            The multicast receive filter list was updated.
<at> retval EFI_NOT_STARTED        The network interface has not been started.
<at> retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
                                 * This is NULL


                                 * There are bits set in Enable that are not set


                                   in Snp->SnpMode->ReceiveFilterMask


                                 * There are bits set in Disable that are not set


                                   in Snp->SnpMode->ReceiveFilterMask


                                 * Multicast is being enabled (the


                                   EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST bit is


                                   set in Enable, it is not set in Disable, and


                                   ResetMCastFilter is FALSE) and MCastFilterCount


                                   is zero


                                 * Multicast is being enabled and MCastFilterCount


                                   is greater than Snp->SnpMode->MaxMCastFilterCount


                                 * Multicast is being enabled and MCastFilter is NULL


                                 * Multicast is being enabled and one or more of


                                   the addresses in the MCastFilter list are not


                                   valid multicast MAC addresses


<at> retval EFI_DEVICE_ERROR       One or more of the following conditions is TRUE:
                                 * The network interface has been started but has


                                   not been initialized


                                 * An unexpected error was returned by the


                                   underlying network driver or device


<at> retval EFI_UNSUPPORTED        This function is not supported by the network
                                 interface.




+**/
+EFI_STATUS
+EFIAPI
+SnpReceiveFilters (

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
);


+/**

Modifies or resets the current station address, if supported.

This function modifies or resets the current station address of a network
interface, if supported. If Reset is TRUE, then the current station address is
set to the network interface's permanent address. If Reset is FALSE, and the
network interface allows its station address to be modified, then the current
station address is changed to the address specified by New. If the network
interface does not allow its station address to be modified, then
EFI_INVALID_PARAMETER will be returned. If the station address is successfully
updated on the network interface, EFI_SUCCESS will be returned. If the driver
has not been initialized, EFI_DEVICE_ERROR will be returned.

<at> param This  A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.
<at> param Reset Flag used to reset the station address to the network interface's
          permanent address.


<at> param New   New station address to be used for the network interface.


<at> retval EFI_SUCCESS            The network interface's station address was updated.
<at> retval EFI_NOT_STARTED        The Simple Network Protocol interface has not been
                                 started by calling Start().


<at> retval EFI_INVALID_PARAMETER  The New station address was not accepted by the NIC.
<at> retval EFI_INVALID_PARAMETER  Reset is FALSE and New is NULL.
<at> retval EFI_DEVICE_ERROR       The Simple Network Protocol interface has not
                                 been initialized by calling Initialize().


<at> retval EFI_DEVICE_ERROR       An error occurred attempting to set the new
                                 station address.


<at> retval EFI_UNSUPPORTED        The NIC does not support changing the network
                                 interface's station address.




+**/
+EFI_STATUS
+EFIAPI
+SnpStationAddress (

IN EFI_SIMPLE_NETWORK_PROTOCOL *This,
IN BOOLEAN                     Reset,
IN EFI_MAC_ADDRESS             *New  OPTIONAL
);


+/**

Resets or collects the statistics on a network interface.

This function resets or collects the statistics on a network interface. If the
size of the statistics table specified by StatisticsSize is not big enough for
all the statistics that are collected by the network interface, then a partial
buffer of statistics is returned in StatisticsTable, StatisticsSize is set to
the size required to collect all the available statistics, and
EFI_BUFFER_TOO_SMALL is returned.
If StatisticsSize is big enough for all the statistics, then StatisticsTable
will be filled, StatisticsSize will be set to the size of the returned
StatisticsTable structure, and EFI_SUCCESS is returned.
If the driver has not been initialized, EFI_DEVICE_ERROR will be returned.
If Reset is FALSE, and both StatisticsSize and StatisticsTable are NULL, then
no operations will be performed, and EFI_SUCCESS will be returned.
If Reset is TRUE, then all of the supported statistics counters on this network
interface will be reset to zero.

<at> param This                    A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.
<at> param Reset                   Set to TRUE to reset the statistics for the network interface.
<at> param StatisticsSize          On input the size, in bytes, of StatisticsTable. On output
                                 the size, in bytes, of the resulting table of statistics.


<at> param StatisticsTable         A pointer to the EFI_NETWORK_STATISTICS structure that
                                 contains the statistics. Type EFI_NETWORK_STATISTICS is


                                 defined in "Related Definitions" below.



<at> retval EFI_SUCCESS            The requested operation succeeded.
<at> retval EFI_NOT_STARTED        The Simple Network Protocol interface has not been
                                 started by calling Start().


<at> retval EFI_BUFFER_TOO_SMALL   StatisticsSize is not NULL and StatisticsTable is
                                 NULL. The current buffer size that is needed to


                                 hold all the statistics is returned in StatisticsSize.


<at> retval EFI_BUFFER_TOO_SMALL   StatisticsSize is not NULL and StatisticsTable is
                                 not NULL. The current buffer size that is needed


                                 to hold all the statistics is returned in


                                 StatisticsSize. A partial set of statistics is


                                 returned in StatisticsTable.


<at> retval EFI_INVALID_PARAMETER  StatisticsSize is NULL and StatisticsTable is not
                                 NULL.


<at> retval EFI_DEVICE_ERROR       The Simple Network Protocol interface has not
                                 been initialized by calling Initialize().


<at> retval EFI_DEVICE_ERROR       An error was encountered collecting statistics
                                 from the NIC.


<at> retval EFI_UNSUPPORTED        The NIC does not support collecting statistics
                                 from the network interface.




+**/
+EFI_STATUS
+EFIAPI
+SnpStatistics (

IN EFI_SIMPLE_NETWORK_PROTOCOL *This,
IN BOOLEAN                     Reset,
IN OUT UINTN                   *StatisticsSize,  OPTIONAL
IN OUT EFI_NETWORK_STATISTICS  *StatisticsTable  OPTIONAL
);


+/**

Converts a multicast IP address to a multicast HW MAC address.

This function converts a multicast IP address to a multicast HW MAC address
for all packet transactions. If the mapping is accepted, then EFI_SUCCESS will
be returned.

<at> param This                    A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.
<at> param IPv6                    Set to TRUE if the multicast IP address is IPv6 [RFC 2460].
                                 Set to FALSE if the multicast IP address is IPv4 [RFC 791].


<at> param IP                      The multicast IP address that is to be converted to a multicast
                                 HW MAC address.


<at> param MAC                     The multicast HW MAC address that is to be generated from IP.

<at> retval EFI_SUCCESS            The multicast IP address was mapped to the
                                 multicast HW MAC address.


<at> retval EFI_NOT_STARTED        The Simple Network Protocol interface has not
                                 been started by calling Start().


<at> retval EFI_INVALID_PARAMETER  IP is NULL.
<at> retval EFI_INVALID_PARAMETER  MAC is NULL.
<at> retval EFI_INVALID_PARAMETER  IP does not point to a valid IPv4 or IPv6
                                 multicast address.


<at> retval EFI_DEVICE_ERROR       The Simple Network Protocol interface has not
                                 been initialized by calling Initialize().


<at> retval EFI_UNSUPPORTED        IPv6 is TRUE and the implementation does not
                                 support IPv6 multicast to MAC address conversion.




+**/
+EFI_STATUS
+EFIAPI
+SnpMcastIpToMac (

IN EFI_SIMPLE_NETWORK_PROTOCOL *This,
IN BOOLEAN                     IPv6,
IN EFI_IP_ADDRESS              *IP,
OUT EFI_MAC_ADDRESS            *MAC
);


+/**

Performs read and write operations on the NVRAM device attached to a network
interface.

This function performs read and write operations on the NVRAM device attached
to a network interface. If ReadWrite is TRUE, a read operation is performed.
If ReadWrite is FALSE, a write operation is performed. Offset specifies the
byte offset at which to start either operation. Offset must be a multiple of
NvRamAccessSize , and it must have a value between zero and NvRamSize.
BufferSize specifies the length of the read or write operation. BufferSize must
also be a multiple of NvRamAccessSize, and Offset + BufferSize must not exceed
NvRamSize.
If any of the above conditions is not met, then EFI_INVALID_PARAMETER will be
returned.
If all the conditions are met and the operation is "read," the NVRAM device
attached to the network interface will be read into Buffer and EFI_SUCCESS
will be returned. If this is a write operation, the contents of Buffer will be
used to update the contents of the NVRAM device attached to the network
interface and EFI_SUCCESS will be returned.

It does the basic checking on the input parameters and retrieves snp structure
and then calls the read_nvdata() call which does the actual reading

<at> param This                    A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.
<at> param ReadWrite               TRUE for read operations, FALSE for write operations.
<at> param Offset                  Byte offset in the NVRAM device at which to start the read or
                                 write operation. This must be a multiple of NvRamAccessSize


                                 and less than NvRamSize. (See EFI_SIMPLE_NETWORK_MODE)


<at> param BufferSize              The number of bytes to read or write from the NVRAM device.
                                 This must also be a multiple of NvramAccessSize.


<at> param Buffer                  A pointer to the data buffer.

<at> retval EFI_SUCCESS            The NVRAM access was performed.
<at> retval EFI_NOT_STARTED        The network interface has not been started.
<at> retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
                                 * The This parameter is NULL


                                 * The This parameter does not point to a valid


                                   EFI_SIMPLE_NETWORK_PROTOCOL  structure


                                 * The Offset parameter is not a multiple of


                                   EFI_SIMPLE_NETWORK_MODE.NvRamAccessSize


                                 * The Offset parameter is not less than


                                   EFI_SIMPLE_NETWORK_MODE.NvRamSize


                                 * The BufferSize parameter is not a multiple of


                                   EFI_SIMPLE_NETWORK_MODE.NvRamAccessSize


                                 * The Buffer parameter is NULL


<at> retval EFI_DEVICE_ERROR       The command could not be sent to the network
                                 interface.


<at> retval EFI_UNSUPPORTED        This function is not supported by the network
                                 interface.




+**/
+EFI_STATUS
+EFIAPI
+SnpNvData (

IN EFI_SIMPLE_NETWORK_PROTOCOL *This,
IN BOOLEAN                     ReadWrite,
IN UINTN                       Offset,
IN UINTN                       BufferSize,
IN OUT VOID                    *Buffer
);


+/**

Reads the current interrupt status and recycled transmit buffer status from a
network interface.

This function gets the current interrupt and recycled transmit buffer status
from the network interface. The interrupt status is returned as a bit mask in
InterruptStatus. If InterruptStatus is NULL, the interrupt status will not be
read. If TxBuf is not NULL, a recycled transmit buffer address will be retrieved.
If a recycled transmit buffer address is returned in TxBuf, then the buffer has
been successfully transmitted, and the status for that buffer is cleared. If
the status of the network interface is successfully collected, EFI_SUCCESS
will be returned. If the driver has not been initialized, EFI_DEVICE_ERROR will
be returned.

<at> param This                    A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.
<at> param InterruptStatus         A pointer to the bit mask of the currently active
                                 interrupts (see "Related Definitions"). If this is NULL,


                                 the interrupt status will not be read from the device.


                                 If this is not NULL, the interrupt status will be read


                                 from the device. When the interrupt status is read, it


                                 will also be cleared. Clearing the transmit interrupt does


                                 not empty the recycled transmit buffer array.


<at> param TxBuf                   Recycled transmit buffer address. The network interface
                                 will not transmit if its internal recycled transmit


                                 buffer array is full. Reading the transmit buffer does


                                 not clear the transmit interrupt. If this is NULL, then


                                 the transmit buffer status will not be read. If there


                                 are no transmit buffers to recycle and TxBuf is not NULL,


                                 TxBuf will be set to NULL.



<at> retval EFI_SUCCESS            The status of the network interface was retrieved.
<at> retval EFI_NOT_STARTED        The network interface has not been started.
<at> retval EFI_INVALID_PARAMETER  This parameter was NULL or did not point to a valid
                                 EFI_SIMPLE_NETWORK_PROTOCOL structure.


<at> retval EFI_DEVICE_ERROR       The command could not be sent to the network
                                 interface.




+**/
+EFI_STATUS
+EFIAPI
+SnpGetStatus (

IN EFI_SIMPLE_NETWORK_PROTOCOL *This,
OUT UINT32                     *InterruptStatus, OPTIONAL
OUT VOID                       **TxBuf           OPTIONAL
);


+/**

Places a packet in the transmit queue of a network interface.

This function places the packet specified by Header and Buffer on the transmit
queue. If HeaderSize is nonzero and HeaderSize is not equal to
This->SnpMode->MediaHeaderSize, then EFI_INVALID_PARAMETER will be returned. If
BufferSize is less than This->SnpMode->MediaHeaderSize, then EFI_BUFFER_TOO_SMALL
will be returned. If Buffer is NULL, then EFI_INVALID_PARAMETER will be
returned. If HeaderSize is nonzero and DestAddr or Protocol is NULL, then
EFI_INVALID_PARAMETER will be returned. If the transmit engine of the network
interface is busy, then EFI_NOT_READY will be returned. If this packet can be
accepted by the transmit engine of the network interface, the packet contents
specified by Buffer will be placed on the transmit queue of the network
interface, and EFI_SUCCESS will be returned. GetStatus() can be used to
determine when the packet has actually been transmitted. The contents of the
Buffer must not be modified until the packet has actually been transmitted.
The Transmit() function performs nonblocking I/O. A caller who wants to perform
blocking I/O, should call Transmit(), and then GetStatus() until the
transmitted buffer shows up in the recycled transmit buffer.
If the driver has not been initialized, EFI_DEVICE_ERROR will be returned.

<at> param This                    A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.
<at> param HeaderSize              The size, in bytes, of the media header to be filled in by the
                                 Transmit() function. If HeaderSize is nonzero, then it must


                                 be equal to This->SnpMode->MediaHeaderSize and the DestAddr and


                                 Protocol parameters must not be NULL.


<at> param BufferSize              The size, in bytes, of the entire packet (media header and
                                 data) to be transmitted through the network interface.


<at> param Buffer                  A pointer to the packet (media header followed by data) to be
                                 transmitted. This parameter cannot be NULL. If HeaderSize is


                                 zero, then the media header in Buffer must already be filled


                                 in by the caller. If HeaderSize is nonzero, then the media


                                 header will be filled in by the Transmit() function.


<at> param SrcAddr                 The source HW MAC address. If HeaderSize is zero, then this
                                 parameter is ignored. If HeaderSize is nonzero and SrcAddr


                                 is NULL, then This->SnpMode->CurrentAddress is used for the


                                 source HW MAC address.


<at> param DestAddr                The destination HW MAC address. If HeaderSize is zero, then
                                 this parameter is ignored.


<at> param Protocol                The type of header to build. If HeaderSize is zero, then this
                                 parameter is ignored. See RFC 1700, section "Ether Types,"


                                 for examples.



<at> retval EFI_SUCCESS            The packet was placed on the transmit queue.
<at> retval EFI_NOT_STARTED        The network interface has not been started.
<at> retval EFI_NOT_READY          The network interface is too busy to accept this
                                 transmit request.


<at> retval EFI_BUFFER_TOO_SMALL   The BufferSize parameter is too small.
<at> retval EFI_INVALID_PARAMETER  One or more of the parameters has an unsupported
                                 value.


<at> retval EFI_DEVICE_ERROR       The command could not be sent to the network interface.
<at> retval EFI_UNSUPPORTED        This function is not supported by the network interface.


+**/
+EFI_STATUS
+EFIAPI
+SnpTransmit (

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
);


+/**

Receives a packet from a network interface.

This function retrieves one packet from the receive queue of a network interface.
If there are no packets on the receive queue, then EFI_NOT_READY will be
returned. If there is a packet on the receive queue, and the size of the packet
is smaller than BufferSize, then the contents of the packet will be placed in
Buffer, and BufferSize will be updated with the actual size of the packet.
In addition, if SrcAddr, DestAddr, and Protocol are not NULL, then these values
will be extracted from the media header and returned. EFI_SUCCESS will be
returned if a packet was successfully received.
If BufferSize is smaller than the received packet, then the size of the receive
packet will be placed in BufferSize and EFI_BUFFER_TOO_SMALL will be returned.
If the driver has not been initialized, EFI_DEVICE_ERROR will be returned.

<at> param This                    A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.
<at> param HeaderSize              The size, in bytes, of the media header received on the network
                                 interface. If this parameter is NULL, then the media header size


                                 will not be returned.


<at> param BufferSize              On entry, the size, in bytes, of Buffer. On exit, the size, in
                                 bytes, of the packet that was received on the network interface.


<at> param Buffer                  A pointer to the data buffer to receive both the media
                                 header and the data.


<at> param SrcAddr                 The source HW MAC address. If this parameter is NULL, the HW
                                 MAC source address will not be extracted from the media header.


<at> param DestAddr                The destination HW MAC address. If this parameter is NULL,
                                 the HW MAC destination address will not be extracted from


                                 the media header.


<at> param Protocol                The media header type. If this parameter is NULL, then the
                                 protocol will not be extracted from the media header. See


                                 RFC 1700 section "Ether Types" for examples.



<at> retval EFI_SUCCESS            The received data was stored in Buffer, and
                                 BufferSize has been updated to the number of


                                 bytes received.


<at> retval EFI_NOT_STARTED        The network interface has not been started.
<at> retval EFI_NOT_READY          No packets have been received on the network interface.
<at> retval EFI_BUFFER_TOO_SMALL   BufferSize is too small for the received packets.
                                 BufferSize has been updated to the required size.


<at> retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
                                 * The This parameter is NULL


                                 * The This parameter does not point to a valid


                                   EFI_SIMPLE_NETWORK_PROTOCOL structure.


                                 * The BufferSize parameter is NULL


                                 * The Buffer parameter is NULL


<at> retval EFI_DEVICE_ERROR       The command could not be sent to the network interface.


+**/
+EFI_STATUS
+EFIAPI
+SnpReceive (

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
);


+/**

Nofication call back function for WaitForPacket event.

<at> param  Event       EFI Event.
<at> param  SnpPtr      Pointer to YUKON_DRIVER structure.


+**/
+VOID
+EFIAPI
+SnpWaitForPacketNotify (

EFI_EVENT Event,
VOID      *SnpPtr
);



+#endif /*  _SNP_H_  */
diff --git a/Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.dec b/Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.dec
new file mode 100644
index 0000000..fe0a85a
--- /dev/null
+++ b/Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.dec
@@ -0,0 +1,29 @@
+#/** @file
+#
+#  Copyright (c) 2011-2016, ARM Limited. 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.
+#
+#**/



+[Defines]

DEC_SPECIFICATION              = 0x00010005
PACKAGE_NAME                   = MarvellYukonDxe
PACKAGE_GUID                   = 6a48c93e-121e-11e6-b469-fbac4ae107ed
PACKAGE_VERSION                = 0.01



+[Includes]



+[LibraryClasses]



+[Protocols]



+[PcdsFixedAtBuild.common]

gEmbeddedTokenSpaceGuid.PcdYukonMacAddress|0|UINT64|0x00000057

diff --git a/Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.inf b/Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.inf
new file mode 100644
index 0000000..aae8707
--- /dev/null
+++ b/Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.inf
@@ -0,0 +1,77 @@
+##  <at> file
+# Component description file for Marvell Yukon II SNP module.
+#
+# Copyright (c) 2011-2016, ARM Ltd. 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]

INF_VERSION                    = 0x00010005
BASE_NAME                      = MarvellYukonDxe
FILE_GUID                      = d7de5d0c-99f8-4970-b85c-c19df8997d7d
MODULE_TYPE                    = UEFI_DRIVER
VERSION_STRING                 = 1.0
ENTRY_POINT                    = InitializeMarvellYukonDriver


+#
+# The following information is for reference only and not required by the build tools.
+#
+#  DRIVER_BINDING                =  gMarvellYukonDriverBinding
+#  COMPONENT_NAME                =  gSimpleNetworkComponentName
+#  COMPONENT_NAME2               =  gSimpleNetworkComponentName2
+#



+[Sources]

Snp.c
DriverBinding.c
ComponentName.c
e1000phy.c
if_msk.c
DeviceConfig.c



+[Packages]

EmbeddedPkg/EmbeddedPkg.dec
NetworkPkg/NetworkPkg.dec
MdeModulePkg/MdeModulePkg.dec
MdePkg/MdePkg.dec
OpenPlatformPkg/Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.dec


+[LibraryClasses]

UefiLib
BaseLib
UefiBootServicesTableLib
UefiDriverEntryPoint
BaseMemoryLib
MemoryAllocationLib
IoLib
DebugLib
TimerLib
NetLib
ArmLib
DevicePathLib


+[Pcd]

gEmbeddedTokenSpaceGuid.PcdYukonMacAddress


+#[Guids]
+#  gEfiEventExitBootServicesGuid                 ## CONSUMES



+[Protocols]

gEfiPciIoProtocolGuid
gEfiSimpleNetworkProtocolGuid
gEfiMetronomeArchProtocolGuid
gEfiPxeBaseCodeProtocolGuid
gEfiDevicePathProtocolGuid
gEfiEmbeddedDeviceConfigProtocolGuid


+[Depex]

TRUE

--
2.7.4

Linaro-uefi mailing list
Linaro-uefi@lists.linaro.org
https://lists.linaro.org/mailman/listinfo/linaro-uefi

    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

Re: [Linaro-uefi] [PATCH v3 2/4] OpenPlatformPkg/MarvellYukonDxe: Marvell Yukon NIC driver