init.c File Reference

#include "nvnet.h"
#include "debug.h"

Include dependency graph for init.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
static VOID	QueryInteger (_In_ NDIS_HANDLE ConfigurationHandle, _In_ PCWSTR EntryName, _Out_ PULONG EntryContext, _In_ ULONG DefaultValue, _In_ ULONG Minimum, _In_ ULONG Maximum)
static NDIS_STATUS	NvNetReadConfiguration (_Inout_ PNVNET_ADAPTER Adapter)
static NDIS_STATUS	NvNetInitializeAdapterResources (_Inout_ PNVNET_ADAPTER Adapter)
static NDIS_STATUS	AllocateTransmitBuffers (_In_ PNVNET_ADAPTER Adapter)
static NDIS_STATUS	AllocateTransmitBlocks (_In_ PNVNET_ADAPTER Adapter)
static NDIS_STATUS	AllocateTransmitDescriptors (_In_ PNVNET_ADAPTER Adapter)
static NDIS_STATUS	AllocateReceiveDescriptors (_In_ PNVNET_ADAPTER Adapter)
static NDIS_STATUS	AllocateReceiveBuffers (_In_ PNVNET_ADAPTER Adapter)
static NDIS_STATUS	AllocateAdapterMemory (_In_ PNVNET_ADAPTER Adapter)
VOID	NvNetInitTransmitMemory (_In_ PNVNET_ADAPTER Adapter)
static VOID	NvNetInitReceiveMemory (_In_ PNVNET_ADAPTER Adapter)
VOID	NvNetFreeAdapter (_In_ PNVNET_ADAPTER Adapter)
NDIS_STATUS NTAPI	MiniportInitialize (_Out_ PNDIS_STATUS OpenErrorStatus, _Out_ PUINT SelectedMediumIndex, _In_ PNDIS_MEDIUM MediumArray, _In_ UINT MediumArraySize, _In_ NDIS_HANDLE MiniportAdapterHandle, _In_ NDIS_HANDLE WrapperConfigurationContext)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file init.c.

Function Documentation

AllocateAdapterMemory()

static NDIS_STATUS AllocateAdapterMemory ( _In_ PNVNET_ADAPTER  Adapter )

static

Definition at line 504 of file init.c.

