dc21x4.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS DC21x4 Driver
 * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:     Miniport driver entry
 * COPYRIGHT:   Copyright 2023 Dmitry Borisov <di.sean@protonmail.com>
 */
 
/* INCLUDES *******************************************************************/
 
#include "dc21x4.h"
 
#include <debug.h>
 
/* FUNCTIONS ******************************************************************/
 
ULONG
DcEthernetCrc(
    _In_reads_bytes_(Size) const VOID* Buffer,
    _In_ ULONG Size)
{
    ULONG i, j, Crc;
    const UCHAR* Data = Buffer;
 
    Crc = 0xFFFFFFFF;
    for (i = 0; i < Size; ++i)
    {
        Crc ^= Data[i];
        for (j = 8; j > 0; j--)
        {
            /* CRC-32 polynomial little-endian */
            Crc = (Crc >> 1) ^ (-(LONG)(Crc & 1) & 0xEDB88320);
        }
    }
 
    return Crc;
}
 
static
VOID
DcFlushTransmitQueue(
    _In_ PDC21X4_ADAPTER Adapter)
{
    LIST_ENTRY DoneList;
    PLIST_ENTRY Entry;
    PNDIS_PACKET Packet;
    PDC_TCB Tcb;
 
    InitializeListHead(&DoneList);
 
    NdisAcquireSpinLock(&Adapter->SendLock);
 
    /* Remove pending transmissions from the transmit ring */
    for (Tcb = Adapter->LastTcb;
         Tcb != Adapter->CurrentTcb;
         Tcb = DC_NEXT_TCB(Adapter, Tcb))
    {
        Packet = Tcb->Packet;
 
        if (!Packet)
            continue;
 
        InsertTailList(&DoneList, DC_LIST_ENTRY_FROM_PACKET(Packet));
 
        DC_RELEASE_TCB(Adapter, Tcb);
    }
    Adapter->CurrentTcb = Tcb;
 
    /* Remove pending transmissions from the internal queue */
    while (!IsListEmpty(&Adapter->SendQueueList))
    {
        Entry = RemoveHeadList(&Adapter->SendQueueList);
 
        InsertTailList(&DoneList, Entry);
    }
 
    NdisReleaseSpinLock(&Adapter->SendLock);
 
    while (!IsListEmpty(&DoneList))
    {
        Entry = RemoveHeadList(&DoneList);
 
        NdisMSendComplete(Adapter->AdapterHandle,
                          DC_PACKET_FROM_LIST_ENTRY(Entry),
                          NDIS_STATUS_FAILURE);
    }
}
 
static
VOID
DcStopReceivePath(
    _In_ PDC21X4_ADAPTER Adapter)
{
    BOOLEAN RxStopped;
 
    ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
 
#if DBG
    NdisAcquireSpinLock(&Adapter->ReceiveLock);
    if (Adapter->RcbFree != Adapter->RcbCount)
    {
        INFO("RX packets: %u/%u\n", Adapter->RcbFree, Adapter->RcbCount);
    }
    NdisReleaseSpinLock(&Adapter->ReceiveLock);
#endif
 
    while (TRUE)
    {
        NdisAcquireSpinLock(&Adapter->ReceiveLock);
 
        RxStopped = (Adapter->RcbFree == Adapter->RcbCount);
 
        NdisReleaseSpinLock(&Adapter->ReceiveLock);
 
        if (RxStopped)
            break;
 
        NdisMSleep(10);
    }
}
 
DECLSPEC_NOINLINE /* Called from pageable code */
VOID
DcStopAdapter(
    _In_ PDC21X4_ADAPTER Adapter,
    _In_ BOOLEAN WaitForPackets)
{
    BOOLEAN TimerCancelled;
 
    /* Attempt to disable interrupts to complete more quickly */
    DC_WRITE(Adapter, DcCsr7_IrqMask, 0);
 
    /* Prevent DPCs from executing and stop accepting incoming packets */
    NdisAcquireSpinLock(&Adapter->SendLock);
    Adapter->Flags &= ~DC_ACTIVE;
    NdisReleaseSpinLock(&Adapter->SendLock);
 
    NdisMCancelTimer(&Adapter->MediaMonitorTimer, &TimerCancelled);
 
    /* Wait for any DPCs to complete */
    KeFlushQueuedDpcs();
 
    /* Disable interrupts */
    DC_WRITE(Adapter, DcCsr7_IrqMask, 0);
 
    /* Wait for completion of TX/RX and stop the DMA engine inside the NIC */
    DcStopTxRxProcess(Adapter);
    Adapter->OpMode &= ~(DC_OPMODE_RX_ENABLE | DC_OPMODE_TX_ENABLE);
 
    DcFlushTransmitQueue(Adapter);
 
    /* Wait for the packets to be returned to the driver */
    if (WaitForPackets)
    {
        DcStopReceivePath(Adapter);
    }
 
    /* Make sure there is no pending OID request */
    if (Adapter->OidPending)
    {
        NdisMSetInformationComplete(Adapter->AdapterHandle, NDIS_STATUS_SUCCESS);
 
        Adapter->OidPending = FALSE;
    }
}
 
