requests.c File Reference

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

Include dependency graph for requests.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	NdisEqualMemory   NvEqualMemory

Functions
static ULONG	NvNetGetLinkSpeed (_In_ PNVNET_ADAPTER Adapter)
static ULONG	PacketFilterToMask (_In_ ULONG PacketFilter)
static DECLSPEC_NOINLINE VOID	NvNetApplyPacketFilter (_In_ PNVNET_ADAPTER Adapter)
static VOID	NvNetReadStatistics (_In_ PNVNET_ADAPTER Adapter)
static VOID	NvNetQueryHwCounter (_In_ PNVNET_ADAPTER Adapter, _In_ NDIS_OID Oid, _Out_ PULONG64 Counter)
static VOID	NvNetQuerySoftwareCounter (_In_ PNVNET_ADAPTER Adapter, _In_ NDIS_OID Oid, _Out_ PULONG64 Counter)
static NDIS_STATUS	NvNetFillPowerManagementCapabilities (_In_ PNVNET_ADAPTER Adapter, _Out_ PNDIS_PNP_CAPABILITIES Capabilities)
static ULONG	BuildFrameSignature (_In_ PNVNET_WAKE_FRAME WakeFrame)
static VOID	WriteWakeFrame (_In_ PNVNET_ADAPTER Adapter, _In_ PNVNET_WAKE_FRAME WakeFrame, _In_ ULONG FrameNumber)
static ULONG	FrameNumberToWakeUpMask (_In_ ULONG FrameNumber)
static ULONG	FrameNumberToPowerMask (_In_ ULONG FrameNumber)
VOID	NvNetSetPowerState (_In_ PNVNET_ADAPTER Adapter, _In_ NDIS_DEVICE_POWER_STATE NewPowerState, _In_ ULONG WakeFlags)
static VOID NTAPI	NvNetPowerWorker (_In_ PNDIS_WORK_ITEM WorkItem, _In_opt_ PVOID Context)
static NDIS_STATUS	NvNetSetPower (_In_ PNVNET_ADAPTER Adapter, _In_ NDIS_DEVICE_POWER_STATE NewPowerState)
static NDIS_STATUS	NvNetAddWakeUpPattern (_In_ PNVNET_ADAPTER Adapter, _In_ PNDIS_PM_PACKET_PATTERN Pattern)
static BOOLEAN	NvEqualMemory (_In_reads_bytes_(Length) PVOID Destination, _In_reads_bytes_(Length) PVOID Source, _In_ ULONG Length)
static NDIS_STATUS	NvNetRemoveWakeUpPattern (_In_ PNVNET_ADAPTER Adapter, _In_ PNDIS_PM_PACKET_PATTERN Pattern)
static ULONG	NvNetGetWakeUp (_In_ PNVNET_ADAPTER Adapter)
static VOID	NvNetEnableWakeUp (_In_ PNVNET_ADAPTER Adapter, _In_ ULONG Flags)
static NDIS_STATUS	NvNetGetTcpTaskOffload (_In_ PNVNET_ADAPTER Adapter, _In_ PNDIS_TASK_OFFLOAD_HEADER TaskOffloadHeader, _In_ ULONG InformationBufferLength, _Out_ PULONG BytesWritten, _Out_ PULONG BytesNeeded)
static NDIS_STATUS	NvNetSetTcpTaskOffload (_Inout_ PNVNET_ADAPTER Adapter, _In_ PNDIS_TASK_OFFLOAD_HEADER TaskOffloadHeader, _In_ PULONG BytesRead)
NDIS_STATUS NTAPI	MiniportQueryInformation (_In_ NDIS_HANDLE MiniportAdapterContext, _In_ NDIS_OID Oid, _In_ PVOID InformationBuffer, _In_ ULONG InformationBufferLength, _Out_ PULONG BytesWritten, _Out_ PULONG BytesNeeded)
NDIS_STATUS NTAPI	MiniportSetInformation (_In_ NDIS_HANDLE MiniportAdapterContext, _In_ NDIS_OID Oid, _In_ PVOID InformationBuffer, _In_ ULONG InformationBufferLength, _Out_ PULONG BytesRead, _Out_ PULONG BytesNeeded)

Variables
static const NDIS_OID	NvpSupportedOidList []

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file requests.c.

NdisEqualMemory

#define NdisEqualMemory   NvEqualMemory

Definition at line 717 of file requests.c.

Function Documentation

BuildFrameSignature()

static ULONG BuildFrameSignature ( _In_ PNVNET_WAKE_FRAME  WakeFrame )

static

Definition at line 427 of file requests.c.

{
    ULONG i, j, Crc;
 
    Crc = 0xFFFFFFFF;
    for (i = 0; i < sizeof(WakeFrame->WakeUpPattern); ++i)
    {
        if (WakeFrame->PatternMask.AsUCHAR[i / 8] & (1 << (i % 8)))
        {
            Crc ^= WakeFrame->WakeUpPattern[i];
            for (j = 8; j > 0; --j)
            {
                Crc = (Crc >> 1) ^ (-(LONG)(Crc & 1) & 0xEDB88320);
            }
        }
    }
 
    return ~Crc;
}

Referenced by WriteWakeFrame().

FrameNumberToPowerMask()

static ULONG FrameNumberToPowerMask ( _In_ ULONG  FrameNumber )

static

Definition at line 482 of file requests.c.

{
    switch (FrameNumber)
    {
        case 5:
            return NVREG_POWERSTATE2_WAKEUPPAT_5;
        case 6:
            return NVREG_POWERSTATE2_WAKEUPPAT_6;
        case 7:
            return NVREG_POWERSTATE2_WAKEUPPAT_7;
 
        default:
            return 0;
    }
}

Referenced by NvNetSetPowerState().

FrameNumberToWakeUpMask()

static ULONG FrameNumberToWakeUpMask ( _In_ ULONG  FrameNumber )

static

Definition at line 471 of file requests.c.

{
    if (FrameNumber < 5)
        return 0x10000 << FrameNumber;
    else
        return 0;
}

Referenced by NvNetSetPowerState().

MiniportQueryInformation()

NDIS_STATUS NTAPI MiniportQueryInformation	(	_In_ NDIS_HANDLE	MiniportAdapterContext,
		_In_ NDIS_OID	Oid,
		_In_ PVOID	InformationBuffer,
		_In_ ULONG	InformationBufferLength,
		_Out_ PULONG	BytesWritten,
		_Out_ PULONG	BytesNeeded
	)

Definition at line 997 of file requests.c.

