ReactOS 0.4.16-dev-1223-gddcd5f7
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
 

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 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.

Function Documentation

◆ BuildFrameSignature()

static ULONG BuildFrameSignature ( _In_ PNVNET_WAKE_FRAME  WakeFrame)
static

Definition at line 428 of file requests.c.

430{
431 ULONG i, j, Crc;
432
433 Crc = 0xFFFFFFFF;
434 for (i = 0; i < sizeof(WakeFrame->WakeUpPattern); ++i)
435 {
436 if (WakeFrame->PatternMask.AsUCHAR[i / 8] & (1 << (i % 8)))
437 {
438 Crc ^= WakeFrame->WakeUpPattern[i];
439 for (j = 8; j > 0; --j)
440 {
441 Crc = (Crc >> 1) ^ (-(LONG)(Crc & 1) & 0xEDB88320);
442 }
443 }
444 }
445
446 return ~Crc;
447}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
long LONG
Definition: pedump.c:60
uint32_t ULONG
Definition: typedefs.h:59

Referenced by WriteWakeFrame().

◆ FrameNumberToPowerMask()

static ULONG FrameNumberToPowerMask ( _In_ ULONG  FrameNumber)
static

Definition at line 483 of file requests.c.

485{
486 switch (FrameNumber)
487 {
488 case 5:
490 case 6:
492 case 7:
494
495 default:
496 return 0;
497 }
498}
#define NVREG_POWERSTATE2_WAKEUPPAT_6
Definition: nic.h:343
#define NVREG_POWERSTATE2_WAKEUPPAT_5
Definition: nic.h:342
#define NVREG_POWERSTATE2_WAKEUPPAT_7
Definition: nic.h:344

Referenced by NvNetSetPowerState().

◆ FrameNumberToWakeUpMask()

static ULONG FrameNumberToWakeUpMask ( _In_ ULONG  FrameNumber)
static

Definition at line 472 of file requests.c.

474{
475 if (FrameNumber < 5)
476 return 0x10000 << FrameNumber;
477 else
478 return 0;
479}

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 974 of file requests.c.