CODE_SEG("PAGE")
VOID
DcStartAdapter(
    _In_ PDC21X4_ADAPTER Adapter)
{
    PAGED_CODE();
 
    /* Enable interrupts */
    _InterlockedExchange((PLONG)&Adapter->CurrentInterruptMask, Adapter->InterruptMask);
    DC_WRITE(Adapter, DcCsr7_IrqMask, Adapter->InterruptMask);
 
    Adapter->Flags |= DC_ACTIVE;
 
    /* Start the RX process */
    Adapter->OpMode |= DC_OPMODE_RX_ENABLE;
    DC_WRITE(Adapter, DcCsr6_OpMode, Adapter->OpMode);
 
    /* Start the media monitor, wait the selected media to become ready */
    NdisMSetTimer(&Adapter->MediaMonitorTimer, 2400);
}
 
CODE_SEG("PAGE")
VOID
NTAPI
DcResetWorker(
    _In_ PNDIS_WORK_ITEM WorkItem,
    _In_opt_ PVOID Context)
{
    PDC21X4_ADAPTER Adapter = Context;
    NDIS_STATUS Status;
    ULONG InterruptStatus;
    LONG ResetReason;
 
    UNREFERENCED_PARAMETER(WorkItem);
 
    PAGED_CODE();
 
    Status = NDIS_STATUS_SUCCESS;
 
    /* Check if the device is present */
    InterruptStatus = DC_READ(Adapter, DcCsr5_Status);
    if (InterruptStatus == 0xFFFFFFFF)
    {
        ERR("Hardware is gone...\n");
 
        /* Remove this adapter */
        NdisMRemoveMiniport(Adapter->AdapterHandle);
 
        Status = NDIS_STATUS_HARD_ERRORS;
        goto Done;
    }
 
    DcStopAdapter(Adapter, FALSE);
 
    if (Adapter->LinkUp)
    {
        Adapter->LinkUp = FALSE;
 
        NdisMIndicateStatus(Adapter->AdapterHandle,
                            NDIS_STATUS_MEDIA_DISCONNECT,
                            NULL,
                            0);
        NdisMIndicateStatusComplete(Adapter->AdapterHandle);
    }
 
    DcSetupAdapter(Adapter);
 
    DcStartAdapter(Adapter);
 
Done:
    ResetReason = _InterlockedExchange(&Adapter->ResetLock, 0);
 
    /* Complete the pending reset request */
    if (ResetReason == 1)
    {
        NdisMResetComplete(Adapter->AdapterHandle, Status, FALSE);
    }
}
 
VOID
NTAPI
DcTransmitTimeoutRecoveryWorker(
    _In_ PNDIS_WORK_ITEM WorkItem,
    _In_opt_ PVOID Context)
{
    PDC21X4_ADAPTER Adapter = Context;
 
    UNREFERENCED_PARAMETER(WorkItem);
 
    NdisAcquireSpinLock(&Adapter->ModeLock);
 
    DcStopTxRxProcess(Adapter);
    DC_WRITE(Adapter, DcCsr6_OpMode, Adapter->OpMode);
 
    NdisDprAcquireSpinLock(&Adapter->SendLock);
 
    DC_WRITE(Adapter, DcCsr1_TxPoll, DC_TX_POLL_DOORBELL);
 
    NdisDprReleaseSpinLock(&Adapter->SendLock);
 
    NdisReleaseSpinLock(&Adapter->ModeLock);
}
 