{
    PNVNET_ADAPTER Adapter = (PNVNET_ADAPTER)MiniportAdapterContext;
    NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
    ULONG InfoLength;
    PVOID InfoPtr;
    union _GENERIC_INFORMATION
    {
        USHORT Ushort;
        ULONG Ulong;
        ULONG64 Ulong64;
        NDIS_MEDIUM Medium;
        NDIS_HARDWARE_STATUS Status;
        NDIS_DEVICE_POWER_STATE PowerState;
    } GenericInfo;
 
    InfoLength = sizeof(ULONG);
    InfoPtr = &GenericInfo;
 
    switch (Oid)
    {
        case OID_GEN_SUPPORTED_LIST:
            InfoPtr = (PVOID)&NvpSupportedOidList;
            InfoLength = sizeof(NvpSupportedOidList);
            break;
 
        case OID_GEN_HARDWARE_STATUS:
            InfoLength = sizeof(NDIS_HARDWARE_STATUS);
            GenericInfo.Status = NdisHardwareStatusReady;
            break;
 
        case OID_GEN_MEDIA_SUPPORTED:
        case OID_GEN_MEDIA_IN_USE:
        {
            InfoLength = sizeof(NDIS_MEDIUM);
            GenericInfo.Medium = NdisMedium802_3;
            break;
        }
 
        case OID_GEN_CURRENT_LOOKAHEAD:
        case OID_GEN_MAXIMUM_LOOKAHEAD:
        {
            GenericInfo.Ulong = Adapter->MaximumFrameSize - sizeof(ETH_HEADER);
            break;
        }
 
        case OID_GEN_MAXIMUM_FRAME_SIZE:
        {
            GenericInfo.Ulong = Adapter->MaximumFrameSize;
            break;
        }
 
        case OID_GEN_LINK_SPEED:
        {
            GenericInfo.Ulong = NvNetGetLinkSpeed(Adapter) * 10000;
            break;
        }
 
        case OID_GEN_TRANSMIT_BUFFER_SPACE:
        {
            /* TODO: Change this later, once the driver can handle multipacket sends */
            GenericInfo.Ulong = Adapter->MaximumFrameSize;
            break;
        }
 
        case OID_GEN_RECEIVE_BUFFER_SPACE:
        {
            GenericInfo.Ulong = Adapter->MaximumFrameSize * NVNET_RECEIVE_DESCRIPTORS;
        }
 
        case OID_GEN_MAXIMUM_TOTAL_SIZE:
        case OID_GEN_TRANSMIT_BLOCK_SIZE:
        case OID_GEN_RECEIVE_BLOCK_SIZE:
        {
            GenericInfo.Ulong = Adapter->MaximumFrameSize;
            break;
        }
 
        case OID_GEN_VENDOR_ID:
        {
            GenericInfo.Ulong = 0;
            GenericInfo.Ulong |= (Adapter->PermanentMacAddress[0] << 16);
            GenericInfo.Ulong |= (Adapter->PermanentMacAddress[1] << 8);
            GenericInfo.Ulong |= (Adapter->PermanentMacAddress[2] & 0xFF);
            break;
        }
 
        case OID_GEN_DRIVER_VERSION:
        {
            InfoLength = sizeof(USHORT);
            GenericInfo.Ushort = (NDIS_MINIPORT_MAJOR_VERSION << 8) | NDIS_MINIPORT_MINOR_VERSION;
            break;
        }
 
        case OID_GEN_VENDOR_DESCRIPTION:
        {
            static const CHAR VendorDesc[] = "nVidia nForce Ethernet Controller";
            InfoPtr = (PVOID)&VendorDesc;
            InfoLength = sizeof(VendorDesc);
            break;
        }
 
        case OID_GEN_CURRENT_PACKET_FILTER:
        {
            GenericInfo.Ulong = Adapter->PacketFilter;
            break;
        }
 
        case OID_GEN_MAC_OPTIONS:
        {
            GenericInfo.Ulong = NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
                                NDIS_MAC_OPTION_TRANSFERS_NOT_PEND |
                                NDIS_MAC_OPTION_NO_LOOPBACK;
 
            if (Adapter->Flags & NV_PACKET_PRIORITY)
                GenericInfo.Ulong |= NDIS_MAC_OPTION_8021P_PRIORITY;
            if (Adapter->Flags & NV_VLAN_TAGGING)
                GenericInfo.Ulong |= NDIS_MAC_OPTION_8021Q_VLAN;
            break;
        }
 
        case OID_GEN_MEDIA_CONNECT_STATUS:
        {
            GenericInfo.Ulong = Adapter->Connected ? NdisMediaStateConnected
                                                   : NdisMediaStateDisconnected;
            break;
        }
 
        case OID_GEN_MAXIMUM_SEND_PACKETS:
        {
            /* TODO: Multipacket sends */
            GenericInfo.Ulong = 1;
            break;
        }
 
        case OID_GEN_VENDOR_DRIVER_VERSION:
        {
            /* 1.0.0 */
            GenericInfo.Ulong = 0x100;
            break;
        }
 
        case OID_GEN_XMIT_OK:
        case OID_GEN_RCV_OK:
        case OID_GEN_XMIT_ERROR:
        case OID_GEN_RCV_ERROR:
        case OID_GEN_RCV_NO_BUFFER:
        case OID_GEN_DIRECTED_FRAMES_RCV:
        case OID_GEN_RCV_CRC_ERROR:
        case OID_802_3_RCV_ERROR_ALIGNMENT:
        case OID_802_3_XMIT_ONE_COLLISION:
        case OID_802_3_XMIT_MORE_COLLISIONS:
        case OID_802_3_XMIT_DEFERRED:
        case OID_802_3_XMIT_MAX_COLLISIONS:
        case OID_802_3_RCV_OVERRUN:
        case OID_802_3_XMIT_UNDERRUN:
        case OID_802_3_XMIT_HEARTBEAT_FAILURE:
        case OID_802_3_XMIT_TIMES_CRS_LOST:
        case OID_802_3_XMIT_LATE_COLLISIONS:
        {
            if (Adapter->Features & DEV_HAS_STATISTICS_COUNTERS)
            {
                NvNetReadStatistics(Adapter);
                NvNetQueryHwCounter(Adapter, Oid, &GenericInfo.Ulong64);
            }
            else
            {
                NvNetQuerySoftwareCounter(Adapter, Oid, &GenericInfo.Ulong64);
            }
 
            *BytesNeeded = sizeof(ULONG64);
            if (InformationBufferLength < sizeof(ULONG))
            {
                *BytesWritten = 0;
                return NDIS_STATUS_BUFFER_TOO_SHORT;
            }
            if (InformationBufferLength >= sizeof(ULONG64))
            {
                *BytesWritten = sizeof(ULONG64);
                NdisMoveMemory(InformationBuffer, InfoPtr, sizeof(ULONG64));
            }
            else
            {
                *BytesWritten = sizeof(ULONG);
                NdisMoveMemory(InformationBuffer, InfoPtr, sizeof(ULONG));
            }
 
            return NDIS_STATUS_SUCCESS;
        }
 
        case OID_GEN_TRANSMIT_QUEUE_LENGTH:
        {
            GenericInfo.Ulong = NVNET_TRANSMIT_BLOCKS - Adapter->Send.TcbSlots;
            break;
        }
 
        case OID_802_3_PERMANENT_ADDRESS:
        {
            InfoPtr = Adapter->PermanentMacAddress;
            InfoLength = ETH_LENGTH_OF_ADDRESS;
            break;
        }
 
        case OID_802_3_CURRENT_ADDRESS:
        {
            InfoPtr = Adapter->CurrentMacAddress;
            InfoLength = ETH_LENGTH_OF_ADDRESS;
            break;
        }
 
        case OID_802_3_MULTICAST_LIST:
        {
            InfoPtr = Adapter->MulticastList;
            InfoLength = Adapter->MulticastListSize * ETH_LENGTH_OF_ADDRESS;
            break;
        }
 
        case OID_802_3_MAXIMUM_LIST_SIZE:
        {
            GenericInfo.Ulong = NVNET_MULTICAST_LIST_SIZE;
            break;
        }
 
        case OID_TCP_TASK_OFFLOAD:
        {
            return NvNetGetTcpTaskOffload(Adapter,
                                          InformationBuffer,
                                          InformationBufferLength,
                                          BytesWritten,
                                          BytesWritten);
        }
 
        case OID_PNP_ENABLE_WAKE_UP:
        {
            GenericInfo.Ulong = NvNetGetWakeUp(Adapter);
            break;
        }
 
        case OID_PNP_CAPABILITIES:
        {
            InfoLength = sizeof(NDIS_PNP_CAPABILITIES);
 
            if (InformationBufferLength < InfoLength)
            {
                *BytesWritten = 0;
                *BytesNeeded = InfoLength;
                return NDIS_STATUS_BUFFER_TOO_SHORT;
            }
 
            *BytesWritten = InfoLength;
            *BytesNeeded = 0;
            return NvNetFillPowerManagementCapabilities(Adapter, InformationBuffer);
        }
 
        case OID_PNP_QUERY_POWER:
        {
            return NDIS_STATUS_SUCCESS;
        }
 
        case OID_GEN_VLAN_ID:
        {
            /* TODO: Implement software VLAN support */
            if (!(Adapter->Flags & NV_VLAN_TAGGING))
            {
                Status = NDIS_STATUS_NOT_SUPPORTED;
                break;
            }
 
            GenericInfo.Ulong = Adapter->VlanId;
            break;
        }
 
        default:
            Status = NDIS_STATUS_INVALID_OID;
            break;
    }
 
    if (Status == NDIS_STATUS_SUCCESS)
    {
        if (InfoLength > InformationBufferLength)
        {
            *BytesWritten = 0;
            *BytesNeeded = InfoLength;
            Status = NDIS_STATUS_BUFFER_TOO_SHORT;
        }
        else
        {
            NdisMoveMemory(InformationBuffer, InfoPtr, InfoLength);
            *BytesWritten = InfoLength;
            *BytesNeeded = 0;
        }
    }
    else
    {
        *BytesWritten = 0;
        *BytesNeeded = 0;
    }
 
    return Status;
}