981{
982 PNVNET_ADAPTER Adapter = (PNVNET_ADAPTER)MiniportAdapterContext;
984 ULONG InfoLength;
985 PVOID InfoPtr;
986 union _GENERIC_INFORMATION
987 {
989 ULONG Ulong;
990 ULONG64 Ulong64;
991 NDIS_MEDIUM Medium;
994 } GenericInfo;
995
996 InfoLength = sizeof(ULONG);
997 InfoPtr = &GenericInfo;
998
999 switch (Oid)
1000 {
1002 InfoPtr = (PVOID)&NvpSupportedOidList;
1003 InfoLength = sizeof(NvpSupportedOidList);
1004 break;
1005
1007 InfoLength = sizeof(NDIS_HARDWARE_STATUS);
1008 GenericInfo.Status = NdisHardwareStatusReady;
1009 break;
1010
1013 {
1014 InfoLength = sizeof(NDIS_MEDIUM);
1015 GenericInfo.Medium = NdisMedium802_3;
1016 break;
1017 }
1018
1021 {
1022 GenericInfo.Ulong = Adapter->MaximumFrameSize - sizeof(ETH_HEADER);
1023 break;
1024 }
1025
1027 {
1028 GenericInfo.Ulong = Adapter->MaximumFrameSize;
1029 break;
1030 }
1031
1032 case OID_GEN_LINK_SPEED:
1033 {
1034 GenericInfo.Ulong = NvNetGetLinkSpeed(Adapter) * 10000;
1035 break;
1036 }
1037
1039 {
1040 /* TODO: Change this later, once the driver can handle multipacket sends */
1041 GenericInfo.Ulong = Adapter->MaximumFrameSize;
1042 break;
1043 }
1044
1046 {
1047 GenericInfo.Ulong = Adapter->MaximumFrameSize * NVNET_RECEIVE_DESCRIPTORS;
1048 }
1049
1053 {
1054 GenericInfo.Ulong = Adapter->MaximumFrameSize;
1055 break;
1056 }
1057
1058 case OID_GEN_VENDOR_ID:
1059 {
1060 GenericInfo.Ulong = 0;
1061 GenericInfo.Ulong |= (Adapter->PermanentMacAddress[0] << 16);
1062 GenericInfo.Ulong |= (Adapter->PermanentMacAddress[1] << 8);
1063 GenericInfo.Ulong |= (Adapter->PermanentMacAddress[2] & 0xFF);
1064 break;
1065 }
1066
1068 {
1069 InfoLength = sizeof(USHORT);
1070 GenericInfo.Ushort = (NDIS_MINIPORT_MAJOR_VERSION << 8) | NDIS_MINIPORT_MINOR_VERSION;
1071 break;
1072 }
1073
1075 {
1076 static const CHAR VendorDesc[] = "nVidia nForce Ethernet Controller";
1077 InfoPtr = (PVOID)&VendorDesc;
1078 InfoLength = sizeof(VendorDesc);
1079 break;
1080 }
1081
1083 {
1084 GenericInfo.Ulong = Adapter->PacketFilter;
1085 break;
1086 }
1087
1089 {
1090 GenericInfo.Ulong = NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
1093
1094 if (Adapter->Flags & NV_PACKET_PRIORITY)
1095 GenericInfo.Ulong |= NDIS_MAC_OPTION_8021P_PRIORITY;
1096 if (Adapter->Flags & NV_VLAN_TAGGING)
1097 GenericInfo.Ulong |= NDIS_MAC_OPTION_8021Q_VLAN;
1098 break;
1099 }
1100
1102 {
1103 GenericInfo.Ulong = Adapter->Connected ? NdisMediaStateConnected
1105 break;
1106 }
1107
1109 {
1110 /* TODO: Multipacket sends */
1111 GenericInfo.Ulong = 1;
1112 break;
1113 }
1114
1116 {
1117 /* 1.0.0 */
1118 GenericInfo.Ulong = 0x100;
1119 break;
1120 }
1121
1122 case OID_GEN_XMIT_OK:
1123 case OID_GEN_RCV_OK:
1124 case OID_GEN_XMIT_ERROR:
1125 case OID_GEN_RCV_ERROR:
1139 {
1141 {
1142 NvNetReadStatistics(Adapter);
1143 NvNetQueryHwCounter(Adapter, Oid, &GenericInfo.Ulong64);
1144 }
1145 else
1146 {
1147 NvNetQuerySoftwareCounter(Adapter, Oid, &GenericInfo.Ulong64);
1148 }
1149
1150 *BytesNeeded = sizeof(ULONG64);
1151 if (InformationBufferLength < sizeof(ULONG))
1152 {
1153 *BytesWritten = 0;
1155 }
1156 if (InformationBufferLength >= sizeof(ULONG64))
1157 {
1158 *BytesWritten = sizeof(ULONG64);
1159 NdisMoveMemory(InformationBuffer, InfoPtr, sizeof(ULONG64));
1160 }
1161 else
1162 {
1163 *BytesWritten = sizeof(ULONG);
1164 NdisMoveMemory(InformationBuffer, InfoPtr, sizeof(ULONG));
1165 }
1166
1167 return NDIS_STATUS_SUCCESS;
1168 }
1169
1171 {
1172 GenericInfo.Ulong = NVNET_TRANSMIT_BLOCKS - Adapter->Send.TcbSlots;
1173 break;
1174 }
1175
1177 {
1178 InfoPtr = Adapter->PermanentMacAddress;
1179 InfoLength = ETH_LENGTH_OF_ADDRESS;
1180 break;
1181 }
1182
1184 {
1185 InfoPtr = Adapter->CurrentMacAddress;
1186 InfoLength = ETH_LENGTH_OF_ADDRESS;
1187 break;
1188 }
1189
1191 {
1192 InfoPtr = Adapter->MulticastList;
1193 InfoLength = Adapter->MulticastListSize * ETH_LENGTH_OF_ADDRESS;
1194 break;
1195 }
1196
1198 {
1199 GenericInfo.Ulong = NVNET_MULTICAST_LIST_SIZE;
1200 break;
1201 }
1202
1204 {
1205 GenericInfo.Ulong = NdisPhysicalMedium802_3;
1206 break;
1207 }
1208
1210 {
1211 return NvNetGetTcpTaskOffload(Adapter,
1212 InformationBuffer,
1213 InformationBufferLength,
1215 BytesWritten);
1216 }
1217
1219 {
1220 GenericInfo.Ulong = NvNetGetWakeUp(Adapter);
1221 break;
1222 }
1223
1225 {
1226 InfoLength = sizeof(NDIS_PNP_CAPABILITIES);
1227
1228 if (InformationBufferLength < InfoLength)
1229 {
1230 *BytesWritten = 0;
1231 *BytesNeeded = InfoLength;
1233 }
1234
1235 *BytesWritten = InfoLength;
1236 *BytesNeeded = 0;
1237 return NvNetFillPowerManagementCapabilities(Adapter, InformationBuffer);
1238 }
1239
1241 {
1242 return NDIS_STATUS_SUCCESS;
1243 }
1244
1245 case OID_GEN_VLAN_ID:
1246 {
1247 /* TODO: Implement software VLAN support */
1248 if (!(Adapter->Flags & NV_VLAN_TAGGING))
1249 {
1251 break;
1252 }
1253
1254 GenericInfo.Ulong = Adapter->VlanId;
1255 break;
1256 }
1257
1258 default:
1260 break;
1261 }
1262
1264 {
1265 if (InfoLength > InformationBufferLength)
1266 {
1267 *BytesWritten = 0;
1268 *BytesNeeded = InfoLength;
1270 }
1271 else
1272 {
1273 NdisMoveMemory(InformationBuffer, InfoPtr, InfoLength);
1274 *BytesWritten = InfoLength;
1275 *BytesNeeded = 0;
1276 }
1277 }
1278 else
1279 {
1280 *BytesWritten = 0;
1281 *BytesNeeded = 0;
1282 }
1283
1284 return Status;
1285}
#define ETH_LENGTH_OF_ADDRESS
Definition: efilter.h:16
Status
Definition: gdiplustypes.h:25
unsigned __int64 ULONG64
Definition: imports.h:198
#define NDIS_STATUS_NOT_SUPPORTED
Definition: ndis.h:479
#define NDIS_MAC_OPTION_TRANSFERS_NOT_PEND
Definition: ndis.h:684
#define NDIS_STATUS_INVALID_OID
Definition: ndis.h:488
#define NDIS_STATUS_SUCCESS
Definition: ndis.h:346
#define NDIS_STATUS_BUFFER_TOO_SHORT
Definition: ndis.h:487
#define NDIS_MAC_OPTION_NO_LOOPBACK
Definition: ndis.h:685
#define NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA
Definition: ndis.h:682
#define NDIS_MAC_OPTION_8021P_PRIORITY
Definition: ndis.h:688
#define NdisMoveMemory(Destination, Source, Length)
Definition: ndis.h:3896
enum _NDIS_MEDIUM NDIS_MEDIUM
#define OID_GEN_TRANSMIT_BLOCK_SIZE
Definition: ntddndis.h:242
#define OID_GEN_XMIT_OK
Definition: ntddndis.h:267
#define OID_GEN_MAXIMUM_TOTAL_SIZE
Definition: ntddndis.h:249
#define OID_GEN_XMIT_ERROR
Definition: ntddndis.h:269
#define OID_GEN_VENDOR_DRIVER_VERSION
Definition: ntddndis.h:254
@ NdisPhysicalMedium802_3
Definition: ntddndis.h:221
#define OID_802_3_PERMANENT_ADDRESS
Definition: ntddndis.h:302
#define OID_GEN_LINK_SPEED
Definition: ntddndis.h:239
#define OID_GEN_VENDOR_ID
Definition: ntddndis.h:244
#define OID_802_3_RCV_OVERRUN
Definition: ntddndis.h:312
#define OID_GEN_CURRENT_PACKET_FILTER
Definition: ntddndis.h:246
@ NdisMediaStateConnected
Definition: ntddndis.h:470
@ NdisMediaStateDisconnected
Definition: ntddndis.h:471
#define OID_GEN_RCV_NO_BUFFER
Definition: ntddndis.h:271
#define OID_802_3_XMIT_HEARTBEAT_FAILURE
Definition: ntddndis.h:314
#define OID_GEN_PHYSICAL_MEDIUM
Definition: ntddndis.h:264
enum _NDIS_DEVICE_POWER_STATE NDIS_DEVICE_POWER_STATE
#define OID_802_3_XMIT_ONE_COLLISION
Definition: ntddndis.h:308
#define OID_802_3_XMIT_MORE_COLLISIONS
Definition: ntddndis.h:309
#define OID_802_3_XMIT_MAX_COLLISIONS
Definition: ntddndis.h:311
#define OID_GEN_RECEIVE_BUFFER_SPACE
Definition: ntddndis.h:241
#define OID_802_3_XMIT_TIMES_CRS_LOST
Definition: ntddndis.h:315
#define OID_802_3_MAXIMUM_LIST_SIZE
Definition: ntddndis.h:305
#define OID_GEN_DRIVER_VERSION
Definition: ntddndis.h:248
#define OID_802_3_XMIT_UNDERRUN
Definition: ntddndis.h:313
#define OID_802_3_XMIT_LATE_COLLISIONS
Definition: ntddndis.h:316
#define OID_802_3_CURRENT_ADDRESS
Definition: ntddndis.h:303
#define OID_802_3_MULTICAST_LIST
Definition: ntddndis.h:304
struct _NDIS_PNP_CAPABILITIES NDIS_PNP_CAPABILITIES
#define OID_GEN_DIRECTED_FRAMES_RCV
Definition: ntddndis.h:281
#define OID_PNP_ENABLE_WAKE_UP
Definition: ntddndis.h:366
#define OID_GEN_TRANSMIT_BUFFER_SPACE
Definition: ntddndis.h:240
#define OID_GEN_MEDIA_SUPPORTED
Definition: ntddndis.h:235
@ NdisMedium802_3
Definition: ntddndis.h:188
#define OID_GEN_MAXIMUM_FRAME_SIZE
Definition: ntddndis.h:238
#define OID_GEN_RCV_CRC_ERROR
Definition: ntddndis.h:286
#define NDIS_MAC_OPTION_8021Q_VLAN
Definition: ntddndis.h:440
#define OID_GEN_MEDIA_IN_USE
Definition: ntddndis.h:236
#define OID_GEN_MEDIA_CONNECT_STATUS
Definition: ntddndis.h:252
#define OID_GEN_RCV_OK
Definition: ntddndis.h:268
#define OID_GEN_MAXIMUM_LOOKAHEAD
Definition: ntddndis.h:237
#define OID_802_3_RCV_ERROR_ALIGNMENT
Definition: ntddndis.h:307
#define OID_GEN_VLAN_ID
Definition: ntddndis.h:260
int NDIS_STATUS
Definition: ntddndis.h:475
#define OID_PNP_QUERY_POWER
Definition: ntddndis.h:362
#define OID_GEN_RCV_ERROR
Definition: ntddndis.h:270
@ NdisHardwareStatusReady
Definition: ntddndis.h:450
#define OID_PNP_CAPABILITIES
Definition: ntddndis.h:360
#define OID_TCP_TASK_OFFLOAD
Definition: ntddndis.h:377
#define OID_GEN_CURRENT_LOOKAHEAD
Definition: ntddndis.h:247
#define OID_GEN_MAC_OPTIONS
Definition: ntddndis.h:251
#define OID_GEN_VENDOR_DESCRIPTION
Definition: ntddndis.h:245
#define OID_GEN_SUPPORTED_LIST
Definition: ntddndis.h:233
#define OID_802_3_XMIT_DEFERRED
Definition: ntddndis.h:310
#define OID_GEN_RECEIVE_BLOCK_SIZE
Definition: ntddndis.h:243
#define OID_GEN_MAXIMUM_SEND_PACKETS
Definition: ntddndis.h:253
#define OID_GEN_TRANSMIT_QUEUE_LENGTH
Definition: ntddndis.h:287
#define OID_GEN_HARDWARE_STATUS
Definition: ntddndis.h:234
enum _NDIS_HARDWARE_STATUS NDIS_HARDWARE_STATUS
#define DEV_HAS_STATISTICS_COUNTERS
Definition: nic.h:44
static ULONG NvNetGetWakeUp(_In_ PNVNET_ADAPTER Adapter)
Definition: requests.c:738
static VOID NvNetQuerySoftwareCounter(_In_ PNVNET_ADAPTER Adapter, _In_ NDIS_OID Oid, _Out_ PULONG64 Counter)
Definition: requests.c:345
static VOID NvNetReadStatistics(_In_ PNVNET_ADAPTER Adapter)
Definition: requests.c:214
static VOID NvNetQueryHwCounter(_In_ PNVNET_ADAPTER Adapter, _In_ NDIS_OID Oid, _Out_ PULONG64 Counter)
Definition: requests.c:259
static NDIS_STATUS NvNetGetTcpTaskOffload(_In_ PNVNET_ADAPTER Adapter, _In_ PNDIS_TASK_OFFLOAD_HEADER TaskOffloadHeader, _In_ ULONG InformationBufferLength, _Out_ PULONG BytesWritten, _Out_ PULONG BytesNeeded)
Definition: requests.c:757
static NDIS_STATUS NvNetFillPowerManagementCapabilities(_In_ PNVNET_ADAPTER Adapter, _Out_ PNDIS_PNP_CAPABILITIES Capabilities)
Definition: requests.c:414
static ULONG NvNetGetLinkSpeed(_In_ PNVNET_ADAPTER Adapter)
Definition: requests.c:83
static const NDIS_OID NvpSupportedOidList[]
Definition: requests.c:17
#define NVNET_RECEIVE_DESCRIPTORS
Definition: nvnet.h:34
#define NVNET_MULTICAST_LIST_SIZE
Definition: nvnet.h:64
#define NVNET_TRANSMIT_BLOCKS
Definition: nvnet.h:31
#define NV_PACKET_PRIORITY
Definition: nvnet.h:298
#define NV_VLAN_TAGGING
Definition: nvnet.h:299
struct _NVNET_ADAPTER * PNVNET_ADAPTER
Definition: nvnet.h:259
unsigned short USHORT
Definition: pedump.c:61
Definition: lan.h:33
UCHAR PermanentMacAddress[ETH_LENGTH_OF_ADDRESS]
Definition: nvnet.h:338
ULONG MaximumFrameSize
Definition: nvnet.h:321
BOOLEAN Connected
Definition: nvnet.h:334
ULONG Features
Definition: nvnet.h:284
ULONG PacketFilter
Definition: nvnet.h:309
ULONG Flags
Definition: nvnet.h:285
ULONG VlanId
Definition: nvnet.h:323
struct _NVNET_ADAPTER::@1058 MulticastList[NVNET_MULTICAST_LIST_SIZE]
NVNET_SEND Send
Definition: nvnet.h:310
UCHAR CurrentMacAddress[ETH_LENGTH_OF_ADDRESS]
Definition: nvnet.h:339
ULONG TcbSlots
Definition: nvnet.h:246
void * PVOID
Definition: typedefs.h:50
unsigned short Ushort
Definition: utypes.h:44
unsigned long Ulong
Definition: utypes.h:42
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_ WDF_DEVICE_POWER_STATE PowerState
Definition: wdfdevice.h:3034
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PLONGLONG _In_opt_ PWDF_REQUEST_SEND_OPTIONS _Out_opt_ PULONG_PTR BytesWritten
Definition: wdfiotarget.h:960
char CHAR
Definition: xmlstorage.h:175