static
BOOLEAN
NTAPI
DcCheckForHang(
    _In_ NDIS_HANDLE MiniportAdapterContext)
{
    PDC21X4_ADAPTER Adapter = (PDC21X4_ADAPTER)MiniportAdapterContext;
    ULONG TcbCompleted;
    BOOLEAN TxHang = FALSE;
 
    if (!(Adapter->Flags & DC_ACTIVE))
        return FALSE;
 
    NdisDprAcquireSpinLock(&Adapter->SendLock);
 
    if (Adapter->TcbSlots != (DC_TRANSMIT_BLOCKS - DC_TCB_RESERVE))
    {
        TcbCompleted = Adapter->TcbCompleted;
        TxHang = (TcbCompleted == Adapter->LastTcbCompleted);
        Adapter->LastTcbCompleted = TcbCompleted;
    }
 
    NdisDprReleaseSpinLock(&Adapter->SendLock);
 
    if (TxHang)
    {
        WARN("Transmit timeout, CSR12 %08lx, CSR5 %08lx\n",
             DC_READ(Adapter, DcCsr12_SiaStatus),
             DC_READ(Adapter, DcCsr5_Status));
 
        NdisScheduleWorkItem(&Adapter->TxRecoveryWorkItem);
    }
 
    return FALSE;
}
 
static
NDIS_STATUS
NTAPI
DcReset(
    _Out_ PBOOLEAN AddressingReset,
    _In_ NDIS_HANDLE MiniportAdapterContext)
{
    PDC21X4_ADAPTER Adapter = (PDC21X4_ADAPTER)MiniportAdapterContext;
 
    WARN("Called\n");
 
    if (_InterlockedCompareExchange(&Adapter->ResetLock, 1, 0))
    {
        return NDIS_STATUS_RESET_IN_PROGRESS;
    }
 
    NdisScheduleWorkItem(&Adapter->ResetWorkItem);
 
    return NDIS_STATUS_PENDING;
}
 
static
CODE_SEG("PAGE")
VOID
NTAPI
DcHalt(
    _In_ NDIS_HANDLE MiniportAdapterContext)
{
    PDC21X4_ADAPTER Adapter = (PDC21X4_ADAPTER)MiniportAdapterContext;
 
    PAGED_CODE();
 
    INFO("Called\n");
 
    DcStopAdapter(Adapter, TRUE);
 
    DcDisableHw(Adapter);
 
    DcFreeAdapter(Adapter);
}
 
static
VOID
NTAPI
DcShutdown(
    _In_ NDIS_HANDLE MiniportAdapterContext)
{
    PDC21X4_ADAPTER Adapter = (PDC21X4_ADAPTER)MiniportAdapterContext;
 
    INFO("Called\n");
 
    DcDisableHw(Adapter);
}
 
CODE_SEG("INIT")
NTSTATUS
NTAPI
DriverEntry(
    _In_ PDRIVER_OBJECT DriverObject,
    _In_ PUNICODE_STRING RegistryPath)
{
    NDIS_HANDLE WrapperHandle;
    NDIS_STATUS Status;
    NDIS_MINIPORT_CHARACTERISTICS Characteristics = { 0 };
 
    INFO("Called\n");
 
    NdisMInitializeWrapper(&WrapperHandle, DriverObject, RegistryPath, NULL);
    if (!WrapperHandle)
        return NDIS_STATUS_FAILURE;
 
    Characteristics.MajorNdisVersion = NDIS_MINIPORT_MAJOR_VERSION;
    Characteristics.MinorNdisVersion = NDIS_MINIPORT_MINOR_VERSION;
    Characteristics.CheckForHangHandler = DcCheckForHang;
    Characteristics.HaltHandler = DcHalt;
    Characteristics.HandleInterruptHandler = DcHandleInterrupt;
    Characteristics.InitializeHandler = DcInitialize;
    Characteristics.ISRHandler = DcIsr;
    Characteristics.QueryInformationHandler = DcQueryInformation;
    Characteristics.ResetHandler = DcReset;
    Characteristics.SetInformationHandler = DcSetInformation;
    Characteristics.ReturnPacketHandler = DcReturnPacket;
    Characteristics.SendPacketsHandler = DcSendPackets;
    Characteristics.CancelSendPacketsHandler = DcCancelSendPackets;
    Characteristics.AdapterShutdownHandler = DcShutdown;
 
    Status = NdisMRegisterMiniport(WrapperHandle, &Characteristics, sizeof(Characteristics));
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NdisTerminateWrapper(WrapperHandle, NULL);
        return Status;
    }
 
    InitializeListHead(&SRompAdapterList);
 
    return NDIS_STATUS_SUCCESS;
}