{
    NDIS_STATUS Status;
 
    PAGED_CODE();
 
    Status = AllocateTransmitBuffers(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
        return Status;
 
    Status = AllocateTransmitBlocks(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
        return Status;
 
    Status = AllocateTransmitDescriptors(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
        return Status;
 
    Status = AllocateReceiveDescriptors(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
        return Status;
 
    Status = AllocateReceiveBuffers(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
        return Status;
 
    NdisAllocateSpinLock(&Adapter->Send.Lock);
    NdisAllocateSpinLock(&Adapter->Receive.Lock);
    NdisAllocateSpinLock(&Adapter->Lock);
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportInitialize().

AllocateReceiveBuffers()

static NDIS_STATUS AllocateReceiveBuffers ( _In_ PNVNET_ADAPTER  Adapter )

static

Definition at line 483 of file init.c.

{
    PAGED_CODE();
 
    NdisMAllocateSharedMemory(Adapter->AdapterHandle,
                              NVNET_RECEIVE_BUFFER_SIZE * NVNET_RECEIVE_DESCRIPTORS,
                              TRUE, /* Cached */
                              (PVOID*)&Adapter->ReceiveBuffer,
                              &Adapter->ReceiveBufferPhys);
    if (!Adapter->ReceiveBuffer)
    {
        return NDIS_STATUS_RESOURCES;
    }
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by AllocateAdapterMemory().

AllocateReceiveDescriptors()

static NDIS_STATUS AllocateReceiveDescriptors ( _In_ PNVNET_ADAPTER  Adapter )

static

Definition at line 451 of file init.c.

{
    ULONG Size;
 
    PAGED_CODE();
 
    if (Adapter->Features & DEV_HAS_HIGH_DMA)
    {
        Size = sizeof(NVNET_DESCRIPTOR_64);
    }
    else
    {
        Size = sizeof(NVNET_DESCRIPTOR_32);
    }
    NdisMAllocateSharedMemory(Adapter->AdapterHandle,
                              Size * NVNET_RECEIVE_DESCRIPTORS + NVNET_ALIGNMENT,
                              TRUE, /* Cached */
                              &Adapter->RbdOriginal,
                              &Adapter->RbdPhysOriginal);
    if (!Adapter->RbdOriginal)
        return NDIS_STATUS_RESOURCES;
 
    Adapter->Receive.NvRbd.Memory = ALIGN_UP_POINTER_BY(Adapter->RbdOriginal, NVNET_ALIGNMENT);
    Adapter->RbdPhys.QuadPart = ALIGN_UP_BY(Adapter->RbdPhysOriginal.QuadPart, NVNET_ALIGNMENT);
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by AllocateAdapterMemory().

AllocateTransmitBlocks()

static NDIS_STATUS AllocateTransmitBlocks ( _In_ PNVNET_ADAPTER  Adapter )

static

Definition at line 379 of file init.c.

{
    PNVNET_TCB Tcb;
    NDIS_STATUS Status;
 
    PAGED_CODE();
 
    Status = NdisAllocateMemoryWithTag((PVOID*)&Tcb,
                                       NVNET_TRANSMIT_BLOCKS * sizeof(NVNET_TCB),
                                       NVNET_TAG);
    if (Status != NDIS_STATUS_SUCCESS)
        return Status;
 
    NdisZeroMemory(Tcb, NVNET_TRANSMIT_BLOCKS * sizeof(NVNET_TCB));
 
    Adapter->Send.TailTcb = Tcb + (NVNET_TRANSMIT_BLOCKS - 1);
    Adapter->Send.HeadTcb = Tcb;
    Adapter->Send.CurrentTcb = Tcb;
    Adapter->Send.LastTcb = Tcb;
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by AllocateAdapterMemory().

AllocateTransmitBuffers()

static NDIS_STATUS AllocateTransmitBuffers ( _In_ PNVNET_ADAPTER  Adapter )

static

Definition at line 323 of file init.c.

{
    ULONG i;
    BOOLEAN HasBuffer = FALSE;
    PNVNET_TX_BUFFER CoalesceBuffer;
    NDIS_STATUS Status;
 
    PAGED_CODE();
 
    Status = NdisAllocateMemoryWithTag((PVOID*)&CoalesceBuffer,
                                       NVNET_TRANSMIT_BUFFERS * sizeof(NVNET_TX_BUFFER),
                                       NVNET_TAG);
    if (Status != NDIS_STATUS_SUCCESS)
        return Status;
 
    NdisZeroMemory(CoalesceBuffer, NVNET_TRANSMIT_BUFFERS * sizeof(NVNET_TX_BUFFER));
 
    Adapter->SendBuffer = CoalesceBuffer;
 
    for (i = 0; i < NVNET_TRANSMIT_BUFFERS; ++i)
    {
        PVOID VirtualAddress;
        NDIS_PHYSICAL_ADDRESS PhysicalAddress;
 
        NdisMAllocateSharedMemory(Adapter->AdapterHandle,
                                  Adapter->MaximumFrameSize + NVNET_ALIGNMENT,
                                  TRUE, /* Cached */
                                  &VirtualAddress,
                                  &PhysicalAddress);
        if (!VirtualAddress)
            continue;
 
        CoalesceBuffer->VirtualAddress = ALIGN_UP_POINTER_BY(VirtualAddress, NVNET_ALIGNMENT);
        CoalesceBuffer->PhysicalAddress.QuadPart =
            ALIGN_UP_BY(PhysicalAddress.QuadPart, NVNET_ALIGNMENT);
 
        Adapter->SendBufferAllocationData[i].PhysicalAddress.QuadPart = PhysicalAddress.QuadPart;
        Adapter->SendBufferAllocationData[i].VirtualAddress = VirtualAddress;
 
        PushEntryList(&Adapter->Send.BufferList, &CoalesceBuffer->Link);
        ++CoalesceBuffer;
 
        HasBuffer = TRUE;
    }
    if (!HasBuffer)
    {
        return NDIS_STATUS_RESOURCES;
    }
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by AllocateAdapterMemory().

AllocateTransmitDescriptors()

static NDIS_STATUS AllocateTransmitDescriptors ( _In_ PNVNET_ADAPTER  Adapter )

static

Definition at line 406 of file init.c.

{
    NVNET_TBD Tbd;
    ULONG Size;
 
    PAGED_CODE();
 
    if (Adapter->Features & DEV_HAS_HIGH_DMA)
    {
        Size = sizeof(NVNET_DESCRIPTOR_64);
    }
    else
    {
        Size = sizeof(NVNET_DESCRIPTOR_32);
    }
    NdisMAllocateSharedMemory(Adapter->AdapterHandle,
                              Size * NVNET_TRANSMIT_DESCRIPTORS + NVNET_ALIGNMENT,
                              TRUE, /* Cached */
                              &Adapter->TbdOriginal,
                              &Adapter->TbdPhysOriginal);
    if (!Adapter->TbdOriginal)
        return NDIS_STATUS_RESOURCES;
 
    Tbd.Memory = ALIGN_UP_POINTER_BY(Adapter->TbdOriginal, NVNET_ALIGNMENT);
    Adapter->TbdPhys.QuadPart = ALIGN_UP_BY(Adapter->TbdPhysOriginal.QuadPart, NVNET_ALIGNMENT);
 
    Adapter->Send.HeadTbd = Tbd;
    Adapter->Send.CurrentTbd = Tbd;
 
    if (Adapter->Features & DEV_HAS_HIGH_DMA)
    {
        Adapter->Send.TailTbd.x64 = Tbd.x64 + (NVNET_TRANSMIT_DESCRIPTORS - 1);
    }
    else
    {
        Adapter->Send.TailTbd.x32 = Tbd.x32 + (NVNET_TRANSMIT_DESCRIPTORS - 1);
    }
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by AllocateAdapterMemory().

MiniportInitialize()

NDIS_STATUS NTAPI MiniportInitialize	(	_Out_ PNDIS_STATUS	OpenErrorStatus,
		_Out_ PUINT	SelectedMediumIndex,
		_In_ PNDIS_MEDIUM	MediumArray,
		_In_ UINT	MediumArraySize,
		_In_ NDIS_HANDLE	MiniportAdapterHandle,
		_In_ NDIS_HANDLE	WrapperConfigurationContext
	)

Definition at line 708 of file init.c.

{
    UINT i;
    ULONG Size;
    PVOID UnalignedAdapter;
    PNVNET_ADAPTER Adapter;
    NDIS_STATUS Status;
 
    PAGED_CODE();
 
    NDIS_DbgPrint(MIN_TRACE, ("()\n"));
 
    for (i = 0; i < MediumArraySize; ++i)
    {
        if (MediumArray[i] == NdisMedium802_3)
        {
            *SelectedMediumIndex = i;
            break;
        }
    }
    if (i == MediumArraySize)
    {
        NDIS_DbgPrint(MAX_TRACE, ("No supported media\n"));
        return NDIS_STATUS_UNSUPPORTED_MEDIA;
    }
 
    Size = sizeof(NVNET_ADAPTER) + NdisGetSharedDataAlignment();
 
    Status = NdisAllocateMemoryWithTag((PVOID*)&UnalignedAdapter,
                                       Size,
                                       NVNET_TAG);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NDIS_DbgPrint(MAX_TRACE, ("Failed to allocate adapter\n"));
        return NDIS_STATUS_RESOURCES;
    }
 
    NdisZeroMemory(UnalignedAdapter, Size);
    Adapter = ALIGN_UP_POINTER_BY(UnalignedAdapter, NdisGetSharedDataAlignment());
    Adapter->AdapterOriginal = UnalignedAdapter;
    Adapter->AdapterHandle = MiniportAdapterHandle;
    Adapter->WrapperConfigurationHandle = WrapperConfigurationContext;
 
    Status = NvNetReadConfiguration(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        goto Failure;
    }
 
    NdisMSetAttributesEx(MiniportAdapterHandle,
                         Adapter,
                         0,
                         NDIS_ATTRIBUTE_USES_SAFE_BUFFER_APIS |
                         // NDIS_ATTRIBUTE_DESERIALIZE |  TODO
                         NDIS_ATTRIBUTE_BUS_MASTER,
                         NdisInterfacePci);
 
    Status = NvNetRecognizeHardware(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        if (Status == NDIS_STATUS_ADAPTER_NOT_FOUND)
        {
            NvNetLogError(Adapter, NDIS_ERROR_CODE_ADAPTER_NOT_FOUND);
        }
        else if (Status == NDIS_STATUS_NOT_RECOGNIZED)
        {
            NvNetLogError(Adapter, NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION);
        }
 
        goto Failure;
    }
 
    Status = NvNetInitializeAdapterResources(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        goto Failure;
    }
 
    Status = NdisMInitializeScatterGatherDma(Adapter->AdapterHandle,
                                             !!(Adapter->Features & DEV_HAS_HIGH_DMA),
                                             NVNET_MAXIMUM_FRAME_SIZE);
                                             // ^TODO: NVNET_MAX_DMA_TRANSFER);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NvNetLogError(Adapter, NDIS_ERROR_CODE_OUT_OF_RESOURCES);
        goto Failure;
    }
 
    Status = AllocateAdapterMemory(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NDIS_DbgPrint(MAX_TRACE, ("Failed to allocate adapter memory\n"));
 
        NvNetLogError(Adapter, NDIS_ERROR_CODE_OUT_OF_RESOURCES);
        goto Failure;
    }
 
    NvNetInitTransmitMemory(Adapter);
    NvNetInitReceiveMemory(Adapter);
 
    if (Adapter->Features & DEV_HAS_HIGH_DMA)
    {
        Adapter->TransmitPacket = NvNetTransmitPacket64;
        Adapter->ProcessTransmit = ProcessTransmitDescriptors64;
    }
    else
    {
        Adapter->TransmitPacket = NvNetTransmitPacket32;
 
        if (Adapter->Features & DEV_HAS_LARGEDESC)
        {
            Adapter->ProcessTransmit = ProcessTransmitDescriptors32;
        }
        else
        {
            Adapter->ProcessTransmit = ProcessTransmitDescriptorsLegacy;
        }
    }
 
    Status = NvNetGetPermanentMacAddress(Adapter, Adapter->PermanentMacAddress);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NvNetLogError(Adapter, NDIS_ERROR_CODE_NETWORK_ADDRESS);
        goto Failure;
    }
 
    if (!(Adapter->Flags & NV_USE_SOFT_MAC_ADDRESS))
    {
        ETH_COPY_NETWORK_ADDRESS(Adapter->CurrentMacAddress,
                                 Adapter->PermanentMacAddress);
    }
 
    NvNetSetupMacAddress(Adapter, Adapter->CurrentMacAddress);
 
    Status = NvNetInitNIC(Adapter, TRUE);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NDIS_DbgPrint(MAX_TRACE, ("Failed to initialize the NIC\n"));
 
        NvNetLogError(Adapter, NDIS_ERROR_CODE_HARDWARE_FAILURE);
        goto Failure;
    }
 
    NvNetDisableInterrupts(Adapter);
    NV_WRITE(Adapter, NvRegMIIStatus, NVREG_MIISTAT_MASK_ALL);
    NV_WRITE(Adapter, NvRegIrqStatus, NVREG_IRQSTAT_MASK);
 
/* FIXME: Bug in the PIC HAL? */
#if defined(SARCH_XBOX)
    Status = NdisMRegisterInterrupt(&Adapter->Interrupt,
                                    Adapter->AdapterHandle,
                                    Adapter->InterruptVector,
                                    Adapter->InterruptLevel,
                                    TRUE, /* Request ISR calls */
                                    FALSE,
                                    NdisInterruptLatched);
#else
    Status = NdisMRegisterInterrupt(&Adapter->Interrupt,
                                    Adapter->AdapterHandle,
                                    Adapter->InterruptVector,
                                    Adapter->InterruptLevel,
                                    TRUE, /* Request ISR calls */
                                    TRUE, /* Shared */
                                    NdisInterruptLevelSensitive);
#endif
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NvNetLogError(Adapter, NDIS_ERROR_CODE_INTERRUPT_CONNECT);
        goto Failure;
    }
 
    NvNetStartAdapter(Adapter);
 
    return NDIS_STATUS_SUCCESS;
 
Failure:
    NvNetFreeAdapter(Adapter);
 
    return Status;
}

NvNetFreeAdapter()

VOID NvNetFreeAdapter

(

_In_ PNVNET_ADAPTER

Adapter

)

Definition at line 603 of file init.c.

{
    ULONG i;
    ULONG DescriptorSize;
 
    PAGED_CODE();
 
    NDIS_DbgPrint(MIN_TRACE, ("()\n"));
 
    for (i = 0; i < RTL_NUMBER_OF(Adapter->WakeFrames); ++i)
    {
        PNVNET_WAKE_FRAME WakeFrame = Adapter->WakeFrames[i];
 
        if (!WakeFrame)
            continue;
 
        NdisFreeMemory(WakeFrame, sizeof(*WakeFrame), 0);
    }
 
    if (Adapter->Interrupt.InterruptObject)
    {
        NdisMDeregisterInterrupt(&Adapter->Interrupt);
        Adapter->Interrupt.InterruptObject = NULL;
    }
 
    if (Adapter->Features & DEV_HAS_HIGH_DMA)
    {
        DescriptorSize = sizeof(NVNET_DESCRIPTOR_64);
    }
    else
    {
        DescriptorSize = sizeof(NVNET_DESCRIPTOR_32);
    }
    if (Adapter->TbdOriginal)
    {
        NdisMFreeSharedMemory(Adapter->AdapterHandle,
                              DescriptorSize * NVNET_TRANSMIT_DESCRIPTORS,
                              FALSE,
                              Adapter->TbdOriginal,
                              Adapter->TbdPhysOriginal);
        Adapter->TbdOriginal = NULL;
    }
    if (Adapter->RbdOriginal)
    {
        NdisMFreeSharedMemory(Adapter->AdapterHandle,
                              DescriptorSize * NVNET_RECEIVE_DESCRIPTORS,
                              FALSE,
                              Adapter->RbdOriginal,
                              Adapter->RbdPhysOriginal);
        Adapter->RbdOriginal = NULL;
    }
    if (Adapter->SendBuffer)
    {
        ULONG Length = ALIGN_UP_BY(Adapter->MaximumFrameSize, NVNET_ALIGNMENT);
 
        for (i = 0; i < NVNET_TRANSMIT_BUFFERS; ++i)
        {
            PNVNET_TX_BUFFER_DATA SendBufferData = &Adapter->SendBufferAllocationData[i];
 
            if (!SendBufferData->VirtualAddress)
                continue;
 
            NdisMFreeSharedMemory(Adapter->AdapterHandle,
                                  Length,
                                  TRUE,
                                  SendBufferData->VirtualAddress,
                                  SendBufferData->PhysicalAddress);
        }
 
        NdisFreeMemory(Adapter->SendBuffer, NVNET_TRANSMIT_BUFFERS * sizeof(NVNET_TX_BUFFER), 0);
        Adapter->SendBuffer = NULL;
    }
 
    if (Adapter->ReceiveBuffer)
    {
        NdisMFreeSharedMemory(Adapter->AdapterHandle,
                              NVNET_RECEIVE_BUFFER_SIZE * NVNET_RECEIVE_DESCRIPTORS,
                              FALSE,
                              Adapter->ReceiveBuffer,
                              Adapter->ReceiveBufferPhys);
        Adapter->ReceiveBuffer = NULL;
    }
 
    if (Adapter->IoBase)
    {
        NdisMUnmapIoSpace(Adapter->AdapterHandle,
                          Adapter->IoBase,
                          Adapter->IoLength);
        Adapter->IoBase = NULL;
    }
 
    if (Adapter->Lock.SpinLock)
        NdisFreeSpinLock(&Adapter->Lock);
    if (Adapter->Send.Lock.SpinLock)
        NdisFreeSpinLock(&Adapter->Send.Lock);
    if (Adapter->Receive.Lock.SpinLock)
        NdisFreeSpinLock(&Adapter->Receive.Lock);
 
    NdisFreeMemory(Adapter->AdapterOriginal, sizeof(NVNET_ADAPTER), 0);
}

Referenced by MiniportHalt(), and MiniportInitialize().

NvNetInitializeAdapterResources()

static NDIS_STATUS NvNetInitializeAdapterResources ( _Inout_ PNVNET_ADAPTER  Adapter )

static

Definition at line 223 of file init.c.

{
    NDIS_STATUS Status;
    PNDIS_RESOURCE_LIST AssignedResources = NULL;
    UINT i, ResourceListSize = 0;
 
    PAGED_CODE();
 
    NDIS_DbgPrint(MIN_TRACE, ("()\n"));
 
    NdisMQueryAdapterResources(&Status,
                               Adapter->WrapperConfigurationHandle,
                               AssignedResources,
                               &ResourceListSize);
    if (Status != NDIS_STATUS_RESOURCES)
    {
        NvNetLogError(Adapter, NDIS_ERROR_CODE_RESOURCE_CONFLICT);
        return NDIS_STATUS_FAILURE;
    }
 
    Status = NdisAllocateMemoryWithTag((PVOID*)&AssignedResources,
                                       ResourceListSize,
                                       NVNET_TAG);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NvNetLogError(Adapter, NDIS_ERROR_CODE_OUT_OF_RESOURCES);
        return Status;
    }
 
    NdisMQueryAdapterResources(&Status,
                               Adapter->WrapperConfigurationHandle,
                               AssignedResources,
                               &ResourceListSize);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NvNetLogError(Adapter, NDIS_ERROR_CODE_RESOURCE_CONFLICT);
        goto Cleanup;
    }
 
    for (i = 0; i < AssignedResources->Count; ++i)
    {
        PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor = &AssignedResources->PartialDescriptors[i];
 
        switch (Descriptor->Type)
        {
            case CmResourceTypeMemory:
            {
                Adapter->IoAddress = Descriptor->u.Memory.Start;
                Adapter->IoLength = Descriptor->u.Memory.Length;
                break;
            }
 
            case CmResourceTypeInterrupt:
            {
                Adapter->InterruptVector = Descriptor->u.Interrupt.Vector;
                Adapter->InterruptLevel = Descriptor->u.Interrupt.Level;
                Adapter->InterruptShared = (Descriptor->ShareDisposition == CmResourceShareShared);
                Adapter->InterruptFlags = Descriptor->Flags;
                break;
            }
 
            default:
                break;
        }
    }
 
    if (!Adapter->IoAddress.QuadPart || !Adapter->InterruptVector)
    {
        Status = NDIS_STATUS_RESOURCES;
        NvNetLogError(Adapter, NDIS_ERROR_CODE_RESOURCE_CONFLICT);
        goto Cleanup;
    }
 
    NDIS_DbgPrint(MIN_TRACE, ("MEM at [%I64X-%I64X]\n",
                              Adapter->IoAddress.QuadPart,
                              Adapter->IoAddress.QuadPart + Adapter->IoLength));
    NDIS_DbgPrint(MIN_TRACE, ("IRQ Vector %d Level %d\n",
                              Adapter->InterruptVector,
                              Adapter->InterruptLevel));
 
    Status = NdisMMapIoSpace((PVOID*)&Adapter->IoBase,
                             Adapter->AdapterHandle,
                             Adapter->IoAddress,
                             Adapter->IoLength);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NvNetLogError(Adapter, NDIS_ERROR_CODE_RESOURCE_CONFLICT);
        goto Cleanup;
    }
 
Cleanup:
    NdisFreeMemory(AssignedResources, ResourceListSize, 0);
 
    return Status;
}

Referenced by MiniportInitialize().

NvNetInitReceiveMemory()

static VOID NvNetInitReceiveMemory ( _In_ PNVNET_ADAPTER  Adapter )

static

Definition at line 563 of file init.c.

{
    NV_RBD NvRbd;
    ULONG i;
 
    PAGED_CODE();
 
    Adapter->CurrentRx = 0;
 
    if (Adapter->Features & DEV_HAS_HIGH_DMA)
    {
        for (i = 0; i < NVNET_RECEIVE_DESCRIPTORS; ++i)
        {
            NvRbd.x64 = &Adapter->Receive.NvRbd.x64[i];
 
            NvRbd.x64->AddressHigh = NdisGetPhysicalAddressHigh(Adapter->ReceiveBufferPhys)
                                     + i * NVNET_RECEIVE_BUFFER_SIZE;
            NvRbd.x64->AddressLow = NdisGetPhysicalAddressLow(Adapter->ReceiveBufferPhys)
                                    + i * NVNET_RECEIVE_BUFFER_SIZE;
            NvRbd.x64->VlanTag = 0;
            NvRbd.x64->FlagsLength = NV_RX2_AVAIL | NVNET_RECEIVE_BUFFER_SIZE;
        }
    }
    else
    {
        for (i = 0; i < NVNET_RECEIVE_DESCRIPTORS; ++i)
        {
            NvRbd.x32 = &Adapter->Receive.NvRbd.x32[i];
 
            NvRbd.x32->Address = NdisGetPhysicalAddressLow(Adapter->ReceiveBufferPhys)
                                 + i * NVNET_RECEIVE_BUFFER_SIZE;
            NvRbd.x32->FlagsLength = NV_RX_AVAIL | NVNET_RECEIVE_BUFFER_SIZE;
        }
    }
}

Referenced by MiniportInitialize().

NvNetInitTransmitMemory()

VOID NvNetInitTransmitMemory

(

_In_ PNVNET_ADAPTER

Adapter

)

Definition at line 540 of file init.c.

{
    PAGED_CODE();
 
    Adapter->Send.TcbSlots = NVNET_TRANSMIT_BLOCKS;
    Adapter->Send.TbdSlots = NVNET_TRANSMIT_DESCRIPTORS;
 
    if (Adapter->Features & DEV_HAS_HIGH_DMA)
    {
        NdisZeroMemory(Adapter->Send.HeadTbd.x64,
                       sizeof(NVNET_DESCRIPTOR_64) * NVNET_TRANSMIT_DESCRIPTORS);
    }
    else
    {
        NdisZeroMemory(Adapter->Send.HeadTbd.x32,
                       sizeof(NVNET_DESCRIPTOR_32) * NVNET_TRANSMIT_DESCRIPTORS);
    }
}

Referenced by MiniportInitialize().

NvNetReadConfiguration()

static NDIS_STATUS NvNetReadConfiguration ( _Inout_ PNVNET_ADAPTER  Adapter )

static

Definition at line 67 of file init.c.

{
    NDIS_STATUS Status;
    NDIS_HANDLE ConfigurationHandle;
    PUCHAR NetworkAddress;
    UINT Length;
    ULONG GenericUlong;
 
    PAGED_CODE();
 
    NDIS_DbgPrint(MIN_TRACE, ("()\n"));
 
    NdisOpenConfiguration(&Status,
                          &ConfigurationHandle,
                          Adapter->WrapperConfigurationHandle);
    if (Status != NDIS_STATUS_SUCCESS)
        return Status;
 
    QueryInteger(ConfigurationHandle,
                 L"OptimizationMode",
                 &GenericUlong,
                 NV_OPTIMIZATION_MODE_DYNAMIC,
                 NV_OPTIMIZATION_MODE_THROUGHPUT,
                 NV_OPTIMIZATION_MODE_DYNAMIC);
    Adapter->OptimizationMode = GenericUlong;
 
    QueryInteger(ConfigurationHandle,
                 L"*FlowControl",
                 &GenericUlong,
                 NV_FLOW_CONTROL_AUTO,
                 NV_FLOW_CONTROL_DISABLE,
                 NV_FLOW_CONTROL_RX_TX);
    Adapter->FlowControlMode = GenericUlong;
 
    QueryInteger(ConfigurationHandle,
                 L"*SpeedDuplex",
                 &GenericUlong,
                 0,
                 0,
                 4);
    switch (GenericUlong)
    {
        case 1:
            Adapter->Flags |= NV_FORCE_SPEED_AND_DUPLEX;
            break;
        case 2:
            Adapter->Flags |= (NV_FORCE_SPEED_AND_DUPLEX | NV_FORCE_FULL_DUPLEX);
            break;
        case 3:
            Adapter->Flags |= (NV_FORCE_SPEED_AND_DUPLEX | NV_USER_SPEED_100);
            break;
        case 4:
            Adapter->Flags |= (NV_FORCE_SPEED_AND_DUPLEX | NV_FORCE_FULL_DUPLEX |
                               NV_USER_SPEED_100);
            break;
 
        default:
            break;
    }
 
    QueryInteger(ConfigurationHandle,
                 L"ChecksumOffload",
                 &GenericUlong,
                 0,
                 0,
                 1);
    if (GenericUlong)
        Adapter->Flags |= NV_SEND_CHECKSUM;
 
    QueryInteger(ConfigurationHandle,
                 L"*LsoV1IPv4",
                 &GenericUlong,
                 0,
                 0,
                 1);
    if (GenericUlong)
        Adapter->Flags |= NV_SEND_LARGE_SEND;
 
    QueryInteger(ConfigurationHandle,
                 L"*JumboPacket",
                 &GenericUlong,
                 NVNET_MAXIMUM_FRAME_SIZE,
                 NVNET_MAXIMUM_FRAME_SIZE,
                 NVNET_MAXIMUM_FRAME_SIZE_JUMBO);
    Adapter->MaximumFrameSize = GenericUlong;
 
    QueryInteger(ConfigurationHandle,
                 L"*PriorityVLANTag",
                 &GenericUlong,
                 3,
                 0,
                 3);
    switch (GenericUlong)
    {
        case 0:
            break;
        case 1:
            Adapter->Flags |= NV_PACKET_PRIORITY;
            break;
        case 2:
            Adapter->Flags |= NV_VLAN_TAGGING;
            break;
        case 3:
            Adapter->Flags |= NV_PACKET_PRIORITY | NV_VLAN_TAGGING;
            break;
 
        default:
            ASSERT(FALSE);
            UNREACHABLE;
    }
 
    QueryInteger(ConfigurationHandle,
                 L"VlanID",
                 &GenericUlong,
                 0,
                 0,
                 NVNET_MAXIMUM_VLAN_ID);
    Adapter->VlanId = GenericUlong;
 
    NdisReadNetworkAddress(&Status,
                           (PVOID*)&NetworkAddress,
                           &Length,
                           ConfigurationHandle);
    if ((Status == NDIS_STATUS_SUCCESS) && (Length == ETH_LENGTH_OF_ADDRESS))
    {
        if ((ETH_IS_MULTICAST(NetworkAddress) || ETH_IS_BROADCAST(NetworkAddress)) ||
            !ETH_IS_LOCALLY_ADMINISTERED(NetworkAddress))
        {
            NDIS_DbgPrint(MAX_TRACE, ("Invalid software MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
                                      NetworkAddress[0],
                                      NetworkAddress[1],
                                      NetworkAddress[2],
                                      NetworkAddress[3],
                                      NetworkAddress[4],
                                      NetworkAddress[5]));
        }
        else
        {
            NDIS_DbgPrint(MIN_TRACE, ("Using software MAC\n"));
 
            ETH_COPY_NETWORK_ADDRESS(Adapter->CurrentMacAddress, NetworkAddress);
 
            Adapter->Flags |= NV_USE_SOFT_MAC_ADDRESS;
        }
    }
    Status = NDIS_STATUS_SUCCESS;
 
    NdisCloseConfiguration(ConfigurationHandle);
 
    return Status;
}

Referenced by MiniportInitialize().

QueryInteger()

static VOID QueryInteger ( _In_ NDIS_HANDLE  ConfigurationHandle, _In_ PCWSTR  EntryName, _Out_ PULONG  EntryContext, _In_ ULONG  DefaultValue, _In_ ULONG  Minimum, _In_ ULONG  Maximum  )

static

Definition at line 20 of file init.c.

{
    NDIS_STATUS Status;
    UNICODE_STRING Keyword;
    PNDIS_CONFIGURATION_PARAMETER ConfigurationParameter;
 
    PAGED_CODE();
 
    NdisInitUnicodeString(&Keyword, EntryName);
    NdisReadConfiguration(&Status,
                          &ConfigurationParameter,
                          ConfigurationHandle,
                          &Keyword,
                          NdisParameterInteger);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NDIS_DbgPrint(MIN_TRACE, ("'%S' request failed\n", EntryName));
 
        *EntryContext = DefaultValue;
    }
    else
    {
        if (ConfigurationParameter->ParameterData.IntegerData >= Minimum &&
            ConfigurationParameter->ParameterData.IntegerData <= Maximum)
        {
            *EntryContext = ConfigurationParameter->ParameterData.IntegerData;
        }
        else
        {
            NDIS_DbgPrint(MAX_TRACE, ("'%S' value out of range\n", EntryName));
 
            *EntryContext = DefaultValue;
        }
    }
 
    NDIS_DbgPrint(MIN_TRACE, ("Set '%S' to %d\n", EntryName, *EntryContext));
}

Referenced by NvNetReadConfiguration().