◆ 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 1289 of file requests.c.

1296{
1297 PNVNET_ADAPTER Adapter = (PNVNET_ADAPTER)MiniportAdapterContext;
1299 ULONG GenericUlong;
1300
1301 *BytesRead = 0;
1302 *BytesNeeded = 0;
1303
1304 switch (Oid)
1305 {
1307 {
1308 if (InformationBufferLength % ETH_LENGTH_OF_ADDRESS)
1309 {
1310 *BytesNeeded = (InformationBufferLength / ETH_LENGTH_OF_ADDRESS) *
1313 break;
1314 }
1315
1316 if (InformationBufferLength > sizeof(Adapter->MulticastList))
1317 {
1318 *BytesNeeded = sizeof(Adapter->MulticastList);
1320 break;
1321 }
1322
1323 *BytesRead = InformationBufferLength;
1324 NdisMoveMemory(Adapter->MulticastList, InformationBuffer, InformationBufferLength);
1325
1326 Adapter->MulticastListSize = InformationBufferLength / ETH_LENGTH_OF_ADDRESS;
1327
1328 NvNetApplyPacketFilter(Adapter);
1329 break;
1330 }
1331
1333 {
1334 if (InformationBufferLength < sizeof(ULONG))
1335 {
1336 *BytesNeeded = sizeof(ULONG);
1338 break;
1339 }
1340
1341 *BytesRead = sizeof(ULONG);
1342 NdisMoveMemory(&GenericUlong, InformationBuffer, sizeof(ULONG));
1343
1344 if (GenericUlong & ~NVNET_PACKET_FILTERS)
1345 {
1347 break;
1348 }
1349
1350 /* Do not check to see if the filter is the same filter */
1351 Adapter->PacketFilter = GenericUlong;
1352
1353 NvNetApplyPacketFilter(Adapter);
1354 break;
1355 }
1356
1358 {
1359 if (InformationBufferLength < sizeof(ULONG))
1360 {
1361 *BytesNeeded = sizeof(ULONG);
1363 break;
1364 }
1365
1366 /* Nothing to do */
1367 *BytesRead = sizeof(ULONG);
1368 break;
1369 }
1370
1371 case OID_GEN_VLAN_ID:
1372 {
1373 if (InformationBufferLength < sizeof(ULONG))
1374 {
1375 *BytesNeeded = sizeof(ULONG);
1377 break;
1378 }
1379
1380 if (!(Adapter->Flags & NV_VLAN_TAGGING))
1381 {
1383 break;
1384 }
1385
1386 *BytesRead = sizeof(ULONG);
1387 NdisMoveMemory(&GenericUlong, InformationBuffer, sizeof(ULONG));
1388
1389 if (GenericUlong > NVNET_MAXIMUM_VLAN_ID)
1390 {
1392 break;
1393 }
1394
1395 Adapter->VlanId = GenericUlong;
1396 break;
1397 }
1398
1400 {
1401 if (InformationBufferLength < sizeof(NDIS_TASK_OFFLOAD_HEADER))
1402 {
1403 *BytesNeeded = sizeof(NDIS_TASK_OFFLOAD_HEADER);
1405 break;
1406 }
1407
1408 *BytesRead = InformationBufferLength;
1409
1410 Status = NvNetSetTcpTaskOffload(Adapter, InformationBuffer, BytesRead);
1411 break;
1412 }
1413
1415 {
1416 if (InformationBufferLength < sizeof(NDIS_PM_PACKET_PATTERN))
1417 {
1418 *BytesNeeded = sizeof(NDIS_PM_PACKET_PATTERN);
1420 break;
1421 }
1422
1424
1425 Status = NvNetAddWakeUpPattern(Adapter, InformationBuffer);
1426 break;
1427 }
1428
1430 {
1431 if (InformationBufferLength < sizeof(NDIS_PM_PACKET_PATTERN))
1432 {
1433 *BytesNeeded = sizeof(NDIS_PM_PACKET_PATTERN);
1435 break;
1436 }
1437
1439
1440 Status = NvNetRemoveWakeUpPattern(Adapter, InformationBuffer);
1441 break;
1442 }
1443
1445 {
1446 if (InformationBufferLength < sizeof(ULONG))
1447 {
1448 *BytesNeeded = sizeof(ULONG);
1450 break;
1451 }
1452
1453 *BytesRead = sizeof(ULONG);
1454 NdisMoveMemory(&GenericUlong, InformationBuffer, sizeof(ULONG));
1455
1456 NvNetEnableWakeUp(Adapter, GenericUlong);
1457 break;
1458 }
1459
1460 case OID_PNP_SET_POWER:
1461 {
1462 if (InformationBufferLength < sizeof(NDIS_DEVICE_POWER_STATE))
1463 {
1464 *BytesNeeded = sizeof(NDIS_DEVICE_POWER_STATE);
1466 break;
1467 }
1468
1469 *BytesRead = sizeof(ULONG);
1470 NdisMoveMemory(&GenericUlong, InformationBuffer, sizeof(ULONG));
1471
1472 if (GenericUlong < NdisDeviceStateD0 || GenericUlong > NdisDeviceStateD3)
1473 {
1475 break;
1476 }
1477
1478 Status = NvNetSetPower(Adapter, GenericUlong);
1479 break;
1480 }
1481
1482 default:
1484 break;
1485 }
1486
1487 return Status;
1488}
#define NDIS_STATUS_INVALID_DATA
Definition: ndis.h:486
#define NDIS_STATUS_INVALID_LENGTH
Definition: ndis.h:485
#define NDIS_STATUS_FAILURE
Definition: ndis.h:465
struct _NDIS_TASK_OFFLOAD_HEADER NDIS_TASK_OFFLOAD_HEADER
#define NDIS_STATUS_MULTICAST_FULL
Definition: ndis.h:473
struct _NDIS_PM_PACKET_PATTERN NDIS_PM_PACKET_PATTERN
#define OID_PNP_SET_POWER
Definition: ntddndis.h:361
#define OID_PNP_ADD_WAKE_UP_PATTERN
Definition: ntddndis.h:363
#define OID_PNP_REMOVE_WAKE_UP_PATTERN
Definition: ntddndis.h:364
@ NdisDeviceStateD3
Definition: ntddndis.h:41
static VOID NvNetEnableWakeUp(_In_ PNVNET_ADAPTER Adapter, _In_ ULONG Flags)
Definition: requests.c:748
static DECLSPEC_NOINLINE VOID NvNetApplyPacketFilter(_In_ PNVNET_ADAPTER Adapter)
Definition: requests.c:131
static NDIS_STATUS NvNetSetPower(_In_ PNVNET_ADAPTER Adapter, _In_ NDIS_DEVICE_POWER_STATE NewPowerState)
Definition: requests.c:647
static NDIS_STATUS NvNetAddWakeUpPattern(_In_ PNVNET_ADAPTER Adapter, _In_ PNDIS_PM_PACKET_PATTERN Pattern)
Definition: requests.c:661
static NDIS_STATUS NvNetSetTcpTaskOffload(_Inout_ PNVNET_ADAPTER Adapter, _In_ PNDIS_TASK_OFFLOAD_HEADER TaskOffloadHeader, _In_ PULONG BytesRead)
Definition: requests.c:865
static NDIS_STATUS NvNetRemoveWakeUpPattern(_In_ PNVNET_ADAPTER Adapter, _In_ PNDIS_PM_PACKET_PATTERN Pattern)
Definition: requests.c:698
#define NVNET_MAXIMUM_VLAN_ID
Definition: nvnet.h:62
#define NVNET_PACKET_FILTERS
Definition: nvnet.h:69
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PLONGLONG _In_opt_ PWDF_REQUEST_SEND_OPTIONS _Out_opt_ PULONG_PTR BytesRead
Definition: wdfiotarget.h:870

