[Linaro-uefi] [PATCH v4 1/4] OpenPlatformPkg/MarvellYukonDxe: Marvell Yukon NIC driver 1/3

The UEFI driver for Marvell Yukon NIC, part 1

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 | 510 +++++++++++++++++ Drivers/Net/MarvellYukonDxe/MarvellYukon.h | 712 ++++++++++++++++++++++++ Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.dec | 29 + Drivers/Net/MarvellYukonDxe/MarvellYukonDxe.inf | 77 +++ 7 files changed, 2069 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..69e1957 --- /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_ERROR, "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..eddc4f5 --- /dev/null +++ b/Drivers/Net/MarvellYukonDxe/DriverBinding.c @@ -0,0 +1,510 @@ +/** <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; + } else { + DEBUG ((EFI_D_NET, "Marvell Yukon: MarvellYukonDriverSupported: Supported Controller = %p\n", Controller)); + } + + gBS->CloseProtocol ( + Controller, + &gEfiPciIoProtocolGuid, + This->DriverBindingHandle, + Controller + ); + } + + 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; + MAC_ADDR_DEVICE_PATH MacDeviceNode; + VOID *ChildPciIo; + YUKON_DRIVER *YukonDriver; + + LengthInBytes = sizeof (*YukonDriver); + YukonDriver = (YUKON_DRIVER *)AllocateZeroPool (sizeof (YUKON_DRIVER)); + if (YukonDriver == NULL) { + DEBUG ((EFI_D_ERROR, "Marvell Yukon: AllocateZeroPool() failed with Status = %r\n", EFI_OUT_OF_RESOURCES)); + 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_GET_PROTOCOL + ); + + 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, sizeof (MacDeviceNode)); + + // + // 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, sizeof (EFI_MAC_ADDRESS)); + + MacDeviceNode.IfType = YukonDriver->SnpMode.IfType; + YukonDriver->DevicePath = AppendDevicePathNode (ParentDevicePath, &MacDeviceNode.Header); + if (YukonDriver->DevicePath == NULL) { + DEBUG ((EFI_D_ERROR, "Marvell Yukon: AppendDevicePathNode: ERROR Status = %r\n", EFI_OUT_OF_RESOURCES)); + gBS->CloseProtocol ( + Controller, + &gEfiPciIoProtocolGuid, + pThis->DriverBindingHandle, + Controller + ); + gBS->FreePool (YukonDriver); + return EFI_OUT_OF_RESOURCES; + } + + // + // Install both the simple network and device path protocols. + // + Status = gBS->InstallMultipleProtocolInterfaces ( + &YukonDriver->Controller, + &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, + &gEfiPciIoProtocolGuid, + pThis->DriverBindingHandle, + Controller + ); + + gBS->FreePool (YukonDriver->DevicePath); + gBS->FreePool (YukonDriver); + return Status; + } else { + + // + // Hook as a child device + // + Status = gBS->OpenProtocol (Controller, + &gEfiPciIoProtocolGuid, + &ChildPciIo, + pThis->DriverBindingHandle, + YukonDriver->Controller, + EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER); + if (EFI_ERROR(Status)){ + DEBUG ((EFI_D_ERROR, "Marvell Yukon: OpenProtocol: child controller error. Status = %r\n", Status)); + + gBS->UninstallMultipleProtocolInterfaces ( + Controller, + &gEfiSimpleNetworkProtocolGuid, + &YukonDriver->Snp, + &gEfiDevicePathProtocolGuid, + YukonDriver->DevicePath, + NULL + ); + + gBS->CloseProtocol ( + Controller, + &gEfiPciIoProtocolGuid, + pThis->DriverBindingHandle, + Controller + ); + + gBS->FreePool (YukonDriver->DevicePath); + gBS->FreePool (YukonDriver); + return Status; + } else { + DEBUG ((EFI_D_NET, "Marvell Yukon: MarvellYukonDriverSupported: New Controller Handle = %p\n", YukonDriver->Controller)); + } + } + + if (!EFI_ERROR(Status)) { + Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_CALLBACK, + &MarvellYukonNotifyExitBoot, YukonDriver, &YukonDriver->ExitBootEvent); + } + + 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; + YUKON_DRIVER *YukonDriver; + EFI_TPL OldTpl; + + if (pThis == NULL) { + DEBUG ((EFI_D_ERROR, "Marvell Yukon: MarvellYukonDriverStop() failed with Status = %r\n", EFI_INVALID_PARAMETER)); + return EFI_INVALID_PARAMETER; + } + + if (NumberOfChildren > 0 && ChildHandleBuffer == NULL) { + DEBUG ((EFI_D_ERROR, "Marvell Yukon: MarvellYukonDriverStop() failed with Status = %r\n", EFI_INVALID_PARAMETER)); + return EFI_INVALID_PARAMETER; + } + + if (NumberOfChildren > 0) { + + // + // Currently support only one network port + // + ASSERT (NumberOfChildren == 1); + + Status = gBS->OpenProtocol ( + ChildHandleBuffer[0], + &gEfiSimpleNetworkProtocolGuid, + (VOID **) &SimpleNetwork, + pThis->DriverBindingHandle, + Controller, + EFI_OPEN_PROTOCOL_GET_PROTOCOL + ); + + if (!EFI_ERROR(Status)) { + + YukonDriver = YUKON_DEV_FROM_THIS_SNP (SimpleNetwork); + OldTpl = gBS->RaiseTPL (TPL_CALLBACK); + + ASSERT (YukonDriver->Controller == ChildHandleBuffer[0]); + if (YukonDriver->SnpMode.State != EfiSimpleNetworkStopped) { + + // + // Device in use, cannot stop driver instance + // + Status = EFI_DEVICE_ERROR; + DEBUG ((EFI_D_ERROR, "Marvell Yukon: MarvellYukonDriverStop: Error: SNP is not stopped. Status %r\n", Status)); + } else { + + // + // Unhook the child controller + // + gBS->CloseProtocol (Controller, + &gEfiPciIoProtocolGuid, + pThis->DriverBindingHandle, + YukonDriver->Controller); + + Status = gBS->UninstallMultipleProtocolInterfaces ( + YukonDriver->Controller, + &gEfiSimpleNetworkProtocolGuid, + &YukonDriver->Snp, + &gEfiDevicePathProtocolGuid, + YukonDriver->DevicePath, + NULL + ); + + if (EFI_ERROR(Status)){ + DEBUG ((EFI_D_ERROR, "Marvell Yukon: MarvellYukonDriverStop:UninstallMultipleProtocolInterfaces error. Status %r\n", Status)); + } + + gBS->CloseEvent (YukonDriver->ExitBootEvent); + gBS->FreePool (YukonDriver->DevicePath); + gBS->FreePool (YukonDriver); + } + gBS->RestoreTPL (OldTpl); + } + } else { + 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)); + } + } + + return Status; +} + +/** + Process exit boot event. + + @param [in] Event Event id. + @param [in] Context Driver context. + +**/ +VOID +EFIAPI +MarvellYukonNotifyExitBoot ( + IN EFI_EVENT Event, + IN VOID *Context + ) +{ + YUKON_DRIVER *YukonDriver; + EFI_STATUS Status; + + if (Context == NULL) { + DEBUG ((EFI_D_ERROR, "Marvell Yukon: MarvellYukonNotifyExitBoot() failed with Status = %r\n", EFI_INVALID_PARAMETER)); + } else { + + YukonDriver = Context; + + if (YukonDriver->SnpMode.State != EfiSimpleNetworkStopped) { + Status = YukonDriver->Snp.Shutdown(&YukonDriver->Snp); + if (!EFI_ERROR (Status)) { + YukonDriver->Snp.Stop(&YukonDriver->Snp); + } + } + } +} + +// +// 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")); + + if (SystemTable == NULL) { + DEBUG ((EFI_D_ERROR, "Marvell Yukon: InitializeMarvellYukonDriver() failed with Status = %r\n", EFI_INVALID_PARAMETER)); + return EFI_INVALID_PARAMETER; + } + + 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_ERROR, "Marvell Yukon: InitializeMarvellYukonDriver(): Device configuration protocol init failed\n")); + } + } else { + DEBUG ((EFI_D_ERROR, "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..6d03811 --- /dev/null +++ b/Drivers/Net/MarvellYukonDxe/MarvellYukon.h @@ -0,0 +1,712 @@ +/** +* +* 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 YUKON_DRIVER_SIGNATURE SIGNATURE_32 ('m', 'y', 'u', 'k') + +typedef struct { + UINT32 Signature; + EFI_LOCK Lock; + + EFI_HANDLE Controller; + EFI_EVENT ExitBootEvent; + + EFI_SIMPLE_NETWORK_PROTOCOL Snp; + EFI_SIMPLE_NETWORK_MODE SnpMode; + + EFI_HANDLE DeviceHandle; + EFI_DEVICE_PATH_PROTOCOL* DevicePath; + EFI_PCI_IO_PROTOCOL* PciIo; + +} 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 + ); + +#endif + +/** + Process exit boot event. + + @param [in] Event Event id. + @param [in] Context Driver context. + +**/ +VOID +EFIAPI +MarvellYukonNotifyExitBoot ( + IN EFI_EVENT Event, + IN VOID *Context + ); + +/* _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