From: vanjeff Date: Wed, 20 Feb 2008 02:20:05 +0000 (+0000) Subject: Rename callback.c to Callback.c X-Git-Tag: edk2-stable201903~21477 X-Git-Url: https://git.proxmox.com/?p=mirror_edk2.git;a=commitdiff_plain;h=5e7e4fadc06dce933810ff1764e3f07707c4608f Rename callback.c to Callback.c git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@4718 6f19259b-4bc3-4df7-8a09-765794883524 --- diff --git a/MdeModulePkg/Universal/Network/SnpDxe/Callback.c b/MdeModulePkg/Universal/Network/SnpDxe/Callback.c new file mode 100644 index 0000000000..c246874917 --- /dev/null +++ b/MdeModulePkg/Universal/Network/SnpDxe/Callback.c @@ -0,0 +1,611 @@ +/*++ +Copyright (c) 2006, Intel Corporation +All rights reserved. This program and the accompanying materials +are licensed and made available under the terms and conditions of the BSD License +which accompanies this distribution. The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +Module name: + callback.c + +Abstract: + This file contains two sets of callback routines for undi3.0 and undi3.1. + the callback routines for Undi3.1 have an extra parameter UniqueId which + stores the interface context for the NIC that snp is trying to talk.. + +--*/ + + +#include "Snp.h" + +// +// Global variables +// these 2 global variables are used only for 3.0 undi. we could not place +// them in the snp structure because we will not know which snp structure +// in the callback context! +// +STATIC BOOLEAN mInitializeLock = TRUE; +STATIC EFI_LOCK mLock; + +// +// End Global variables +// +extern EFI_PCI_IO_PROTOCOL *mPciIoFncs; + +VOID +snp_undi32_callback_v2p_30 ( + IN UINT64 CpuAddr, + IN OUT UINT64 DeviceAddrPtr + ) +/*++ + +Routine Description: + This is a callback routine supplied to UNDI at undi_start time. + UNDI call this routine with a virtual or CPU address that SNP provided + to convert it to a physical or device address. Since EFI uses the identical + mapping, this routine returns the physical address same as the virtual address + for most of the addresses. an address above 4GB cannot generally be used as a + device address, it needs to be mapped to a lower physical address. This routine + does not call the map routine itself, but it assumes that the mapping was done + at the time of providing the address to UNDI. This routine just looks up the + address in a map table (which is the v2p structure chain) + +Arguments: + CpuAddr - virtual address of a buffer + DeviceAddrPtr - pointer to the physical address + +Returns: + void - The DeviceAddrPtr will contain 0 in case of any error + +--*/ +{ + struct s_v2p *v2p; + // + // Do nothing if virtual address is zero or physical pointer is NULL. + // No need to map if the virtual address is within 4GB limit since + // EFI uses identical mapping + // + if ((CpuAddr == 0) || (DeviceAddrPtr == 0)) { + DEBUG ((EFI_D_ERROR, "\nv2p: Null virtual address or physical pointer.\n")); + return ; + } + + if (CpuAddr < FOUR_GIGABYTES) { + *(UINT64 *) (UINTN) DeviceAddrPtr = CpuAddr; + return ; + } + // + // SNP creates a vaddr tp paddr mapping at the time of calling undi with any + // big address, this callback routine just looks up in the v2p list and + // returns the physical address for any given virtual address. + // + if (find_v2p (&v2p, (VOID *) (UINTN) CpuAddr) != EFI_SUCCESS) { + *(UINT64 *) (UINTN) DeviceAddrPtr = CpuAddr; + } else { + *(UINT64 *) (UINTN) DeviceAddrPtr = v2p->paddr; + } +} + +VOID +snp_undi32_callback_block_30 ( + IN UINT32 Enable + ) +/*++ + +Routine Description: + This is a callback routine supplied to UNDI at undi_start time. + UNDI call this routine when it wants to have exclusive access to a critical + section of the code/data + +Arguments: + Enable - non-zero indicates acquire + zero indicates release + +Returns: + void +--*/ +{ + // + // tcpip was calling snp at tpl_notify and if we acquire a lock that was + // created at a lower level (TPL_CALLBACK) it gives an assert! + // + if (mInitializeLock) { + EfiInitializeLock (&mLock, TPL_NOTIFY); + mInitializeLock = FALSE; + } + + if (Enable != 0) { + EfiAcquireLock (&mLock); + } else { + EfiReleaseLock (&mLock); + } +} + +VOID +snp_undi32_callback_delay_30 ( + IN UINT64 MicroSeconds + ) +/*++ + +Routine Description: + This is a callback routine supplied to UNDI at undi_start time. + UNDI call this routine with the number of micro seconds when it wants to + pause. + +Arguments: + MicroSeconds - number of micro seconds to pause, ususlly multiple of 10 + +Returns: + void +--*/ +{ + if (MicroSeconds != 0) { + gBS->Stall ((UINTN) MicroSeconds); + } +} + +VOID +snp_undi32_callback_memio_30 ( + IN UINT8 ReadOrWrite, + IN UINT8 NumBytes, + IN UINT64 Address, + IN OUT UINT64 BufferAddr + ) +/*++ + +Routine Description: + This is a callback routine supplied to UNDI at undi_start time. + This is the IO routine for UNDI. This is not currently being used by UNDI3.0 + because Undi3.0 uses io/mem offsets relative to the beginning of the device + io/mem address and so it needs to use the PCI_IO_FUNCTION that abstracts the + start of the device's io/mem addresses. Since SNP cannot retrive the context + of the undi3.0 interface it cannot use the PCI_IO_FUNCTION that specific for + that NIC and uses one global IO functions structure, this does not work. + This however works fine for EFI1.0 Undis because they use absolute addresses + for io/mem access. + +Arguments: + ReadOrWrite - indicates read or write, IO or Memory + NumBytes - number of bytes to read or write + Address - IO or memory address to read from or write to + BufferAddr - memory location to read into or that contains the bytes + to write + +Returns: + +--*/ +{ + EFI_PCI_IO_PROTOCOL_WIDTH Width; + + switch (NumBytes) { + case 2: + Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 1; + break; + + case 4: + Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 2; + break; + + case 8: + Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 3; + break; + + default: + Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 0; + } + + switch (ReadOrWrite) { + case PXE_IO_READ: + mPciIoFncs->Io.Read ( + mPciIoFncs, + Width, + 1, // BAR 1, IO base address + Address, + 1, // count + (VOID *) (UINTN) BufferAddr + ); + break; + + case PXE_IO_WRITE: + mPciIoFncs->Io.Write ( + mPciIoFncs, + Width, + 1, // BAR 1, IO base address + Address, + 1, // count + (VOID *) (UINTN) BufferAddr + ); + break; + + case PXE_MEM_READ: + mPciIoFncs->Mem.Read ( + mPciIoFncs, + Width, + 0, // BAR 0, Memory base address + Address, + 1, // count + (VOID *) (UINTN) BufferAddr + ); + break; + + case PXE_MEM_WRITE: + mPciIoFncs->Mem.Write ( + mPciIoFncs, + Width, + 0, // BAR 0, Memory base address + Address, + 1, // count + (VOID *) (UINTN) BufferAddr + ); + break; + } + + return ; +} +// +// New callbacks for 3.1: +// there won't be a virtual2physical callback for UNDI 3.1 because undi3.1 uses +// the MemMap call to map the required address by itself! +// +VOID +snp_undi32_callback_block ( + IN UINT64 UniqueId, + IN UINT32 Enable + ) +/*++ + +Routine Description: + This is a callback routine supplied to UNDI3.1 at undi_start time. + UNDI call this routine when it wants to have exclusive access to a critical + section of the code/data + +Arguments: + UniqueId - This was supplied to UNDI at Undi_Start, SNP uses this to store + Undi interface context (Undi does not read or write this variable) + Enable - non-zero indicates acquire + zero indicates release + +Returns: + void + +--*/ +{ + SNP_DRIVER *snp; + + snp = (SNP_DRIVER *) (UINTN) UniqueId; + // + // tcpip was calling snp at tpl_notify and when we acquire a lock that was + // created at a lower level (TPL_CALLBACK) it gives an assert! + // + if (Enable != 0) { + EfiAcquireLock (&snp->lock); + } else { + EfiReleaseLock (&snp->lock); + } +} + +VOID +snp_undi32_callback_delay ( + IN UINT64 UniqueId, + IN UINT64 MicroSeconds + ) +/*++ + +Routine Description: + This is a callback routine supplied to UNDI at undi_start time. + UNDI call this routine with the number of micro seconds when it wants to + pause. + +Arguments: + MicroSeconds - number of micro seconds to pause, ususlly multiple of 10 + +Returns: + void +--*/ +{ + if (MicroSeconds != 0) { + gBS->Stall ((UINTN) MicroSeconds); + } +} + +/* + * IO routine for UNDI start CPB. + */ +VOID +snp_undi32_callback_memio ( + UINT64 UniqueId, + UINT8 ReadOrWrite, + UINT8 NumBytes, + UINT64 Address, + UINT64 BufferAddr + ) +/*++ + +Routine Description: + This is a callback routine supplied to UNDI at undi_start time. + This is the IO routine for UNDI3.1. + +Arguments: + ReadOrWrite - indicates read or write, IO or Memory + NumBytes - number of bytes to read or write + Address - IO or memory address to read from or write to + BufferAddr - memory location to read into or that contains the bytes + to write + +Returns: + +--*/ +{ + SNP_DRIVER *snp; + EFI_PCI_IO_PROTOCOL_WIDTH Width; + + snp = (SNP_DRIVER *) (UINTN) UniqueId; + + Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 0; + switch (NumBytes) { + case 2: + Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 1; + break; + + case 4: + Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 2; + break; + + case 8: + Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 3; + break; + } + + switch (ReadOrWrite) { + case PXE_IO_READ: + snp->IoFncs->Io.Read ( + snp->IoFncs, + Width, + snp->IoBarIndex, // BAR 1 (for 32bit regs), IO base address + Address, + 1, // count + (VOID *) (UINTN) BufferAddr + ); + break; + + case PXE_IO_WRITE: + snp->IoFncs->Io.Write ( + snp->IoFncs, + Width, + snp->IoBarIndex, // BAR 1 (for 32bit regs), IO base address + Address, + 1, // count + (VOID *) (UINTN) BufferAddr + ); + break; + + case PXE_MEM_READ: + snp->IoFncs->Mem.Read ( + snp->IoFncs, + Width, + snp->MemoryBarIndex, // BAR 0, Memory base address + Address, + 1, // count + (VOID *) (UINTN) BufferAddr + ); + break; + + case PXE_MEM_WRITE: + snp->IoFncs->Mem.Write ( + snp->IoFncs, + Width, + snp->MemoryBarIndex, // BAR 0, Memory base address + Address, + 1, // count + (VOID *) (UINTN) BufferAddr + ); + break; + } + + return ; +} + +VOID +snp_undi32_callback_map ( + IN UINT64 UniqueId, + IN UINT64 CpuAddr, + IN UINT32 NumBytes, + IN UINT32 Direction, + IN OUT UINT64 DeviceAddrPtr + ) +/*++ + +Routine Description: + This is a callback routine supplied to UNDI at undi_start time. + UNDI call this routine when it has to map a CPU address to a device + address. + +Arguments: + UniqueId - This was supplied to UNDI at Undi_Start, SNP uses this to store + Undi interface context (Undi does not read or write this variable) + CpuAddr - Virtual address to be mapped! + NumBytes - size of memory to be mapped + Direction - direction of data flow for this memory's usage: + cpu->device, device->cpu or both ways + DeviceAddrPtr - pointer to return the mapped device address + +Returns: + None + +--*/ +{ + EFI_PHYSICAL_ADDRESS *DevAddrPtr; + EFI_PCI_IO_PROTOCOL_OPERATION DirectionFlag; + UINTN BuffSize; + SNP_DRIVER *snp; + UINTN Index; + EFI_STATUS Status; + + BuffSize = (UINTN) NumBytes; + snp = (SNP_DRIVER *) (UINTN) UniqueId; + DevAddrPtr = (EFI_PHYSICAL_ADDRESS *) (UINTN) DeviceAddrPtr; + + if (CpuAddr == 0) { + *DevAddrPtr = 0; + return ; + } + + switch (Direction) { + case TO_AND_FROM_DEVICE: + DirectionFlag = EfiPciIoOperationBusMasterCommonBuffer; + break; + + case FROM_DEVICE: + DirectionFlag = EfiPciIoOperationBusMasterWrite; + break; + + case TO_DEVICE: + DirectionFlag = EfiPciIoOperationBusMasterRead; + break; + + default: + *DevAddrPtr = 0; + // + // any non zero indicates error! + // + return ; + } + // + // find an unused map_list entry + // + for (Index = 0; Index < MAX_MAP_LENGTH; Index++) { + if (snp->map_list[Index].virt == 0) { + break; + } + } + + if (Index >= MAX_MAP_LENGTH) { + DEBUG ((EFI_D_INFO, "SNP maplist is FULL\n")); + *DevAddrPtr = 0; + return ; + } + + snp->map_list[Index].virt = (EFI_PHYSICAL_ADDRESS) CpuAddr; + + Status = snp->IoFncs->Map ( + snp->IoFncs, + DirectionFlag, + (VOID *) (UINTN) CpuAddr, + &BuffSize, + DevAddrPtr, + &(snp->map_list[Index].map_cookie) + ); + if (Status != EFI_SUCCESS) { + *DevAddrPtr = 0; + snp->map_list[Index].virt = 0; + } + + return ; +} + +VOID +snp_undi32_callback_unmap ( + IN UINT64 UniqueId, + IN UINT64 CpuAddr, + IN UINT32 NumBytes, + IN UINT32 Direction, + IN UINT64 DeviceAddr + ) +/*++ + +Routine Description: + This is a callback routine supplied to UNDI at undi_start time. + UNDI call this routine when it wants to unmap an address that was previously + mapped using map callback + +Arguments: + UniqueId - This was supplied to UNDI at Undi_Start, SNP uses this to store + Undi interface context (Undi does not read or write this variable) + CpuAddr - Virtual address that was mapped! + NumBytes - size of memory mapped + Direction- direction of data flow for this memory's usage: + cpu->device, device->cpu or both ways + DeviceAddr - the mapped device address + +Returns: + +--*/ +{ + SNP_DRIVER *snp; + UINT16 Index; + + snp = (SNP_DRIVER *) (UINTN) UniqueId; + + for (Index = 0; Index < MAX_MAP_LENGTH; Index++) { + if (snp->map_list[Index].virt == CpuAddr) { + break; + } + } + + if (Index >= MAX_MAP_LENGTH) + { + DEBUG ((EFI_D_ERROR, "SNP could not find a mapping, failed to unmap.\n")); + return ; + } + + snp->IoFncs->Unmap (snp->IoFncs, snp->map_list[Index].map_cookie); + snp->map_list[Index].virt = 0; + snp->map_list[Index].map_cookie = NULL; + return ; +} + +VOID +snp_undi32_callback_sync ( + UINT64 UniqueId, + UINT64 CpuAddr, + UINT32 NumBytes, + UINT32 Direction, + UINT64 DeviceAddr + ) +/*++ + +Routine Description: + This is a callback routine supplied to UNDI at undi_start time. + UNDI call this routine when it wants synchronize the virtual buffer contents + with the mapped buffer contents. The virtual and mapped buffers need not + correspond to the same physical memory (especially if the virtual address is + > 4GB). Depending on the direction for which the buffer is mapped, undi will + need to synchronize their contents whenever it writes to/reads from the buffer + using either the cpu address or the device address. + + EFI does not provide a sync call, since virt=physical, we sould just do + the synchronization ourself here! + +Arguments: + UniqueId - This was supplied to UNDI at Undi_Start, SNP uses this to store + Undi interface context (Undi does not read or write this variable) + CpuAddr - Virtual address that was mapped! + NumBytes - size of memory mapped + Direction- direction of data flow for this memory's usage: + cpu->device, device->cpu or both ways + DeviceAddr - the mapped device address + +Returns: + +--*/ +{ + if ((CpuAddr == 0) || (DeviceAddr == 0) || (NumBytes == 0)) { + return ; + + } + + switch (Direction) { + case FROM_DEVICE: + CopyMem ((UINT8 *) (UINTN) CpuAddr, (UINT8 *) (UINTN) DeviceAddr, NumBytes); + break; + + case TO_DEVICE: + CopyMem ((UINT8 *) (UINTN) DeviceAddr, (UINT8 *) (UINTN) CpuAddr, NumBytes); + break; + } + + return ; +}