◆ NvNetAddWakeUpPattern()

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

Definition at line 661 of file requests.c.

664{
665 ULONG FrameNumber;
667 PNVNET_WAKE_FRAME WakeFrame;
668
669 if (!_BitScanForward(&FrameNumber, Adapter->WakeFrameBitmap))
670 {
672 }
673
674 Status = NdisAllocateMemoryWithTag((PVOID*)&WakeFrame, sizeof(*WakeFrame), NVNET_TAG);
676 {
678 }
679
680 Adapter->WakeFrameBitmap &= ~(1 << FrameNumber);
681
682 NdisZeroMemory(WakeFrame, sizeof(*WakeFrame));
683 NdisMoveMemory(&WakeFrame->PatternMask,
684 (PUCHAR)Pattern + sizeof(NDIS_PM_PACKET_PATTERN),
685 min(Pattern->MaskSize, 16));
686 NdisMoveMemory(&WakeFrame->WakeUpPattern,
687 (PUCHAR)Pattern + Pattern->PatternOffset,
688 min(Pattern->PatternSize, 128));
689 Adapter->WakeFrames[FrameNumber] = WakeFrame;
690
691 /* TODO: VLAN frame translation */
692
693 return NDIS_STATUS_SUCCESS;
694}
NDIS_STATUS EXPORT NdisAllocateMemoryWithTag(OUT PVOID *VirtualAddress, IN UINT Length, IN ULONG Tag)
Definition: memory.c:21
unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask)
Definition: intrin_arm.h:57
#define min(a, b)
Definition: monoChain.cc:55
#define NdisZeroMemory(Destination, Length)
Definition: ndis.h:3926
#define NDIS_STATUS_RESOURCES
Definition: ndis.h:466
#define NVNET_TAG
Definition: nvnet.h:22
unsigned char * PUCHAR
Definition: typedefs.h:53

Referenced by MiniportSetInformation().

◆ NvNetApplyPacketFilter()

static DECLSPEC_NOINLINE VOID NvNetApplyPacketFilter ( _In_ PNVNET_ADAPTER  Adapter)
static

Definition at line 131 of file requests.c.

133{
136 ULONG FilterMask;
137 BOOLEAN RestartReceiver;
138
139 if (Adapter->PacketFilter & NDIS_PACKET_TYPE_ALL_MULTICAST)
140 {
142 NdisZeroMemory(Mask, sizeof(Mask));
143
146 }
147 else if (Adapter->PacketFilter & NDIS_PACKET_TYPE_MULTICAST)
148 {
149 if (Adapter->MulticastListSize > 0)
150 {
151 ULONG i, j;
152
153 NdisFillMemory(Address, sizeof(Address), 0xFF);
154 NdisFillMemory(Mask, sizeof(Mask), 0xFF);
155
156 for (i = 0; i < Adapter->MulticastListSize; ++i)
157 {
158 PUCHAR MacAddress = Adapter->MulticastList[i].MacAddress;
159
160 for (j = 0; j < ETH_LENGTH_OF_ADDRESS; ++j)
161 {
162 Address[j] &= MacAddress[j];
163 Mask[j] &= ~MacAddress[j];
164 }
165 }
166
167 for (j = 0; j < ETH_LENGTH_OF_ADDRESS; ++j)
168 {
169 Mask[j] |= Address[j];
170 }
171 }
172 else
173 {
175 NdisZeroMemory(Mask, sizeof(Mask));
176 }
177 }
178 else
179 {
181 NdisFillMemory(Mask, sizeof(Mask), 0xFF);
182 }
183
184 FilterMask = NV_READ(Adapter, NvRegPacketFilterFlags) & NVREG_PFF_PAUSE_RX;
185 FilterMask |= PacketFilterToMask(Adapter->PacketFilter);
186
187 NdisAcquireSpinLock(&Adapter->Receive.Lock);
188
189 RestartReceiver = !!(NV_READ(Adapter, NvRegReceiverControl) & NVREG_RCVCTL_START);
190 if (RestartReceiver)
191 {
192 NvNetStopReceiver(Adapter);
193 }
194
196 Address[3] << 24 | Address[2] << 16 | Address[1] << 8 | Address[0]);
197 NV_WRITE(Adapter, NvRegMulticastAddrB, Address[5] << 8 | Address[4]);
199 Mask[3] << 24 | Mask[2] << 16 | Mask[1] << 8 | Mask[0]);
200 NV_WRITE(Adapter, NvRegMulticastMaskB, Mask[5] << 8 | Mask[4]);
201
202 NV_WRITE(Adapter, NvRegPacketFilterFlags, FilterMask);
203
204 if (RestartReceiver)
205 {
206 NvNetStartReceiver(Adapter);
207 }
208
209 NdisReleaseSpinLock(&Adapter->Receive.Lock);
210}
unsigned char BOOLEAN
unsigned int Mask
Definition: fpcontrol.c:82
#define NdisReleaseSpinLock(_SpinLock)
Definition: ndis.h:4115
#define NdisFillMemory(Destination, Length, Fill)
Definition: ndis.h:3886
#define NDIS_PACKET_TYPE_MULTICAST
Definition: ndis.h:664
#define NDIS_PACKET_TYPE_ALL_MULTICAST
Definition: ndis.h:665
#define NdisAcquireSpinLock(_SpinLock)
Definition: ndis.h:4106
VOID NvNetStartReceiver(_In_ PNVNET_ADAPTER Adapter)
Definition: nic.c:104
VOID NvNetStopReceiver(_In_ PNVNET_ADAPTER Adapter)
Definition: nic.c:147
#define NVREG_RCVCTL_START
Definition: nic.h:125
#define NVREG_MCASTADDRA_FORCE
Definition: nic.h:155
@ NvRegMulticastAddrA
Definition: nic.h:153
@ NvRegMulticastMaskA
Definition: nic.h:157
@ NvRegReceiverControl
Definition: nic.h:124
@ NvRegPacketFilterFlags
Definition: nic.h:113
@ NvRegMulticastMaskB
Definition: nic.h:160
@ NvRegMulticastAddrB
Definition: nic.h:154
#define NVREG_PFF_PAUSE_RX
Definition: nic.h:114
static ULONG PacketFilterToMask(_In_ ULONG PacketFilter)
Definition: requests.c:110
FORCEINLINE VOID NV_WRITE(_In_ PNVNET_ADAPTER Adapter, _In_ NVNET_REGISTER Register, _In_ ULONG Value)
Definition: nvnet.h:646
FORCEINLINE ULONG NV_READ(_In_ PNVNET_ADAPTER Adapter, _In_ NVNET_REGISTER Register)
Definition: nvnet.h:656
static WCHAR Address[46]
Definition: ping.c:68
unsigned char UCHAR
Definition: xmlstorage.h:181

Referenced by MiniportSetInformation(), and NvNetPowerWorker().

◆ NvNetEnableWakeUp()

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

Definition at line 748 of file requests.c.

751{
752 Adapter->WakeFlags = Flags;
753}
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

Referenced by MiniportSetInformation().

◆ NvNetFillPowerManagementCapabilities()

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

Definition at line 414 of file requests.c.

417{
418 Capabilities->WakeUpCapabilities.MinMagicPacketWakeUp =
419 Capabilities->WakeUpCapabilities.MinPatternWakeUp =
420 Capabilities->WakeUpCapabilities.MinLinkChangeWakeUp = NdisDeviceStateD3;
421
422 /* All hardware is PM-aware */
423 return NDIS_STATUS_SUCCESS;
424}
_Must_inspect_result_ typedef _Out_ PHIDP_CAPS Capabilities
Definition: hidclass.h:103

Referenced by MiniportQueryInformation().

◆ NvNetGetLinkSpeed()

static ULONG NvNetGetLinkSpeed ( _In_ PNVNET_ADAPTER  Adapter)
static

Definition at line 83 of file requests.c.

