init.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS nVidia nForce Ethernet Controller Driver
 * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:     Miniport initialization helper routines
 * COPYRIGHT:   Copyright 2021-2022 Dmitry Borisov <di.sean@protonmail.com>
 */
 
/* INCLUDES *******************************************************************/
 
#include "nvnet.h"
 
#define NDEBUG
#include "debug.h"
 
/* FUNCTIONS ******************************************************************/
 
static
CODE_SEG("PAGE")
VOID
QueryInteger(
    _In_ NDIS_HANDLE ConfigurationHandle,
    _In_ PCWSTR EntryName,
    _Out_ PULONG EntryContext,
    _In_ ULONG DefaultValue,
    _In_ ULONG Minimum,
    _In_ ULONG Maximum)
{
    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));
}
 
static
CODE_SEG("PAGE")
NDIS_STATUS
NvNetReadConfiguration(
    _Inout_ PNVNET_ADAPTER Adapter)
{
    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"LargeSendOffload",
                 &GenericUlong,
                 0,
                 0,
                 1);
    if (GenericUlong)
        Adapter->Flags |= NV_SEND_LARGE_SEND;
 
    QueryInteger(ConfigurationHandle,
                 L"JumboSize",
                 &GenericUlong,
                 NVNET_MAXIMUM_FRAME_SIZE,
                 NVNET_MAXIMUM_FRAME_SIZE,
                 NVNET_MAXIMUM_FRAME_SIZE_JUMBO);
    Adapter->MaximumFrameSize = GenericUlong;
 
    QueryInteger(ConfigurationHandle,
                 L"Priority",
                 &GenericUlong,
                 0,
                 0,
                 1);
    if (GenericUlong)
        Adapter->Flags |= NV_PACKET_PRIORITY;
 
    QueryInteger(ConfigurationHandle,
                 L"VlanTag",
                 &GenericUlong,
                 0,
                 0,
                 1);
    if (GenericUlong)
        Adapter->Flags |= NV_VLAN_TAGGING;
 
    QueryInteger(ConfigurationHandle,
                 L"VlanID",
                 &GenericUlong,
                 0,
                 0,
                 NVNET_MAXIMUM_VLAN_ID);
 
    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;
}
 
static
CODE_SEG("PAGE")
NDIS_STATUS
NvNetInitializeAdapterResources(
    _Inout_ PNVNET_ADAPTER Adapter)
{
    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;
}
 
static
CODE_SEG("PAGE")
NDIS_STATUS
AllocateTransmitBuffers(
    _In_ PNVNET_ADAPTER Adapter)
{
    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;
}
 
static
CODE_SEG("PAGE")
NDIS_STATUS
AllocateTransmitBlocks(
    _In_ PNVNET_ADAPTER Adapter)
{
    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;
}
 
static
CODE_SEG("PAGE")
NDIS_STATUS
AllocateTransmitDescriptors(
    _In_ PNVNET_ADAPTER Adapter)
{
    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;
}
 
static
CODE_SEG("PAGE")
NDIS_STATUS
AllocateReceiveDescriptors(
    _In_ PNVNET_ADAPTER Adapter)
{
    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;
}
 
static
CODE_SEG("PAGE")
NDIS_STATUS
AllocateReceiveBuffers(
    _In_ PNVNET_ADAPTER Adapter)
{
    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;
}
 
static
CODE_SEG("PAGE")
NDIS_STATUS
AllocateAdapterMemory(
    _In_ PNVNET_ADAPTER Adapter)
{
    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;
}
 
CODE_SEG("PAGE")
VOID
NvNetInitTransmitMemory(
    _In_ PNVNET_ADAPTER Adapter)
{
    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);
    }
}
 
static
CODE_SEG("PAGE")
VOID
NvNetInitReceiveMemory(
    _In_ PNVNET_ADAPTER Adapter)
{
    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;
        }
    }
}
 
 
CODE_SEG("PAGE")
VOID
NvNetFreeAdapter(
    _In_ PNVNET_ADAPTER Adapter)
{
    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);
}
 
CODE_SEG("PAGE")
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)
{
    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;
}