MiniportSetInformation()

NDIS_STATUS NTAPI MiniportSetInformation	(	_In_ NDIS_HANDLE	MiniportAdapterContext,
		_In_ NDIS_OID	Oid,
		_In_ PVOID	InformationBuffer,
		_In_ ULONG	InformationBufferLength,
		_Out_ PULONG	BytesRead,
		_Out_ PULONG	BytesNeeded
	)

Definition at line 1306 of file requests.c.

{
    PNVNET_ADAPTER Adapter = (PNVNET_ADAPTER)MiniportAdapterContext;
    NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
    ULONG GenericUlong;
 
    *BytesRead = 0;
    *BytesNeeded = 0;
 
    switch (Oid)
    {
        case OID_802_3_MULTICAST_LIST:
        {
            if (InformationBufferLength % ETH_LENGTH_OF_ADDRESS)
            {
                *BytesNeeded = (InformationBufferLength / ETH_LENGTH_OF_ADDRESS) *
                               ETH_LENGTH_OF_ADDRESS;
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            if (InformationBufferLength > sizeof(Adapter->MulticastList))
            {
                *BytesNeeded = sizeof(Adapter->MulticastList);
                Status = NDIS_STATUS_MULTICAST_FULL;
                break;
            }
 
            *BytesRead = InformationBufferLength;
            NdisMoveMemory(Adapter->MulticastList, InformationBuffer, InformationBufferLength);
 
            Adapter->MulticastListSize = InformationBufferLength / ETH_LENGTH_OF_ADDRESS;
 
            NvNetApplyPacketFilter(Adapter);
            break;
        }
 
        case OID_GEN_CURRENT_PACKET_FILTER:
        {
            if (InformationBufferLength < sizeof(ULONG))
            {
                *BytesNeeded = sizeof(ULONG);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            *BytesRead = sizeof(ULONG);
            NdisMoveMemory(&GenericUlong, InformationBuffer, sizeof(ULONG));
 
            if (GenericUlong & ~NVNET_PACKET_FILTERS)
            {
                Status = NDIS_STATUS_NOT_SUPPORTED;
                break;
            }
 
            /* Do not check to see if the filter is the same filter */
            Adapter->PacketFilter = GenericUlong;
 
            NvNetApplyPacketFilter(Adapter);
            break;
        }
 
        case OID_GEN_CURRENT_LOOKAHEAD:
        {
            if (InformationBufferLength < sizeof(ULONG))
            {
                *BytesNeeded = sizeof(ULONG);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            /* Nothing to do */
            *BytesRead = sizeof(ULONG);
            break;
        }
 
        case OID_GEN_VLAN_ID:
        {
            if (InformationBufferLength < sizeof(ULONG))
            {
                *BytesNeeded = sizeof(ULONG);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            if (!(Adapter->Flags & NV_VLAN_TAGGING))
            {
                Status = NDIS_STATUS_NOT_SUPPORTED;
                break;
            }
 
            *BytesRead = sizeof(ULONG);
            NdisMoveMemory(&GenericUlong, InformationBuffer, sizeof(ULONG));
 
            if (GenericUlong > NVNET_MAXIMUM_VLAN_ID)
            {
                Status = NDIS_STATUS_FAILURE;
                break;
            }
 
            Adapter->VlanId = GenericUlong;
            break;
        }
 
        case OID_TCP_TASK_OFFLOAD:
        {
            if (InformationBufferLength < sizeof(NDIS_TASK_OFFLOAD_HEADER))
            {
                *BytesNeeded = sizeof(NDIS_TASK_OFFLOAD_HEADER);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            *BytesRead = InformationBufferLength;
 
            Status = NvNetSetTcpTaskOffload(Adapter, InformationBuffer, BytesRead);
            break;
        }
 
        case OID_PNP_ADD_WAKE_UP_PATTERN:
        {
            if (InformationBufferLength < sizeof(NDIS_PM_PACKET_PATTERN))
            {
                *BytesNeeded = sizeof(NDIS_PM_PACKET_PATTERN);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            *BytesRead = sizeof(NDIS_PM_PACKET_PATTERN);
 
            Status = NvNetAddWakeUpPattern(Adapter, InformationBuffer);
            break;
        }
 
        case OID_PNP_REMOVE_WAKE_UP_PATTERN:
        {
            if (InformationBufferLength < sizeof(NDIS_PM_PACKET_PATTERN))
            {
                *BytesNeeded = sizeof(NDIS_PM_PACKET_PATTERN);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            *BytesRead = sizeof(NDIS_PM_PACKET_PATTERN);
 
            Status = NvNetRemoveWakeUpPattern(Adapter, InformationBuffer);
            break;
        }
 
        case OID_PNP_ENABLE_WAKE_UP:
        {
            if (InformationBufferLength < sizeof(ULONG))
            {
                *BytesNeeded = sizeof(ULONG);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            *BytesRead = sizeof(ULONG);
            NdisMoveMemory(&GenericUlong, InformationBuffer, sizeof(ULONG));
 
            NvNetEnableWakeUp(Adapter, GenericUlong);
            break;
        }
 
        case OID_PNP_SET_POWER:
        {
            if (InformationBufferLength < sizeof(NDIS_DEVICE_POWER_STATE))
            {
                *BytesNeeded = sizeof(NDIS_DEVICE_POWER_STATE);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            *BytesRead = sizeof(ULONG);
            NdisMoveMemory(&GenericUlong, InformationBuffer, sizeof(ULONG));
 
            if (GenericUlong < NdisDeviceStateD0 || GenericUlong > NdisDeviceStateD3)
            {
                Status = NDIS_STATUS_INVALID_DATA;
                break;
            }
 
            Status = NvNetSetPower(Adapter, GenericUlong);
            break;
        }
 
        default:
            Status = NDIS_STATUS_NOT_SUPPORTED;
            break;
    }
 
    return Status;
}

NvEqualMemory()

static BOOLEAN NvEqualMemory ( _In_reads_bytes_(Length) PVOID  Destination, _In_reads_bytes_(Length) PVOID  Source, _In_ ULONG  Length  )

static

Definition at line 697 of file requests.c.

{
    ULONG i;
    PUCHAR Src, Dest;
 
    Src = Source;
    Dest = Destination;
    for (i = 0; i < Length; ++i)
    {
        if (Src[i] != Dest[i])
            return FALSE;
    }
 
    return TRUE;
}

NvNetAddWakeUpPattern()

static NDIS_STATUS NvNetAddWakeUpPattern ( _In_ PNVNET_ADAPTER  Adapter, _In_ PNDIS_PM_PACKET_PATTERN  Pattern  )

static

Definition at line 660 of file requests.c.

{
    ULONG FrameNumber;
    NDIS_STATUS Status;
    PNVNET_WAKE_FRAME WakeFrame;
 
    if (!_BitScanForward(&FrameNumber, Adapter->WakeFrameBitmap))
    {
        return NDIS_STATUS_RESOURCES;
    }
 
    Status = NdisAllocateMemoryWithTag((PVOID*)&WakeFrame, sizeof(*WakeFrame), NVNET_TAG);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        return NDIS_STATUS_RESOURCES;
    }
 
    Adapter->WakeFrameBitmap &= ~(1 << FrameNumber);
 
    NdisZeroMemory(WakeFrame, sizeof(*WakeFrame));
    NdisMoveMemory(&WakeFrame->PatternMask,
                   (PUCHAR)Pattern + sizeof(NDIS_PM_PACKET_PATTERN),
                   min(Pattern->MaskSize, 16));
    NdisMoveMemory(&WakeFrame->WakeUpPattern,
                   (PUCHAR)Pattern + Pattern->PatternOffset,
                   min(Pattern->PatternSize, 128));
    Adapter->WakeFrames[FrameNumber] = WakeFrame;
 
    /* TODO: VLAN frame translation */
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportSetInformation().

NvNetApplyPacketFilter()

static DECLSPEC_NOINLINE VOID NvNetApplyPacketFilter ( _In_ PNVNET_ADAPTER  Adapter )

static

Definition at line 130 of file requests.c.

{
    UCHAR Address[ETH_LENGTH_OF_ADDRESS];
    UCHAR Mask[ETH_LENGTH_OF_ADDRESS];
    ULONG FilterMask;
    BOOLEAN RestartReceiver;
 
    if (Adapter->PacketFilter & NDIS_PACKET_TYPE_ALL_MULTICAST)
    {
        NdisZeroMemory(Address, sizeof(Address));
        NdisZeroMemory(Mask, sizeof(Mask));
 
        Address[0] |= NVREG_MCASTADDRA_FORCE;
        Mask[0] |= NVREG_MCASTADDRA_FORCE;
    }
    else if (Adapter->PacketFilter & NDIS_PACKET_TYPE_MULTICAST)
    {
        if (Adapter->MulticastListSize > 0)
        {
            ULONG i, j;
 
            NdisFillMemory(Address, sizeof(Address), 0xFF);
            NdisFillMemory(Mask, sizeof(Mask), 0xFF);
 
            for (i = 0; i < Adapter->MulticastListSize; ++i)
            {
                PUCHAR MacAddress = Adapter->MulticastList[i].MacAddress;
 
                for (j = 0; j < ETH_LENGTH_OF_ADDRESS; ++j)
                {
                    Address[j] &= MacAddress[j];
                    Mask[j] &= ~MacAddress[j];
                }
            }
 
            for (j = 0; j < ETH_LENGTH_OF_ADDRESS; ++j)
            {
                Mask[j] |= Address[j];
            }
        }
        else
        {
            NdisZeroMemory(Address, sizeof(Address));
            NdisZeroMemory(Mask, sizeof(Mask));
        }
    }
    else
    {
        NdisZeroMemory(Address, sizeof(Address));
        NdisFillMemory(Mask, sizeof(Mask), 0xFF);
    }
 
    FilterMask = NV_READ(Adapter, NvRegPacketFilterFlags) & NVREG_PFF_PAUSE_RX;
    FilterMask |= PacketFilterToMask(Adapter->PacketFilter);
 
    NdisAcquireSpinLock(&Adapter->Receive.Lock);
 
    RestartReceiver = !!(NV_READ(Adapter, NvRegReceiverControl) & NVREG_RCVCTL_START);
    if (RestartReceiver)
    {
        NvNetStopReceiver(Adapter);
    }
 
    NV_WRITE(Adapter, NvRegMulticastAddrA,
             Address[3] << 24 | Address[2] << 16 | Address[1] << 8 | Address[0]);
    NV_WRITE(Adapter, NvRegMulticastAddrB, Address[5] << 8 | Address[4]);
    NV_WRITE(Adapter, NvRegMulticastMaskA,
             Mask[3] << 24 | Mask[2] << 16 | Mask[1] << 8 | Mask[0]);
    NV_WRITE(Adapter, NvRegMulticastMaskB, Mask[5] << 8 | Mask[4]);
 
    NV_WRITE(Adapter, NvRegPacketFilterFlags, FilterMask);
 
    if (RestartReceiver)
    {
        NvNetStartReceiver(Adapter);
    }
 
    NdisReleaseSpinLock(&Adapter->Receive.Lock);
}

Referenced by MiniportSetInformation(), and NvNetPowerWorker().

NvNetEnableWakeUp()

static VOID NvNetEnableWakeUp ( _In_ PNVNET_ADAPTER  Adapter, _In_ ULONG  Flags  )

static

Definition at line 771 of file requests.c.

{
    Adapter->WakeFlags = Flags;
}

Referenced by MiniportSetInformation().

NvNetFillPowerManagementCapabilities()

static NDIS_STATUS NvNetFillPowerManagementCapabilities ( _In_ PNVNET_ADAPTER  Adapter, _Out_ PNDIS_PNP_CAPABILITIES  Capabilities  )

static

Definition at line 413 of file requests.c.

{
    Capabilities->WakeUpCapabilities.MinMagicPacketWakeUp =
    Capabilities->WakeUpCapabilities.MinPatternWakeUp =
    Capabilities->WakeUpCapabilities.MinLinkChangeWakeUp = NdisDeviceStateD3;
 
    /* All hardware is PM-aware */
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportQueryInformation().

NvNetGetLinkSpeed()

static ULONG NvNetGetLinkSpeed ( _In_ PNVNET_ADAPTER  Adapter )

static

Definition at line 82 of file requests.c.

{
    ULONG LinkSpeedMbps;
 
    switch (Adapter->LinkSpeed)
    {
        case NVREG_LINKSPEED_10:
            LinkSpeedMbps = 10;
            break;
        case NVREG_LINKSPEED_100:
            LinkSpeedMbps = 100;
            break;
        case NVREG_LINKSPEED_1000:
            LinkSpeedMbps = 1000;
            break;
 
        default:
            UNREACHABLE;
            break;
    }
 
    return LinkSpeedMbps;
}

Referenced by MiniportQueryInformation().

NvNetGetTcpTaskOffload()

static NDIS_STATUS NvNetGetTcpTaskOffload ( _In_ PNVNET_ADAPTER  Adapter, _In_ PNDIS_TASK_OFFLOAD_HEADER  TaskOffloadHeader, _In_ ULONG  InformationBufferLength, _Out_ PULONG  BytesWritten, _Out_ PULONG  BytesNeeded  )

static

Definition at line 780 of file requests.c.

{
    ULONG InfoLength;
    PNDIS_TASK_OFFLOAD TaskOffload;
 
    if (!(Adapter->Flags & (NV_SEND_CHECKSUM | NV_SEND_LARGE_SEND)))
    {
        *BytesWritten = 0;
        *BytesNeeded = 0;
        return NDIS_STATUS_NOT_SUPPORTED;
    }
 
    InfoLength = sizeof(NDIS_TASK_OFFLOAD_HEADER);
    if (Adapter->Flags & NV_SEND_CHECKSUM)
    {
        InfoLength += FIELD_OFFSET(NDIS_TASK_OFFLOAD, TaskBuffer) +
                      sizeof(NDIS_TASK_TCP_IP_CHECKSUM);
    }
    if (Adapter->Flags & NV_SEND_LARGE_SEND)
    {
        InfoLength += FIELD_OFFSET(NDIS_TASK_OFFLOAD, TaskBuffer) +
                      sizeof(NDIS_TASK_TCP_LARGE_SEND);
    }
 
    if (InformationBufferLength < InfoLength)
    {
        *BytesWritten = 0;
        *BytesNeeded = InfoLength;
        return NDIS_STATUS_BUFFER_TOO_SHORT;
    }
 
    if ((TaskOffloadHeader->EncapsulationFormat.Encapsulation != IEEE_802_3_Encapsulation) &&
        (TaskOffloadHeader->EncapsulationFormat.Encapsulation != UNSPECIFIED_Encapsulation ||
         TaskOffloadHeader->EncapsulationFormat.EncapsulationHeaderSize != sizeof(ETH_HEADER)))
    {
        *BytesWritten = 0;
        *BytesNeeded = 0;
        return NDIS_STATUS_NOT_SUPPORTED;
    }
    if (TaskOffloadHeader->Version != NDIS_TASK_OFFLOAD_VERSION)
    {
        *BytesWritten = 0;
        *BytesNeeded = 0;
        return NDIS_STATUS_NOT_SUPPORTED;
    }
 
    TaskOffloadHeader->OffsetFirstTask = sizeof(NDIS_TASK_OFFLOAD_HEADER);
    TaskOffload = (PNDIS_TASK_OFFLOAD)(TaskOffloadHeader + 1);
    if (Adapter->Flags & NV_SEND_CHECKSUM)
    {
        PNDIS_TASK_TCP_IP_CHECKSUM ChecksumTask;
 
        TaskOffload->Size = sizeof(NDIS_TASK_OFFLOAD);
        TaskOffload->Version = NDIS_TASK_OFFLOAD_VERSION;
        TaskOffload->Task = TcpIpChecksumNdisTask;
        TaskOffload->TaskBufferLength = sizeof(NDIS_TASK_TCP_IP_CHECKSUM);
        TaskOffload->OffsetNextTask = FIELD_OFFSET(NDIS_TASK_OFFLOAD, TaskBuffer) +
                                      sizeof(NDIS_TASK_TCP_IP_CHECKSUM);
 
        ChecksumTask = (PNDIS_TASK_TCP_IP_CHECKSUM)TaskOffload->TaskBuffer;
        NdisZeroMemory(ChecksumTask, sizeof(*ChecksumTask));
 
        ChecksumTask->V4Transmit.IpOptionsSupported = 1;
        ChecksumTask->V4Transmit.TcpOptionsSupported = 1;
        ChecksumTask->V4Transmit.TcpChecksum = 1;
        ChecksumTask->V4Transmit.UdpChecksum = 1;
        ChecksumTask->V4Transmit.IpChecksum = 1;
 
        ChecksumTask->V4Receive.IpOptionsSupported = 1;
        ChecksumTask->V4Receive.TcpOptionsSupported = 1;
        ChecksumTask->V4Receive.TcpChecksum = 1;
        ChecksumTask->V4Receive.UdpChecksum = 1;
        ChecksumTask->V4Receive.IpChecksum = 1;
 
        TaskOffload = (PNDIS_TASK_OFFLOAD)(ChecksumTask + 1);
    }
    if (Adapter->Flags & NV_SEND_LARGE_SEND)
    {
        PNDIS_TASK_TCP_LARGE_SEND LargeSendTask;
 
        TaskOffload->Size = sizeof(NDIS_TASK_OFFLOAD);
        TaskOffload->Version = NDIS_TASK_OFFLOAD_VERSION;
        TaskOffload->Task = TcpLargeSendNdisTask;
        TaskOffload->TaskBufferLength = sizeof(NDIS_TASK_TCP_LARGE_SEND);
        TaskOffload->OffsetNextTask = 0;
 
        LargeSendTask = (PNDIS_TASK_TCP_LARGE_SEND)TaskOffload->TaskBuffer;
        LargeSendTask->Version = NDIS_TASK_TCP_LARGE_SEND_V0;
        LargeSendTask->MinSegmentCount = NVNET_MINIMUM_LSO_SEGMENT_COUNT;
        LargeSendTask->MaxOffLoadSize = NVNET_MAXIMUM_LSO_FRAME_SIZE;
        LargeSendTask->IpOptions = TRUE;
        LargeSendTask->TcpOptions = TRUE;
    }
    TaskOffload->OffsetNextTask = 0;
 
    *BytesWritten = InfoLength;
    *BytesNeeded = 0;
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportQueryInformation().

NvNetGetWakeUp()

static ULONG NvNetGetWakeUp ( _In_ PNVNET_ADAPTER  Adapter )

static

Definition at line 761 of file requests.c.

{
    return Adapter->WakeFlags & (NDIS_PNP_WAKE_UP_MAGIC_PACKET |
                                 NDIS_PNP_WAKE_UP_PATTERN_MATCH |
                                 NDIS_PNP_WAKE_UP_LINK_CHANGE);
}

Referenced by MiniportQueryInformation().

NvNetPowerWorker()

static VOID NTAPI NvNetPowerWorker ( _In_ PNDIS_WORK_ITEM  WorkItem, _In_opt_ PVOID  Context  )

static

Definition at line 603 of file requests.c.

{
    PNVNET_ADAPTER Adapter = Context;
 
    UNREFERENCED_PARAMETER(WorkItem);
 
    PAGED_CODE();
 
    if (Adapter->PowerStatePending == NdisDeviceStateD0)
    {
        NvNetSetPowerState(Adapter, NdisDeviceStateD0, 0);
 
        NT_VERIFY(NvNetInitNIC(Adapter, TRUE) == NDIS_STATUS_SUCCESS);
 
        NvNetStartAdapter(Adapter);
 
        NvNetApplyPacketFilter(Adapter);
    }
    else
    {
        NvNetPauseProcessing(Adapter);
 
        NvNetStopAdapter(Adapter);
 
        NvNetIdleTransmitter(Adapter, FALSE);
        NvNetStopTransmitter(Adapter);
        NvNetStopReceiver(Adapter);
        NV_WRITE(Adapter, NvRegTxRxControl,
                 Adapter->TxRxControl | NVREG_TXRXCTL_BIT2 | NVREG_TXRXCTL_RESET);
        NdisStallExecution(NV_TXRX_RESET_DELAY);
 
        NvNetFlushTransmitQueue(Adapter, NDIS_STATUS_FAILURE);
 
        NvNetSetPowerState(Adapter, Adapter->PowerStatePending, Adapter->WakeFlags);
    }
 
    NdisMSetInformationComplete(Adapter->AdapterHandle, NDIS_STATUS_SUCCESS);
}

Referenced by NvNetSetPower().

NvNetQueryHwCounter()

static VOID NvNetQueryHwCounter ( _In_ PNVNET_ADAPTER  Adapter, _In_ NDIS_OID  Oid, _Out_ PULONG64  Counter  )

static

Definition at line 258 of file requests.c.

{
    switch (Oid)
    {
        case OID_GEN_XMIT_OK:
            *Counter = (Adapter->Features & DEV_HAS_STATISTICS_V2)
                       ? Adapter->Statistics.HwTxFrame
                       : (Adapter->Statistics.HwTxZeroReXmt +
                          Adapter->Statistics.HwTxOneReXmt +
                          Adapter->Statistics.HwTxManyReXmt);
            break;
        case OID_GEN_RCV_OK:
            *Counter = (Adapter->Statistics.HwRxUnicast +
                        Adapter->Statistics.HwRxMulticast +
                        Adapter->Statistics.HwRxBroadcast);
            break;
        case OID_GEN_XMIT_ERROR:
            *Counter = (Adapter->Statistics.HwTxRetryErr +
                        Adapter->Statistics.HwTxLateCol +
                        Adapter->Statistics.HwTxUnderflow +
                        Adapter->Statistics.HwTxLossCarrier +
                        Adapter->Statistics.HwTxExcessDef);
            break;
        case OID_GEN_RCV_ERROR:
            *Counter = (Adapter->Statistics.HwRxFrameAlignErr +
                        Adapter->Statistics.HwRxLenErr +
                        Adapter->Statistics.HwRxRunt +
                        Adapter->Statistics.HwRxFrameTooLong +
                        Adapter->Statistics.HwRxFCSErr +
                        Adapter->Statistics.HwRxFrameErr +
                        Adapter->Statistics.HwRxExtraByte +
                        Adapter->Statistics.HwRxLateCol);
            break;
        case OID_GEN_RCV_NO_BUFFER:
            *Counter = (Adapter->Statistics.HwRxDropFrame +
                        Adapter->Statistics.HwRxOverflow +
                        Adapter->Statistics.ReceiveIrqNoBuffers);
            break;
        case OID_GEN_DIRECTED_FRAMES_RCV:
            *Counter = Adapter->Statistics.HwRxUnicast;
            break;
        case OID_GEN_RCV_CRC_ERROR:
            *Counter = Adapter->Statistics.HwRxFCSErr;
            break;
        case OID_802_3_RCV_ERROR_ALIGNMENT:
            *Counter = Adapter->Statistics.HwRxFrameErr;
            break;
        case OID_802_3_XMIT_ONE_COLLISION:
            *Counter = Adapter->Statistics.HwTxOneReXmt;
            break;
        case OID_802_3_XMIT_MORE_COLLISIONS:
            *Counter = Adapter->Statistics.HwTxManyReXmt;
            break;
        case OID_802_3_XMIT_DEFERRED:
            *Counter = Adapter->Statistics.HwTxDef;
            break;
        case OID_802_3_XMIT_MAX_COLLISIONS:
            *Counter = Adapter->Statistics.HwTxRetryErr;
            break;
        case OID_802_3_RCV_OVERRUN:
            *Counter = Adapter->Statistics.HwRxOverflow;
            break;
        case OID_802_3_XMIT_UNDERRUN:
            *Counter = Adapter->Statistics.HwTxUnderflow;
            break;
        case OID_802_3_XMIT_HEARTBEAT_FAILURE:
            *Counter = Adapter->Statistics.HwTxZeroReXmt;
            break;
        case OID_802_3_XMIT_TIMES_CRS_LOST:
            *Counter = Adapter->Statistics.HwTxLossCarrier;
            break;
        case OID_802_3_XMIT_LATE_COLLISIONS:
            *Counter = Adapter->Statistics.HwTxLateCol;
            break;
 
        default:
            UNREACHABLE;
            break;
    }
}

Referenced by MiniportQueryInformation().

NvNetQuerySoftwareCounter()

static VOID NvNetQuerySoftwareCounter ( _In_ PNVNET_ADAPTER  Adapter, _In_ NDIS_OID  Oid, _Out_ PULONG64  Counter  )

static

Definition at line 344 of file requests.c.

{
    switch (Oid)
    {
        case OID_GEN_XMIT_OK:
            *Counter = Adapter->Statistics.TransmitOk;
            break;
        case OID_GEN_RCV_OK:
            *Counter = Adapter->Statistics.ReceiveOk;
            break;
        case OID_GEN_XMIT_ERROR:
            *Counter = Adapter->Statistics.TransmitErrors;
            break;
        case OID_GEN_RCV_ERROR:
            *Counter = Adapter->Statistics.ReceiveErrors;
            break;
        case OID_GEN_RCV_NO_BUFFER:
            *Counter = Adapter->Statistics.ReceiveNoBuffers;
            break;
        case OID_GEN_DIRECTED_FRAMES_RCV:
            *Counter = 0;
            break;
        case OID_GEN_RCV_CRC_ERROR:
            *Counter = Adapter->Statistics.ReceiveCrcErrors;
            break;
        case OID_802_3_RCV_ERROR_ALIGNMENT:
            *Counter = Adapter->Statistics.ReceiveAlignmentErrors;
            break;
        case OID_802_3_XMIT_ONE_COLLISION:
            *Counter = Adapter->Statistics.TransmitOneRetry;
            break;
        case OID_802_3_XMIT_MORE_COLLISIONS:
            *Counter = (Adapter->Statistics.TransmitOk -
                        Adapter->Statistics.TransmitOneRetry -
                        Adapter->Statistics.TransmitZeroRetry);
            break;
        case OID_802_3_XMIT_DEFERRED:
            *Counter = Adapter->Statistics.TransmitDeferred;
            break;
        case OID_802_3_XMIT_MAX_COLLISIONS:
            *Counter = Adapter->Statistics.TransmitExcessiveCollisions;
            break;
        case OID_802_3_RCV_OVERRUN:
            *Counter = Adapter->Statistics.ReceiveOverrunErrors;
            break;
        case OID_802_3_XMIT_UNDERRUN:
            *Counter = Adapter->Statistics.TransmitUnderrunErrors;
            break;
        case OID_802_3_XMIT_HEARTBEAT_FAILURE:
            *Counter = Adapter->Statistics.TransmitZeroRetry;
            break;
        case OID_802_3_XMIT_TIMES_CRS_LOST:
            *Counter = Adapter->Statistics.TransmitLostCarrierSense;
            break;
        case OID_802_3_XMIT_LATE_COLLISIONS:
            *Counter = Adapter->Statistics.TransmitLateCollisions;
            break;
 
        default:
            UNREACHABLE;
            break;
    }
}

Referenced by MiniportQueryInformation().

NvNetReadStatistics()

static VOID NvNetReadStatistics ( _In_ PNVNET_ADAPTER  Adapter )

static

Definition at line 213 of file requests.c.

{
    Adapter->Statistics.HwTxCnt += NV_READ(Adapter, NvRegTxCnt);
    Adapter->Statistics.HwTxZeroReXmt += NV_READ(Adapter, NvRegTxZeroReXmt);
    Adapter->Statistics.HwTxOneReXmt += NV_READ(Adapter, NvRegTxOneReXmt);
    Adapter->Statistics.HwTxManyReXmt += NV_READ(Adapter, NvRegTxManyReXmt);
    Adapter->Statistics.HwTxLateCol += NV_READ(Adapter, NvRegTxLateCol);
    Adapter->Statistics.HwTxUnderflow += NV_READ(Adapter, NvRegTxUnderflow);
    Adapter->Statistics.HwTxLossCarrier += NV_READ(Adapter, NvRegTxLossCarrier);
    Adapter->Statistics.HwTxExcessDef += NV_READ(Adapter, NvRegTxExcessDef);
    Adapter->Statistics.HwTxRetryErr += NV_READ(Adapter, NvRegTxRetryErr);
    Adapter->Statistics.HwRxFrameErr += NV_READ(Adapter, NvRegRxFrameErr);
    Adapter->Statistics.HwRxExtraByte += NV_READ(Adapter, NvRegRxExtraByte);
    Adapter->Statistics.HwRxLateCol += NV_READ(Adapter, NvRegRxLateCol);
    Adapter->Statistics.HwRxRunt += NV_READ(Adapter, NvRegRxRunt);
    Adapter->Statistics.HwRxFrameTooLong += NV_READ(Adapter, NvRegRxFrameTooLong);
    Adapter->Statistics.HwRxOverflow += NV_READ(Adapter, NvRegRxOverflow);
    Adapter->Statistics.HwRxFCSErr += NV_READ(Adapter, NvRegRxFCSErr);
    Adapter->Statistics.HwRxFrameAlignErr += NV_READ(Adapter, NvRegRxFrameAlignErr);
    Adapter->Statistics.HwRxLenErr += NV_READ(Adapter, NvRegRxLenErr);
    Adapter->Statistics.HwRxUnicast += NV_READ(Adapter, NvRegRxUnicast);
    Adapter->Statistics.HwRxMulticast += NV_READ(Adapter, NvRegRxMulticast);
    Adapter->Statistics.HwRxBroadcast += NV_READ(Adapter, NvRegRxBroadcast);
 
    if (Adapter->Features & DEV_HAS_STATISTICS_V2)
    {
        Adapter->Statistics.HwTxDef += NV_READ(Adapter, NvRegTxDef);
        Adapter->Statistics.HwTxFrame += NV_READ(Adapter, NvRegTxFrame);
        Adapter->Statistics.HwRxCnt += NV_READ(Adapter, NvRegRxCnt);
        Adapter->Statistics.HwTxPause += NV_READ(Adapter, NvRegTxPause);
        Adapter->Statistics.HwRxPause += NV_READ(Adapter, NvRegRxPause);
        Adapter->Statistics.HwRxDropFrame += NV_READ(Adapter, NvRegRxDropFrame);
    }
 
    if (Adapter->Features & DEV_HAS_STATISTICS_V3)
    {
        Adapter->Statistics.HwTxUnicast += NV_READ(Adapter, NvRegTxUnicast);
        Adapter->Statistics.HwTxMulticast += NV_READ(Adapter, NvRegTxMulticast);
        Adapter->Statistics.HwTxBroadcast += NV_READ(Adapter, NvRegTxBroadcast);
    }
}

Referenced by MiniportQueryInformation().

NvNetRemoveWakeUpPattern()

static NDIS_STATUS NvNetRemoveWakeUpPattern ( _In_ PNVNET_ADAPTER  Adapter, _In_ PNDIS_PM_PACKET_PATTERN  Pattern  )

static

Definition at line 721 of file requests.c.

{
    ULONG i;
 
    for (i = 0; i < RTL_NUMBER_OF(Adapter->WakeFrames); ++i)
    {
        PNVNET_WAKE_FRAME WakeFrame = Adapter->WakeFrames[i];
 
        if (!WakeFrame)
            continue;
 
        if (!NdisEqualMemory(&WakeFrame->PatternMask,
                             (PUCHAR)Pattern + sizeof(NDIS_PM_PACKET_PATTERN),
                             min(Pattern->MaskSize, 16)))
        {
            continue;
        }
 
        if (!NdisEqualMemory(&WakeFrame->WakeUpPattern,
                             (PUCHAR)Pattern + Pattern->PatternOffset,
                             min(Pattern->PatternSize, 128)))
        {
            continue;
        }
 
        NdisFreeMemory(WakeFrame, sizeof(*WakeFrame), 0);
 
        Adapter->WakeFrameBitmap |= (1 << i);
        Adapter->WakeFrames[i] = NULL;
 
        return NDIS_STATUS_SUCCESS;
    }
 
    return NDIS_STATUS_INVALID_DATA;
}

Referenced by MiniportSetInformation().

NvNetSetPower()

static NDIS_STATUS NvNetSetPower ( _In_ PNVNET_ADAPTER  Adapter, _In_ NDIS_DEVICE_POWER_STATE  NewPowerState  )

static

Definition at line 646 of file requests.c.

{
    Adapter->PowerStatePending = NewPowerState;
 
    NdisInitializeWorkItem(&Adapter->PowerWorkItem, NvNetPowerWorker, Adapter);
    NdisScheduleWorkItem(&Adapter->PowerWorkItem);
 
    return NDIS_STATUS_PENDING;
}

Referenced by MiniportSetInformation().

NvNetSetPowerState()

VOID NvNetSetPowerState	(	_In_ PNVNET_ADAPTER	Adapter,
		_In_ NDIS_DEVICE_POWER_STATE	NewPowerState,
		_In_ ULONG	WakeFlags
	)

Definition at line 500 of file requests.c.

{
    ULONG i, PowerState, PowerState2, WakeUpFlags;
 
    NV_READ(Adapter, NvRegPowerCap);
 
    WakeUpFlags = 0;
    PowerState2 = 0;
    if (Adapter->Features & DEV_HAS_POWER_CNTRL)
    {
        PowerState2 = NV_READ(Adapter, NvRegPowerState2);
        PowerState2 &= ~(NVREG_POWERSTATE2_WAKEUPPAT_5 |
                         NVREG_POWERSTATE2_WAKEUPPAT_6 |
                         NVREG_POWERSTATE2_WAKEUPPAT_7);
    }
 
    if (NewPowerState != NdisDeviceStateD0)
    {
        ULONG FramesEnabled = 0;
 
        if (WakeFlags & NDIS_PNP_WAKE_UP_PATTERN_MATCH)
            WakeUpFlags |= NVREG_WAKEUPFLAGS_ENABLE_MAGPAT;
        if (WakeFlags & NDIS_PNP_WAKE_UP_LINK_CHANGE)
            WakeUpFlags |= NVREG_WAKEUPFLAGS_ENABLE_LINKCHANGE;
        if (WakeFlags & NDIS_PNP_WAKE_UP_MAGIC_PACKET)
        {
            WakeUpFlags |= NVREG_WAKEUPFLAGS_ENABLE_WAKEUPPAT;
 
            for (i = 0; i < RTL_NUMBER_OF(Adapter->WakeFrames); ++i)
            {
                PNVNET_WAKE_FRAME WakeFrame = Adapter->WakeFrames[i];
 
                if (!WakeFrame)
                    continue;
 
                WriteWakeFrame(Adapter, WakeFrame, i);
 
                PowerState2 |= FrameNumberToPowerMask(i);
                WakeUpFlags |= FrameNumberToWakeUpMask(i);
 
                ++FramesEnabled;
            }
        }
 
        if (WakeUpFlags)
        {
            if (!(Adapter->Flags & NV_MAC_IN_USE))
            {
                PowerState2 &= ~NVREG_POWERSTATE2_GATE_CLOCKS;
                PowerState2 |= NVREG_POWERSTATE2_GATE_CLOCK_3;
 
                if (!FramesEnabled && (WakeUpFlags & NVREG_WAKEUPFLAGS_ENABLE_LINKCHANGE))
                    PowerState2 |= NVREG_POWERSTATE2_GATE_CLOCK_1;
                if (FramesEnabled < NV_WAKEUPMASKENTRIES)
                    PowerState2 |= NVREG_POWERSTATE2_GATE_CLOCK_2;
            }
 
            NvNetStartReceiver(Adapter);
        }
        else
        {
            if (!(Adapter->Flags & NV_MAC_IN_USE))
                PowerState2 |= NVREG_POWERSTATE2_GATE_CLOCKS;
        }
    }
 
    NdisStallExecution(NV_POWER_STALL);
 
    NV_WRITE(Adapter, NvRegWakeUpFlags, WakeUpFlags);
    if (Adapter->Features & DEV_HAS_POWER_CNTRL)
    {
        NV_WRITE(Adapter, NvRegPowerState2, PowerState2);
    }
 
    NV_WRITE(Adapter, NvRegPowerState,
             NV_READ(Adapter, NvRegPowerState) | NVREG_POWERSTATE_POWEREDUP);
    for (i = 0; i < NV_POWER_ATTEMPTS; ++i)
    {
        ULONG State = NV_READ(Adapter, NvRegPowerState);
 
        if (!(State & NVREG_POWERSTATE_POWEREDUP))
            break;
 
        NV_WRITE(Adapter, NvRegPowerState, State | NVREG_POWERSTATE_POWEREDUP);
 
        NdisStallExecution(NV_POWER_DELAY);
    }
 
    PowerState = NewPowerState - 1;
    if (WakeUpFlags)
    {
        PowerState |= NVREG_POWERSTATE_VALID;
    }
    NV_WRITE(Adapter, NvRegPowerState, PowerState);
}

Referenced by MiniportShutdown(), and NvNetPowerWorker().

NvNetSetTcpTaskOffload()

static NDIS_STATUS NvNetSetTcpTaskOffload ( _Inout_ PNVNET_ADAPTER  Adapter, _In_ PNDIS_TASK_OFFLOAD_HEADER  TaskOffloadHeader, _In_ PULONG  BytesRead  )

static

Definition at line 888 of file requests.c.

{
    ULONG Offset;
    PNDIS_TASK_OFFLOAD TaskOffload;
 
    if (TaskOffloadHeader->Version != NDIS_TASK_OFFLOAD_VERSION)
    {
        return NDIS_STATUS_NOT_SUPPORTED;
    }
 
    Adapter->IpHeaderOffset = TaskOffloadHeader->EncapsulationFormat.EncapsulationHeaderSize;
 
    TaskOffload = (PNDIS_TASK_OFFLOAD)TaskOffloadHeader;
    Offset = TaskOffloadHeader->OffsetFirstTask;
 
    while (Offset)
    {
        *BytesRead += FIELD_OFFSET(NDIS_TASK_OFFLOAD, TaskBuffer);
 
        TaskOffload = (PNDIS_TASK_OFFLOAD)((PUCHAR)TaskOffload + Offset);
        switch (TaskOffload->Task)
        {
            case TcpIpChecksumNdisTask:
            {
                PNDIS_TASK_TCP_IP_CHECKSUM Task;
 
                *BytesRead += sizeof(NDIS_TASK_TCP_IP_CHECKSUM);
 
                if (!(Adapter->Flags & NV_SEND_CHECKSUM))
                {
                    return NDIS_STATUS_NOT_SUPPORTED;
                }
 
                Task = (PNDIS_TASK_TCP_IP_CHECKSUM)TaskOffload->TaskBuffer;
 
                Adapter->Offload.SendTcpChecksum = Task->V4Transmit.TcpChecksum;
                Adapter->Offload.SendUdpChecksum = Task->V4Transmit.UdpChecksum;
                Adapter->Offload.SendIpChecksum = Task->V4Transmit.IpChecksum;
 
                Adapter->Offload.ReceiveTcpChecksum = Task->V4Receive.TcpChecksum;
                Adapter->Offload.ReceiveUdpChecksum = Task->V4Receive.UdpChecksum;
                Adapter->Offload.ReceiveIpChecksum = Task->V4Receive.IpChecksum;
                break;
            }
 
            case TcpLargeSendNdisTask:
            {
                PNDIS_TASK_TCP_LARGE_SEND Task;
 
                if (!(Adapter->Flags & NV_SEND_LARGE_SEND))
                {
                    return NDIS_STATUS_NOT_SUPPORTED;
                }
 
                if ((TaskOffloadHeader->
                     EncapsulationFormat.Encapsulation != IEEE_802_3_Encapsulation) &&
                    (TaskOffloadHeader->
                     EncapsulationFormat.Encapsulation != UNSPECIFIED_Encapsulation ||
                     TaskOffloadHeader->
                     EncapsulationFormat.EncapsulationHeaderSize != sizeof(ETH_HEADER)))
                {
                    return NDIS_STATUS_NOT_SUPPORTED;
                }
 
                *BytesRead += sizeof(NDIS_TASK_TCP_LARGE_SEND);
 
                Task = (PNDIS_TASK_TCP_LARGE_SEND)TaskOffload->TaskBuffer;
 
                if (Task->MinSegmentCount != NVNET_MINIMUM_LSO_SEGMENT_COUNT)
                    return NDIS_STATUS_NOT_SUPPORTED;
 
                if (Task->MaxOffLoadSize > NVNET_MAXIMUM_LSO_FRAME_SIZE)
                    return NDIS_STATUS_NOT_SUPPORTED;
 
                /* Nothing to do */
                break;
            }
 
            default:
                break;
        }
 
        Offset = TaskOffload->OffsetNextTask;
    }
 
    NdisAcquireSpinLock(&Adapter->Send.Lock);
 
    if (Adapter->Offload.ReceiveTcpChecksum ||
        Adapter->Offload.ReceiveUdpChecksum ||
        Adapter->Offload.ReceiveIpChecksum)
    {
        Adapter->TxRxControl |= NVREG_TXRXCTL_RXCHECK;
    }
    else
    {
        Adapter->TxRxControl &= ~NVREG_TXRXCTL_RXCHECK;
    }
    NV_WRITE(Adapter, NvRegTxRxControl, Adapter->TxRxControl);
 
    NdisReleaseSpinLock(&Adapter->Send.Lock);
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportSetInformation().

PacketFilterToMask()

static ULONG PacketFilterToMask ( _In_ ULONG  PacketFilter )

static

Definition at line 109 of file requests.c.

{
    ULONG FilterMask = NVREG_PFF_ALWAYS | NVREG_PFF_MYADDR | NVREG_PFF_PROMISC;
 
    if (PacketFilter & NDIS_PACKET_TYPE_PROMISCUOUS)
    {
        FilterMask &= ~NVREG_PFF_MYADDR;
    }
 
    if (PacketFilter & NDIS_PACKET_TYPE_BROADCAST)
    {
        FilterMask &= ~NVREG_PFF_PROMISC;
    }
 
    return FilterMask;
}

Referenced by NvNetApplyPacketFilter().

WriteWakeFrame()

static VOID WriteWakeFrame ( _In_ PNVNET_ADAPTER  Adapter, _In_ PNVNET_WAKE_FRAME  WakeFrame, _In_ ULONG  FrameNumber  )

static

Definition at line 450 of file requests.c.

{
    ULONG Offset = FrameNumber * 5 * sizeof(ULONG);
 
    if (FrameNumber >= NV_WAKEUPPATTERNS)
    {
        Offset += NV_PATTERN_V2_OFFSET;
    }
 
    NV_WRITE(Adapter, NvRegPatternCrc + Offset, BuildFrameSignature(WakeFrame));
    NV_WRITE(Adapter, NvRegPatternMask0 + Offset, WakeFrame->PatternMask.AsULONG[0]);
    NV_WRITE(Adapter, NvRegPatternMask1 + Offset, WakeFrame->PatternMask.AsULONG[1]);
    NV_WRITE(Adapter, NvRegPatternMask2 + Offset, WakeFrame->PatternMask.AsULONG[2]);
    NV_WRITE(Adapter, NvRegPatternMask3 + Offset, WakeFrame->PatternMask.AsULONG[3]);
}

Referenced by NvNetSetPowerState().

Variable Documentation

NvpSupportedOidList

const NDIS_OID NvpSupportedOidList[]

static

Definition at line 17 of file requests.c.

Referenced by MiniportQueryInformation().