85{
86 ULONG LinkSpeedMbps;
87
88 switch (Adapter->LinkSpeed)
89 {
91 LinkSpeedMbps = 10;
92 break;
94 LinkSpeedMbps = 100;
95 break;
97 LinkSpeedMbps = 1000;
98 break;
99
100 default:
102 break;
103 }
104
105 return LinkSpeedMbps;
106}
#define UNREACHABLE
#define NVREG_LINKSPEED_1000
Definition: nic.h:189
#define NVREG_LINKSPEED_100
Definition: nic.h:188
#define NVREG_LINKSPEED_10
Definition: nic.h:187

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 757 of file requests.c.

763{
764 ULONG InfoLength;
765 PNDIS_TASK_OFFLOAD TaskOffload;
766
767 if (!(Adapter->Flags & (NV_SEND_CHECKSUM | NV_SEND_LARGE_SEND)))
768 {
769 *BytesWritten = 0;
770 *BytesNeeded = 0;
772 }
773
774 InfoLength = sizeof(NDIS_TASK_OFFLOAD_HEADER);
775 if (Adapter->Flags & NV_SEND_CHECKSUM)
776 {
777 InfoLength += FIELD_OFFSET(NDIS_TASK_OFFLOAD, TaskBuffer) +
779 }
780 if (Adapter->Flags & NV_SEND_LARGE_SEND)
781 {
782 InfoLength += FIELD_OFFSET(NDIS_TASK_OFFLOAD, TaskBuffer) +
784 }
785
786 if (InformationBufferLength < InfoLength)
787 {
788 *BytesWritten = 0;
789 *BytesNeeded = InfoLength;
791 }
792
793 if ((TaskOffloadHeader->EncapsulationFormat.Encapsulation != IEEE_802_3_Encapsulation) &&
794 (TaskOffloadHeader->EncapsulationFormat.Encapsulation != UNSPECIFIED_Encapsulation ||
795 TaskOffloadHeader->EncapsulationFormat.EncapsulationHeaderSize != sizeof(ETH_HEADER)))
796 {
797 *BytesWritten = 0;
798 *BytesNeeded = 0;
800 }
801 if (TaskOffloadHeader->Version != NDIS_TASK_OFFLOAD_VERSION)
802 {
803 *BytesWritten = 0;
804 *BytesNeeded = 0;
806 }
807
808 TaskOffloadHeader->OffsetFirstTask = sizeof(NDIS_TASK_OFFLOAD_HEADER);
809 TaskOffload = (PNDIS_TASK_OFFLOAD)(TaskOffloadHeader + 1);
810 if (Adapter->Flags & NV_SEND_CHECKSUM)
811 {
812 PNDIS_TASK_TCP_IP_CHECKSUM ChecksumTask;
813
814 TaskOffload->Size = sizeof(NDIS_TASK_OFFLOAD);
815 TaskOffload->Version = NDIS_TASK_OFFLOAD_VERSION;
816 TaskOffload->Task = TcpIpChecksumNdisTask;
817 TaskOffload->TaskBufferLength = sizeof(NDIS_TASK_TCP_IP_CHECKSUM);
818 TaskOffload->OffsetNextTask = FIELD_OFFSET(NDIS_TASK_OFFLOAD, TaskBuffer) +
820
821 ChecksumTask = (PNDIS_TASK_TCP_IP_CHECKSUM)TaskOffload->TaskBuffer;
822 NdisZeroMemory(ChecksumTask, sizeof(*ChecksumTask));
823
824 ChecksumTask->V4Transmit.IpOptionsSupported = 1;
825 ChecksumTask->V4Transmit.TcpOptionsSupported = 1;
826 ChecksumTask->V4Transmit.TcpChecksum = 1;
827 ChecksumTask->V4Transmit.UdpChecksum = 1;
828 ChecksumTask->V4Transmit.IpChecksum = 1;
829
830 ChecksumTask->V4Receive.IpOptionsSupported = 1;
831 ChecksumTask->V4Receive.TcpOptionsSupported = 1;
832 ChecksumTask->V4Receive.TcpChecksum = 1;
833 ChecksumTask->V4Receive.UdpChecksum = 1;
834 ChecksumTask->V4Receive.IpChecksum = 1;
835
836 TaskOffload = (PNDIS_TASK_OFFLOAD)(ChecksumTask + 1);
837 }
838 if (Adapter->Flags & NV_SEND_LARGE_SEND)
839 {
840 PNDIS_TASK_TCP_LARGE_SEND LargeSendTask;
841
842 TaskOffload->Size = sizeof(NDIS_TASK_OFFLOAD);
843 TaskOffload->Version = NDIS_TASK_OFFLOAD_VERSION;
844 TaskOffload->Task = TcpLargeSendNdisTask;
845 TaskOffload->TaskBufferLength = sizeof(NDIS_TASK_TCP_LARGE_SEND);
846 TaskOffload->OffsetNextTask = 0;
847
848 LargeSendTask = (PNDIS_TASK_TCP_LARGE_SEND)TaskOffload->TaskBuffer;
849 LargeSendTask->Version = NDIS_TASK_TCP_LARGE_SEND_V0;
852 LargeSendTask->IpOptions = TRUE;
853 LargeSendTask->TcpOptions = TRUE;
854 }
855 TaskOffload->OffsetNextTask = 0;
856
857 *BytesWritten = InfoLength;
858 *BytesNeeded = 0;
859
860 return NDIS_STATUS_SUCCESS;
861}
#define TRUE
Definition: types.h:120
struct _NDIS_TASK_OFFLOAD NDIS_TASK_OFFLOAD
struct _NDIS_TASK_OFFLOAD * PNDIS_TASK_OFFLOAD
@ UNSPECIFIED_Encapsulation
Definition: ndis.h:1207
@ IEEE_802_3_Encapsulation
Definition: ndis.h:1209
#define NDIS_TASK_OFFLOAD_VERSION
Definition: ndis.h:1388
struct _NDIS_TASK_TCP_LARGE_SEND * PNDIS_TASK_TCP_LARGE_SEND
struct _NDIS_TASK_TCP_IP_CHECKSUM NDIS_TASK_TCP_IP_CHECKSUM
@ TcpIpChecksumNdisTask
Definition: ndis.h:1200
@ TcpLargeSendNdisTask
Definition: ndis.h:1202
struct _NDIS_TASK_TCP_LARGE_SEND NDIS_TASK_TCP_LARGE_SEND
#define NDIS_TASK_TCP_LARGE_SEND_V0
Definition: ndis.h:1270
struct _NDIS_TASK_TCP_IP_CHECKSUM * PNDIS_TASK_TCP_IP_CHECKSUM
#define NVNET_MINIMUM_LSO_SEGMENT_COUNT
Definition: nvnet.h:66
#define NVNET_MAXIMUM_LSO_FRAME_SIZE
Definition: nvnet.h:67
#define NV_SEND_LARGE_SEND
Definition: nvnet.h:288
#define NV_SEND_CHECKSUM
Definition: nvnet.h:287
ULONG TaskBufferLength
Definition: ndis.h:1237
ULONG OffsetNextTask
Definition: ndis.h:1236
UCHAR TaskBuffer[1]
Definition: ndis.h:1238
NDIS_TASK Task
Definition: ndis.h:1235
struct _NDIS_TASK_TCP_IP_CHECKSUM::@2208 V4Transmit
struct _NDIS_TASK_TCP_IP_CHECKSUM::@2209 V4Receive
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255

Referenced by MiniportQueryInformation().

◆ NvNetGetWakeUp()

static ULONG NvNetGetWakeUp ( _In_ PNVNET_ADAPTER  Adapter)
static

Definition at line 738 of file requests.c.

740{
741 return Adapter->WakeFlags & (NDIS_PNP_WAKE_UP_MAGIC_PACKET |
744}
#define NDIS_PNP_WAKE_UP_MAGIC_PACKET
Definition: ntddndis.h:372
#define NDIS_PNP_WAKE_UP_LINK_CHANGE
Definition: ntddndis.h:374
#define NDIS_PNP_WAKE_UP_PATTERN_MATCH
Definition: ntddndis.h:373

Referenced by MiniportQueryInformation().

◆ NvNetPowerWorker()

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

Definition at line 604 of file requests.c.

607{
608 PNVNET_ADAPTER Adapter = Context;
609
611
612 PAGED_CODE();
613
614 if (Adapter->PowerStatePending == NdisDeviceStateD0)
615 {
617
619
620 NvNetStartAdapter(Adapter);
621
622 NvNetApplyPacketFilter(Adapter);
623 }
624 else
625 {
626 NvNetPauseProcessing(Adapter);
627
628 NvNetStopAdapter(Adapter);
629
630 NvNetIdleTransmitter(Adapter, FALSE);
631 NvNetStopTransmitter(Adapter);
632 NvNetStopReceiver(Adapter);
633 NV_WRITE(Adapter, NvRegTxRxControl,
636
638
639 NvNetSetPowerState(Adapter, Adapter->PowerStatePending, Adapter->WakeFlags);
640 }
641
643}
#define PAGED_CODE()
#define FALSE
Definition: types.h:117
#define NdisMSetInformationComplete(MiniportAdapterHandle, Status)
Definition: ndis.h:5762
#define NdisStallExecution
Definition: ndis.h:4453
VOID NvNetIdleTransmitter(_In_ PNVNET_ADAPTER Adapter, _In_ BOOLEAN ClearPhyControl)
Definition: nic.c:211
NDIS_STATUS NvNetInitNIC(_In_ PNVNET_ADAPTER Adapter, _In_ BOOLEAN InitPhy)
Definition: nic.c:401
VOID NvNetStopTransmitter(_In_ PNVNET_ADAPTER Adapter)
Definition: nic.c:178
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:329
@ NdisDeviceStateD0
Definition: ntddndis.h:38
#define NV_TXRX_RESET_DELAY
Definition: nic.h:444
#define NVREG_TXRXCTL_BIT2
Definition: nic.h:203
#define NVREG_TXRXCTL_RESET
Definition: nic.h:205
@ NvRegTxRxControl
Definition: nic.h:200
VOID NvNetSetPowerState(_In_ PNVNET_ADAPTER Adapter, _In_ NDIS_DEVICE_POWER_STATE NewPowerState, _In_ ULONG WakeFlags)
Definition: requests.c:501
VOID NvNetFlushTransmitQueue(_In_ PNVNET_ADAPTER Adapter, _In_ NDIS_STATUS CompleteStatus)
Definition: nvnet.c:24
DECLSPEC_NOINLINE VOID NvNetPauseProcessing(_In_ PNVNET_ADAPTER Adapter)
Definition: nvnet.c:46
VOID NvNetStopAdapter(_In_ PNVNET_ADAPTER Adapter)
Definition: nvnet.c:58
VOID NvNetStartAdapter(_In_ PNVNET_ADAPTER Adapter)
Definition: nvnet.c:74
ULONG WakeFlags
Definition: nvnet.h:324
ULONG TxRxControl
Definition: nvnet.h:301
NDIS_HANDLE AdapterHandle
Definition: nvnet.h:283
ULONG PowerStatePending
Definition: nvnet.h:329
_Must_inspect_result_ _In_ PWDF_WORKITEM_CONFIG _In_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWORKITEM * WorkItem
Definition: wdfworkitem.h:115
#define NT_VERIFY(exp)
Definition: rtlfuncs.h:3304

Referenced by NvNetSetPower().

◆ NvNetQueryHwCounter()

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

Definition at line 259 of file requests.c.

263{
264 switch (Oid)
265 {
266 case OID_GEN_XMIT_OK:
267 *Counter = (Adapter->Features & DEV_HAS_STATISTICS_V2)
268 ? Adapter->Statistics.HwTxFrame
269 : (Adapter->Statistics.HwTxZeroReXmt +
270 Adapter->Statistics.HwTxOneReXmt +
271 Adapter->Statistics.HwTxManyReXmt);
272 break;
273 case OID_GEN_RCV_OK:
274 *Counter = (Adapter->Statistics.HwRxUnicast +
275 Adapter->Statistics.HwRxMulticast +
276 Adapter->Statistics.HwRxBroadcast);
277 break;
279 *Counter = (Adapter->Statistics.HwTxRetryErr +
280 Adapter->Statistics.HwTxLateCol +
281 Adapter->Statistics.HwTxUnderflow +
282 Adapter->Statistics.HwTxLossCarrier +
283 Adapter->Statistics.HwTxExcessDef);
284 break;
286 *Counter = (Adapter->Statistics.HwRxFrameAlignErr +
287 Adapter->Statistics.HwRxLenErr +
288 Adapter->Statistics.HwRxRunt +
289 Adapter->Statistics.HwRxFrameTooLong +
290 Adapter->Statistics.HwRxFCSErr +
291 Adapter->Statistics.HwRxFrameErr +
292 Adapter->Statistics.HwRxExtraByte +
293 Adapter->Statistics.HwRxLateCol);
294 break;
296 *Counter = (Adapter->Statistics.HwRxDropFrame +
297 Adapter->Statistics.HwRxOverflow +
298 Adapter->Statistics.ReceiveIrqNoBuffers);
299 break;
301 *Counter = Adapter->Statistics.HwRxUnicast;
302 break;
304 *Counter = Adapter->Statistics.HwRxFCSErr;
305 break;
307 *Counter = Adapter->Statistics.HwRxFrameErr;
308 break;
310 *Counter = Adapter->Statistics.HwTxOneReXmt;
311 break;
313 *Counter = Adapter->Statistics.HwTxManyReXmt;
314 break;
316 *Counter = Adapter->Statistics.HwTxDef;
317 break;
319 *Counter = Adapter->Statistics.HwTxRetryErr;
320 break;
322 *Counter = Adapter->Statistics.HwRxOverflow;
323 break;
325 *Counter = Adapter->Statistics.HwTxUnderflow;
326 break;
328 *Counter = Adapter->Statistics.HwTxZeroReXmt;
329 break;
331 *Counter = Adapter->Statistics.HwTxLossCarrier;
332 break;
334 *Counter = Adapter->Statistics.HwTxLateCol;
335 break;
336
337 default:
339 break;
340 }
341}
#define DEV_HAS_STATISTICS_V2
Definition: nic.h:28
static LARGE_INTEGER Counter
Definition: clock.c:43

Referenced by MiniportQueryInformation().

◆ NvNetQuerySoftwareCounter()

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

Definition at line 345 of file requests.c.

349{
350 switch (Oid)
351 {
352 case OID_GEN_XMIT_OK:
353 *Counter = Adapter->Statistics.TransmitOk;
354 break;
355 case OID_GEN_RCV_OK:
356 *Counter = Adapter->Statistics.ReceiveOk;
357 break;
359 *Counter = Adapter->Statistics.TransmitErrors;
360 break;
362 *Counter = Adapter->Statistics.ReceiveErrors;
363 break;
365 *Counter = Adapter->Statistics.ReceiveNoBuffers;
366 break;
368 *Counter = 0;
369 break;
371 *Counter = Adapter->Statistics.ReceiveCrcErrors;
372 break;
374 *Counter = Adapter->Statistics.ReceiveAlignmentErrors;
375 break;
377 *Counter = Adapter->Statistics.TransmitOneRetry;
378 break;
380 *Counter = (Adapter->Statistics.TransmitOk -
381 Adapter->Statistics.TransmitOneRetry -
382 Adapter->Statistics.TransmitZeroRetry);
383 break;
385 *Counter = Adapter->Statistics.TransmitDeferred;
386 break;
388 *Counter = Adapter->Statistics.TransmitExcessiveCollisions;
389 break;
391 *Counter = Adapter->Statistics.ReceiveOverrunErrors;
392 break;
394 *Counter = Adapter->Statistics.TransmitUnderrunErrors;
395 break;
397 *Counter = Adapter->Statistics.TransmitZeroRetry;
398 break;
400 *Counter = Adapter->Statistics.TransmitLostCarrierSense;
401 break;
403 *Counter = Adapter->Statistics.TransmitLateCollisions;
404 break;
405
406 default:
408 break;
409 }
410}

Referenced by MiniportQueryInformation().

◆ NvNetReadStatistics()

static VOID NvNetReadStatistics ( _In_ PNVNET_ADAPTER  Adapter)
static

Definition at line 214 of file requests.c.

216{
217 Adapter->Statistics.HwTxCnt += NV_READ(Adapter, NvRegTxCnt);
218 Adapter->Statistics.HwTxZeroReXmt += NV_READ(Adapter, NvRegTxZeroReXmt);
219 Adapter->Statistics.HwTxOneReXmt += NV_READ(Adapter, NvRegTxOneReXmt);
220 Adapter->Statistics.HwTxManyReXmt += NV_READ(Adapter, NvRegTxManyReXmt);
221 Adapter->Statistics.HwTxLateCol += NV_READ(Adapter, NvRegTxLateCol);
222 Adapter->Statistics.HwTxUnderflow += NV_READ(Adapter, NvRegTxUnderflow);
223 Adapter->Statistics.HwTxLossCarrier += NV_READ(Adapter, NvRegTxLossCarrier);
224 Adapter->Statistics.HwTxExcessDef += NV_READ(Adapter, NvRegTxExcessDef);
225 Adapter->Statistics.HwTxRetryErr += NV_READ(Adapter, NvRegTxRetryErr);
226 Adapter->Statistics.HwRxFrameErr += NV_READ(Adapter, NvRegRxFrameErr);
227 Adapter->Statistics.HwRxExtraByte += NV_READ(Adapter, NvRegRxExtraByte);
228 Adapter->Statistics.HwRxLateCol += NV_READ(Adapter, NvRegRxLateCol);
229 Adapter->Statistics.HwRxRunt += NV_READ(Adapter, NvRegRxRunt);
230 Adapter->Statistics.HwRxFrameTooLong += NV_READ(Adapter, NvRegRxFrameTooLong);
231 Adapter->Statistics.HwRxOverflow += NV_READ(Adapter, NvRegRxOverflow);
232 Adapter->Statistics.HwRxFCSErr += NV_READ(Adapter, NvRegRxFCSErr);
233 Adapter->Statistics.HwRxFrameAlignErr += NV_READ(Adapter, NvRegRxFrameAlignErr);
234 Adapter->Statistics.HwRxLenErr += NV_READ(Adapter, NvRegRxLenErr);
235 Adapter->Statistics.HwRxUnicast += NV_READ(Adapter, NvRegRxUnicast);
236 Adapter->Statistics.HwRxMulticast += NV_READ(Adapter, NvRegRxMulticast);
237 Adapter->Statistics.HwRxBroadcast += NV_READ(Adapter, NvRegRxBroadcast);
238
239 if (Adapter->Features & DEV_HAS_STATISTICS_V2)
240 {
241 Adapter->Statistics.HwTxDef += NV_READ(Adapter, NvRegTxDef);
242 Adapter->Statistics.HwTxFrame += NV_READ(Adapter, NvRegTxFrame);
243 Adapter->Statistics.HwRxCnt += NV_READ(Adapter, NvRegRxCnt);
244 Adapter->Statistics.HwTxPause += NV_READ(Adapter, NvRegTxPause);
245 Adapter->Statistics.HwRxPause += NV_READ(Adapter, NvRegRxPause);
246 Adapter->Statistics.HwRxDropFrame += NV_READ(Adapter, NvRegRxDropFrame);
247 }
248
249 if (Adapter->Features & DEV_HAS_STATISTICS_V3)
250 {
251 Adapter->Statistics.HwTxUnicast += NV_READ(Adapter, NvRegTxUnicast);
252 Adapter->Statistics.HwTxMulticast += NV_READ(Adapter, NvRegTxMulticast);
253 Adapter->Statistics.HwTxBroadcast += NV_READ(Adapter, NvRegTxBroadcast);
254 }
255}
#define DEV_HAS_STATISTICS_V3
Definition: nic.h:29
@ NvRegRxPause
Definition: nic.h:324
@ NvRegRxDropFrame
Definition: nic.h:325
@ NvRegRxExtraByte
Definition: nic.h:309
@ NvRegTxPause
Definition: nic.h:323
@ NvRegRxRunt
Definition: nic.h:311
@ NvRegRxOverflow
Definition: nic.h:313
@ NvRegTxRetryErr
Definition: nic.h:307
@ NvRegTxUnderflow
Definition: nic.h:304
@ NvRegTxCnt
Definition: nic.h:299
@ NvRegTxMulticast
Definition: nic.h:252
@ NvRegRxFrameTooLong
Definition: nic.h:312
@ NvRegTxFrame
Definition: nic.h:321
@ NvRegRxMulticast
Definition: nic.h:318
@ NvRegRxCnt
Definition: nic.h:322
@ NvRegRxFCSErr
Definition: nic.h:314
@ NvRegTxLateCol
Definition: nic.h:303
@ NvRegTxUnicast
Definition: nic.h:251
@ NvRegRxUnicast
Definition: nic.h:317
@ NvRegTxBroadcast
Definition: nic.h:253
@ NvRegTxExcessDef
Definition: nic.h:306
@ NvRegRxBroadcast
Definition: nic.h:319
@ NvRegTxDef
Definition: nic.h:320
@ NvRegTxZeroReXmt
Definition: nic.h:300
@ NvRegTxManyReXmt
Definition: nic.h:302
@ NvRegTxOneReXmt
Definition: nic.h:301
@ NvRegRxLenErr
Definition: nic.h:316
@ NvRegTxLossCarrier
Definition: nic.h:305
@ NvRegRxLateCol
Definition: nic.h:310
@ NvRegRxFrameErr
Definition: nic.h:308
@ NvRegRxFrameAlignErr
Definition: nic.h:315

Referenced by MiniportQueryInformation().

◆ NvNetRemoveWakeUpPattern()

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

Definition at line 698 of file requests.c.

701{
702 ULONG i;
703
704 for (i = 0; i < RTL_NUMBER_OF(Adapter->WakeFrames); ++i)
705 {
706 PNVNET_WAKE_FRAME WakeFrame = Adapter->WakeFrames[i];
707
708 if (!WakeFrame)
709 continue;
710
711 if (!NdisEqualMemory(&WakeFrame->PatternMask,
712 (PUCHAR)Pattern + sizeof(NDIS_PM_PACKET_PATTERN),
713 min(Pattern->MaskSize, 16)))
714 {
715 continue;
716 }
717
718 if (!NdisEqualMemory(&WakeFrame->WakeUpPattern,
719 (PUCHAR)Pattern + Pattern->PatternOffset,
720 min(Pattern->PatternSize, 128)))
721 {
722 continue;
723 }
724
725 NdisFreeMemory(WakeFrame, sizeof(*WakeFrame), 0);
726
727 Adapter->WakeFrameBitmap |= (1 << i);
728 Adapter->WakeFrames[i] = NULL;
729
730 return NDIS_STATUS_SUCCESS;
731 }
732
734}
#define RTL_NUMBER_OF(x)
Definition: RtlRegistry.c:12
#define NULL
Definition: types.h:112
VOID EXPORT NdisFreeMemory(IN PVOID VirtualAddress, IN UINT Length, IN UINT MemoryFlags)
Definition: memory.c:110
#define NdisEqualMemory(Source1, Source2, Length)
Definition: ndis.h:3876
UCHAR WakeUpPattern[128]
Definition: nvnet.h:181
union _NVNET_WAKE_FRAME::@1057 PatternMask

Referenced by MiniportSetInformation().

◆ NvNetSetPower()

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

Definition at line 647 of file requests.c.

650{
651 Adapter->PowerStatePending = NewPowerState;
652
653 NdisInitializeWorkItem(&Adapter->PowerWorkItem, NvNetPowerWorker, Adapter);
654 NdisScheduleWorkItem(&Adapter->PowerWorkItem);
655
656 return NDIS_STATUS_PENDING;
657}
NDIS_STATUS EXPORT NdisScheduleWorkItem(IN PNDIS_WORK_ITEM pWorkItem)
Definition: misc.c:467
#define NDIS_STATUS_PENDING
Definition: ndis.h:347
#define NdisInitializeWorkItem(_WI_, _R_, _C_)
Definition: ndis.h:3197
static VOID NTAPI NvNetPowerWorker(_In_ PNDIS_WORK_ITEM WorkItem, _In_opt_ PVOID Context)
Definition: requests.c:604

Referenced by MiniportSetInformation().

◆ NvNetSetPowerState()

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

Definition at line 501 of file requests.c.

505{
506 ULONG i, PowerState, PowerState2, WakeUpFlags;
507
508 NV_READ(Adapter, NvRegPowerCap);
509
510 WakeUpFlags = 0;
511 PowerState2 = 0;
512 if (Adapter->Features & DEV_HAS_POWER_CNTRL)
513 {
514 PowerState2 = NV_READ(Adapter, NvRegPowerState2);
515 PowerState2 &= ~(NVREG_POWERSTATE2_WAKEUPPAT_5 |
518 }
519
520 if (NewPowerState != NdisDeviceStateD0)
521 {
522 ULONG FramesEnabled = 0;
523
524 if (WakeFlags & NDIS_PNP_WAKE_UP_PATTERN_MATCH)
525 WakeUpFlags |= NVREG_WAKEUPFLAGS_ENABLE_MAGPAT;
526 if (WakeFlags & NDIS_PNP_WAKE_UP_LINK_CHANGE)
528 if (WakeFlags & NDIS_PNP_WAKE_UP_MAGIC_PACKET)
529 {
531
532 for (i = 0; i < RTL_NUMBER_OF(Adapter->WakeFrames); ++i)
533 {
534 PNVNET_WAKE_FRAME WakeFrame = Adapter->WakeFrames[i];
535
536 if (!WakeFrame)
537 continue;
538
539 WriteWakeFrame(Adapter, WakeFrame, i);
540
541 PowerState2 |= FrameNumberToPowerMask(i);
542 WakeUpFlags |= FrameNumberToWakeUpMask(i);
543
544 ++FramesEnabled;
545 }
546 }
547
548 if (WakeUpFlags)
549 {
550 if (!(Adapter->Flags & NV_MAC_IN_USE))
551 {
552 PowerState2 &= ~NVREG_POWERSTATE2_GATE_CLOCKS;
553 PowerState2 |= NVREG_POWERSTATE2_GATE_CLOCK_3;
554
555 if (!FramesEnabled && (WakeUpFlags & NVREG_WAKEUPFLAGS_ENABLE_LINKCHANGE))
556 PowerState2 |= NVREG_POWERSTATE2_GATE_CLOCK_1;
557 if (FramesEnabled < NV_WAKEUPMASKENTRIES)
558 PowerState2 |= NVREG_POWERSTATE2_GATE_CLOCK_2;
559 }
560
561 NvNetStartReceiver(Adapter);
562 }
563 else
564 {
565 if (!(Adapter->Flags & NV_MAC_IN_USE))
566 PowerState2 |= NVREG_POWERSTATE2_GATE_CLOCKS;
567 }
568 }
569
571
572 NV_WRITE(Adapter, NvRegWakeUpFlags, WakeUpFlags);
573 if (Adapter->Features & DEV_HAS_POWER_CNTRL)
574 {
575 NV_WRITE(Adapter, NvRegPowerState2, PowerState2);
576 }
577
578 NV_WRITE(Adapter, NvRegPowerState,
580 for (i = 0; i < NV_POWER_ATTEMPTS; ++i)
581 {
583
585 break;
586
588
590 }
591
592 PowerState = NewPowerState - 1;
593 if (WakeUpFlags)
594 {
596 }
598}
#define NVREG_POWERSTATE_VALID
Definition: nic.h:289
#define DEV_HAS_POWER_CNTRL
Definition: nic.h:26
#define NVREG_WAKEUPFLAGS_ENABLE_WAKEUPPAT
Definition: nic.h:267
#define NVREG_POWERSTATE2_GATE_CLOCKS
Definition: nic.h:341
#define NVREG_POWERSTATE_POWEREDUP
Definition: nic.h:288
#define NVREG_POWERSTATE2_GATE_CLOCK_2
Definition: nic.h:339
#define NVREG_POWERSTATE2_GATE_CLOCK_3
Definition: nic.h:340
#define NVREG_POWERSTATE2_GATE_CLOCK_1
Definition: nic.h:338
#define NV_POWER_DELAY
Definition: nic.h:457
#define NV_POWER_ATTEMPTS
Definition: nic.h:459
#define NV_POWER_STALL
Definition: nic.h:458
#define NV_WAKEUPMASKENTRIES
Definition: nic.h:467
@ NvRegWakeUpFlags
Definition: nic.h:255
@ NvRegPowerState2
Definition: nic.h:334
@ NvRegPowerCap
Definition: nic.h:282
@ NvRegPowerState
Definition: nic.h:287
#define NVREG_WAKEUPFLAGS_ENABLE_MAGPAT
Definition: nic.h:266
#define NVREG_WAKEUPFLAGS_ENABLE_LINKCHANGE
Definition: nic.h:268
static ULONG FrameNumberToPowerMask(_In_ ULONG FrameNumber)
Definition: requests.c:483
static ULONG FrameNumberToWakeUpMask(_In_ ULONG FrameNumber)
Definition: requests.c:472
static VOID WriteWakeFrame(_In_ PNVNET_ADAPTER Adapter, _In_ PNVNET_WAKE_FRAME WakeFrame, _In_ ULONG FrameNumber)
Definition: requests.c:451
#define NV_MAC_IN_USE
Definition: nvnet.h:291

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 865 of file requests.c.

869{
871 PNDIS_TASK_OFFLOAD TaskOffload;
872
873 if (TaskOffloadHeader->Version != NDIS_TASK_OFFLOAD_VERSION)
874 {
876 }
877
878 Adapter->IpHeaderOffset = TaskOffloadHeader->EncapsulationFormat.EncapsulationHeaderSize;
879
880 TaskOffload = (PNDIS_TASK_OFFLOAD)TaskOffloadHeader;
881 Offset = TaskOffloadHeader->OffsetFirstTask;
882
883 while (Offset)
884 {
886
887 TaskOffload = (PNDIS_TASK_OFFLOAD)((PUCHAR)TaskOffload + Offset);
888 switch (TaskOffload->Task)
889 {
891 {
893
895
896 if (!(Adapter->Flags & NV_SEND_CHECKSUM))
897 {
899 }
900
901 Task = (PNDIS_TASK_TCP_IP_CHECKSUM)TaskOffload->TaskBuffer;
902
903 Adapter->Offload.SendTcpChecksum = Task->V4Transmit.TcpChecksum;
904 Adapter->Offload.SendUdpChecksum = Task->V4Transmit.UdpChecksum;
905 Adapter->Offload.SendIpChecksum = Task->V4Transmit.IpChecksum;
906
907 Adapter->Offload.ReceiveTcpChecksum = Task->V4Receive.TcpChecksum;
908 Adapter->Offload.ReceiveUdpChecksum = Task->V4Receive.UdpChecksum;
909 Adapter->Offload.ReceiveIpChecksum = Task->V4Receive.IpChecksum;
910 break;
911 }
912
914 {
916
917 if (!(Adapter->Flags & NV_SEND_LARGE_SEND))
918 {
920 }
921
922 if ((TaskOffloadHeader->
923 EncapsulationFormat.Encapsulation != IEEE_802_3_Encapsulation) &&
924 (TaskOffloadHeader->
925 EncapsulationFormat.Encapsulation != UNSPECIFIED_Encapsulation ||
926 TaskOffloadHeader->
927 EncapsulationFormat.EncapsulationHeaderSize != sizeof(ETH_HEADER)))
928 {
930 }
931
933
934 Task = (PNDIS_TASK_TCP_LARGE_SEND)TaskOffload->TaskBuffer;
935
938
941
942 /* Nothing to do */
943 break;
944 }
945
946 default:
947 break;
948 }
949
950 Offset = TaskOffload->OffsetNextTask;
951 }
952
953 NdisAcquireSpinLock(&Adapter->Send.Lock);
954
955 if (Adapter->Offload.ReceiveTcpChecksum ||
956 Adapter->Offload.ReceiveUdpChecksum ||
957 Adapter->Offload.ReceiveIpChecksum)
958 {
959 Adapter->TxRxControl |= NVREG_TXRXCTL_RXCHECK;
960 }
961 else
962 {
963 Adapter->TxRxControl &= ~NVREG_TXRXCTL_RXCHECK;
964 }
965 NV_WRITE(Adapter, NvRegTxRxControl, Adapter->TxRxControl);
966
967 NdisReleaseSpinLock(&Adapter->Send.Lock);
968
969 return NDIS_STATUS_SUCCESS;
970}
if(dx< 0)
Definition: linetemp.h:194
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
#define NVREG_TXRXCTL_RXCHECK
Definition: nic.h:206

Referenced by MiniportSetInformation().

◆ PacketFilterToMask()

static ULONG PacketFilterToMask ( _In_ ULONG  PacketFilter)
static

Definition at line 110 of file requests.c.

112{
114
115 if (PacketFilter & NDIS_PACKET_TYPE_PROMISCUOUS)
116 {
117 FilterMask &= ~NVREG_PFF_MYADDR;
118 }
119
120 if (PacketFilter & NDIS_PACKET_TYPE_BROADCAST)
121 {
122 FilterMask &= ~NVREG_PFF_PROMISC;
123 }
124
125 return FilterMask;
126}
#define NDIS_PACKET_TYPE_PROMISCUOUS
Definition: ndis.h:668
#define NDIS_PACKET_TYPE_BROADCAST
Definition: ndis.h:666
#define NVREG_PFF_PROMISC
Definition: nic.h:116
#define NVREG_PFF_ALWAYS
Definition: nic.h:115
#define NVREG_PFF_MYADDR
Definition: nic.h:117

Referenced by NvNetApplyPacketFilter().

◆ WriteWakeFrame()

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

Definition at line 451 of file requests.c.

455{
456 ULONG Offset = FrameNumber * 5 * sizeof(ULONG);
457
458 if (FrameNumber >= NV_WAKEUPPATTERNS)
459 {
461 }
462
463 NV_WRITE(Adapter, NvRegPatternCrc + Offset, BuildFrameSignature(WakeFrame));
464 NV_WRITE(Adapter, NvRegPatternMask0 + Offset, WakeFrame->PatternMask.AsULONG[0]);
465 NV_WRITE(Adapter, NvRegPatternMask1 + Offset, WakeFrame->PatternMask.AsULONG[1]);
466 NV_WRITE(Adapter, NvRegPatternMask2 + Offset, WakeFrame->PatternMask.AsULONG[2]);
467 NV_WRITE(Adapter, NvRegPatternMask3 + Offset, WakeFrame->PatternMask.AsULONG[3]);
468}
#define NV_PATTERN_V2_OFFSET
Definition: nic.h:468
#define NV_WAKEUPPATTERNS
Definition: nic.h:465
@ NvRegPatternMask3
Definition: nic.h:274
@ NvRegPatternMask1
Definition: nic.h:272
@ NvRegPatternMask0
Definition: nic.h:271
@ NvRegPatternMask2
Definition: nic.h:273
@ NvRegPatternCrc
Definition: nic.h:270
static ULONG BuildFrameSignature(_In_ PNVNET_WAKE_FRAME WakeFrame)
Definition: requests.c:428

Referenced by NvNetSetPowerState().

Variable Documentation

◆ NvpSupportedOidList

const NDIS_OID NvpSupportedOidList[]
static

Definition at line 17 of file requests.c.

Referenced by MiniportQueryInformation().