![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ndis.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / inc|
Return to ndis.h CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / inc |
1.1 root 1: /*++ BUILD Version: 0002 // Increment this if a change has global effects
2:
3: Copyright (c) 1992 Microsoft Corporation
4:
5: Module Name:
6:
7: ndis.h
8:
9: Abstract:
10:
11: Main header file for the wrapper
12:
13: Author:
14:
15: Adam Barr (adamba) 26-Jul-1990
16: Johnson R Apacible (JohnsonA) 10-Jul-1991
17:
18: Revision History:
19:
20: 26-Feb-1991 JohnsonA Debug version of wrapper
21: 10-Jul-1991 JohnsonA Implement revised NDIS 3.0 specification
22: 01-Nov-1991 SeanSe Correct and Expand NDIS 3.1 specification
23:
24: --*/
25:
26:
27: #ifndef _NDIS_
28: #define _NDIS_
29:
30:
31: #define NDIS_NT 1
32:
33: #include <ntddk.h>
34: #include <netevent.h>
35:
36:
37: #ifndef _WINDEF_ // these are defined in windows.h too
38: typedef signed int INT, *PINT;
39: typedef unsigned int UINT, *PUINT;
40: #endif
41: typedef UNICODE_STRING NDIS_STRING, *PNDIS_STRING;
42:
43:
44: //
45: // This file contains the definition of an NDIS_OID as
46: // well as #defines for all the current OID values.
47: //
48:
49: #include <ntddndis.h>
50:
51:
52: #ifdef NDIS_DOS
53: #undef NDIS_DOS
54: #endif
55:
56: #ifdef IF_ERROR_CHK
57: #undef IF_ERROR_CHK
58: #endif
59:
60: #ifdef NDISDBG
61: #ifdef MEMPRINT
62: #include "memprint.h" //DavidTr's memprint program at ntos\srv
63: #endif // MEMPRINT
64:
65: extern int NdisMsgLevel;
66: extern BOOLEAN NdisChkErrorFlag;
67: extern ULONG PendingSends;
68:
69: #define TRACE_NONE 0x0000
70: #define TRACE_IMPT 0x0001
71: #define TRACE_ALL 0x0002
72:
73: #define IF_TRACE(level) if ( NdisMsgLevel >= (level) ) //for tracing
74:
75: #define IF_ERROR_CHK if (NdisChkErrorFlag) // for parameter checking
76:
77: #define DbgIsMdl(_Buffer) \
78: ( ((ULONG)(_Buffer)->Size) == MmSizeOfMdl(MmGetMdlVirtualAddress(_Buffer), \
79: MmGetMdlByteCount(_Buffer)) )
80:
81: #define DbgIsNonPaged(_Address) \
82: ( MmIsNonPagedSystemAddressValid((PVOID)(_Address)) )
83:
84: #define DbgIsPacket(_Packet) \
85: ( ((_Packet)->Private.Pool->PacketLength) > sizeof(_Packet) )
86:
87: #define DbgIsNull(_Ptr) ( ((PVOID)(_Ptr)) == NULL )
88:
89: #define NdisPrint1(fmt) DbgPrint(fmt)
90: #define NdisPrint2(fmt,v1) DbgPrint(fmt,v1)
91: #define NdisPrint3(fmt,v1,v2) DbgPrint(fmt,v1,v2)
92: #define NdisPrint4(fmt,v1,v2,v3) DbgPrint(fmt,v1,v2,v3)
93: #define NdisPrint5(fmt,v1,v2,v3,v4) DbgPrint(fmt,v1,v2,v3,v4)
94:
95: #else // NDISDBG
96: #define IF_TRACE(level) if (FALSE)
97: #define IF_ERROR_CHK if (FALSE)
98: #define DbgIsMdl(_Buffer) TRUE
99: #define DbgIsNonPaged(_Address) TRUE
100: #define DbgIsPacket(_Packet) TRUE
101: #define DbgIsNull(_Ptr) FALSE
102:
103: #define NdisPrint1(fmt)
104: #define NdisPrint2(fmt,v1)
105: #define NdisPrint3(fmt,v1,v2)
106: #define NdisPrint4(fmt,v1,v2,v3)
107: #define NdisPrint5(fmt,v1,v2,v3,v4)
108: #endif // NDISDBG
109:
110: //
111: // Ndis defines for configuration manager data structures
112: //
113:
114: typedef CM_MCA_POS_DATA NDIS_MCA_POS_DATA, *PNDIS_MCA_POS_DATA;
115: typedef CM_EISA_SLOT_INFORMATION NDIS_EISA_SLOT_INFORMATION;
116: typedef CM_EISA_SLOT_INFORMATION *PNDIS_EISA_SLOT_INFORMATION;
117: typedef CM_EISA_FUNCTION_INFORMATION NDIS_EISA_FUNCTION_INFORMATION;
118: typedef CM_EISA_FUNCTION_INFORMATION *PNDIS_EISA_FUNCTION_INFORMATION;
119:
120: //
121: //
122: // Ndis defines and data structures
123: //
124: //
125:
126:
127: //
128: // Ndis macros that are supplied to Device Drivers to help
129: // with portability. They are not published in the NT spec
130: // as yet. For now you should supply two versions of each
131: // macros - an NT specific one and a portable one.
132: //
133:
134: #if NDIS_NT
135:
136: //
137: // ZZZ These macros are peculiar to NT.
138: //
139:
140: #define NdisMoveMemory(Destination,Source,Length) RtlCopyMemory(Destination,Source,Length)
141: #define NdisZeroMemory(Destination,Length) RtlZeroMemory(Destination,Length)
142: #define NdisRetrieveUlong(Destination,Source) RtlRetrieveUlong(Destination,Source)
143: #define NdisStoreUlong(Destination,Value) RtlStoreUlong(Destination,Value)
144: #define NDIS_STRING_CONST(x) {sizeof(L##x)-2, sizeof(L##x), L##x}
145:
146: //
147: // On a MIPS machine, I/O mapped memory can't be accessed with
148: // the Rtl routines.
149: //
150:
151: #ifdef _M_IX86
152: #define NdisMoveMappedMemory(Destination,Source,Length) RtlCopyMemory(Destination,Source,Length)
153: #define NdisZeroMappedMemory(Destination,Length) RtlZeroMemory(Destination,Length)
154: #elif defined(_M_MRX000) || defined(_MIPS_)
155: #define NdisMoveMappedMemory(Destination,Source,Length) \
156: { \
157: PUCHAR _Src = (Source); \
158: PUCHAR _Dest = (Destination); \
159: PUCHAR _End = _Dest + (Length); \
160: while (_Dest < _End) { \
161: *_Dest++ = *_Src++; \
162: } \
163: }
164: #define NdisZeroMappedMemory(Destination,Length) \
165: { \
166: PUCHAR _Dest = (Destination); \
167: PUCHAR _End = _Dest + (Length); \
168: while (_Dest < _End) { \
169: *_Dest++ = 0; \
170: } \
171: }
172: #elif defined(_ALPHA_)
173:
174: #define NdisMoveMappedMemory(Destination,Source,Length) \
175: { \
176: PUCHAR _Src = (Source); \
177: PUCHAR _Dest = (Destination); \
178: PUCHAR _End = _Dest + (Length); \
179: while (_Dest < _End) { \
180: *_Dest++ = *_Src++; \
181: } \
182: }
183: #define NdisZeroMappedMemory(Destination,Length) \
184: { \
185: PUCHAR _Dest = (Destination); \
186: PUCHAR _End = _Dest + (Length); \
187: while (_Dest < _End) { \
188: NdisWriteRegisterUchar(_Dest,0); \
189: _Dest++; \
190: } \
191: }
192:
193: #endif
194:
195:
196: #else
197:
198: //
199: // These macros MUST be portable.
200: //
201:
202: #define NdisMoveMemory(Destination,Source,Length) memcpy(Destination,Source,Length)
203: #define NdisZeroMemory(Destination,Length) memset(Destination,'\0',Length)
204: #define NdisMoveMappedMemory(Destination,Source,Length) memcpy(Destination,Source,Length)
205: #define NdisZeroMappedMemory(Destination,Length) memset(Destination,'\0',Length)
206: #define NdisRetrieveUlong(Destination,Source)\
207: {\
208: UCHAR _S = 0;\
209: for (; _S < sizeof(ULONG) ; _S++ ) {\
210: ((PUCHAR)Destination)[_S] = ((PUCHAR)Source)[_S];\
211: }\
212: }
213: #define NdisStoreUlong(Destination,Value)\
214: {\
215: UCHAR _S = 0;\
216: for (; _S < sizeof(ULONG) ; _S++ ) {\
217: ((PUCHAR)Destination)[_S] = ((UCHAR)(Value >> (_S * 8)));\
218: }\
219: }
220:
221:
222: #endif
223:
224:
225: //
226: // On Mips and Intel systems, these are the same. On Alpha, they are different.
227: //
228:
229: #ifdef _ALPHA_
230:
231: #define NdisMoveToMappedMemory(Destination,Source,Length) WRITE_REGISTER_BUFFER_UCHAR(Destination,Source,Length)
232: #define NdisMoveFromMappedMemory(Destination,Source,Length) READ_REGISTER_BUFFER_UCHAR(Source,Destination,Length)
233:
234: #else
235:
236: #define NdisMoveToMappedMemory(Destination,Source,Length) NdisMoveMappedMemory(Destination,Source,Length)
237: #define NdisMoveFromMappedMemory(Destination,Source,Length) NdisMoveMappedMemory(Destination,Source,Length)
238:
239: #endif
240:
241:
242:
243: //
244: // This macro is used to determine how many physical pieces
245: // an NDIS_BUFFER will take up when mapped.
246: //
247:
248: #define NDIS_BUFFER_TO_SPAN_PAGES(_Buffer) \
249: (ADDRESS_AND_SIZE_TO_SPAN_PAGES(\
250: MmGetMdlVirtualAddress(_Buffer), \
251: MmGetMdlByteCount(_Buffer)))
252:
253:
254: //
255: // definition of the basic spin lock structure
256: //
257:
258: typedef struct _NDIS_SPIN_LOCK {
259: KSPIN_LOCK SpinLock;
260: KIRQL OldIrql;
261: } NDIS_SPIN_LOCK, * PNDIS_SPIN_LOCK;
262:
263:
264: typedef PVOID NDIS_HANDLE, *PNDIS_HANDLE;
265:
266: typedef int NDIS_STATUS, *PNDIS_STATUS; // note default size
267:
268: typedef struct _NDIS_TIMER {
269: KTIMER Timer;
270: KDPC Dpc;
271: } NDIS_TIMER, *PNDIS_TIMER;
272:
273:
274: #define NdisInterruptLatched Latched
275: #define NdisInterruptLevelSensitive LevelSensitive
276: typedef KINTERRUPT_MODE NDIS_INTERRUPT_MODE, *PNDIS_INTERRUPT_MODE;
277:
278:
279: typedef
280: BOOLEAN
281: (*PNDIS_INTERRUPT_SERVICE) (
282: IN PVOID InterruptContext
283: );
284:
285: typedef
286: VOID
287: (*PNDIS_DEFERRED_PROCESSING) (
288: IN PVOID SystemSpecific1,
289: IN PVOID InterruptContext,
290: IN PVOID SystemSpecific2,
291: IN PVOID SystemSpecific3
292: );
293:
294:
295: typedef struct _NDIS_INTERRUPT {
296: PKINTERRUPT InterruptObject;
297: KSPIN_LOCK DpcCountLock;
298: PNDIS_INTERRUPT_SERVICE MacIsr; // Pointer to Mac ISR routine
299: PNDIS_DEFERRED_PROCESSING MacDpc; // Pointer to Mac DPC routine
300: KDPC InterruptDpc;
301: PVOID InterruptContext; // Pointer to context for calling
302: // adapters ISR and DPC.
303: UCHAR DpcCount;
304: BOOLEAN Removing; // TRUE if removing interrupt
305:
306: //
307: // This is used to tell when all the Dpcs for the adapter are completed.
308: //
309: KEVENT DpcsCompletedEvent;
310:
311: } NDIS_INTERRUPT, *PNDIS_INTERRUPT;
312:
313: struct _NDIS_PACKET;
314:
315:
316: //
317: // Configuration definitions
318: //
319:
320: //
321: // Possible data types
322: //
323: typedef enum _NDIS_PARAMETER_TYPE {
324: NdisParameterInteger,
325: NdisParameterHexInteger,
326: NdisParameterString,
327: NdisParameterMultiString
328: } NDIS_PARAMETER_TYPE, *PNDIS_PARAMETER_TYPE;
329:
330: //
331: // To store configuration information
332: //
333: typedef struct _NDIS_CONFIGURATION_PARAMETER {
334: NDIS_PARAMETER_TYPE ParameterType;
335: union {
336: ULONG IntegerData;
337: NDIS_STRING StringData;
338: } ParameterData;
339: } NDIS_CONFIGURATION_PARAMETER, *PNDIS_CONFIGURATION_PARAMETER;
340:
341:
342: //
343: // Definitions for the "ProcessorType" keyword
344: //
345: typedef enum _NDIS_PROCESSOR_TYPE {
346: NdisProcessorX86,
347: NdisProcessorMips,
348: NdisProcessorAlpha
349: } NDIS_PROCESSOR_TYPE, *PNDIS_PROCESSOR_TYPE;
350:
351: //
352: // Definitions for the "Environment" keyword
353: //
354: typedef enum _NDIS_ENVIRONMENT_TYPE {
355: NdisEnvironmentWindows,
356: NdisEnvironmentWindowsNt
357: } NDIS_ENVIRONMENT_TYPE, *PNDIS_ENVIRONMENT_TYPE;
358:
359:
360: //
361: // Possible Hardware Architecture. Define these to
362: // match the HAL INTERFACE_TYPE enum.
363: //
364: typedef enum _NDIS_INTERFACE_TYPE {
365: NdisInterfaceInternal = Internal,
366: NdisInterfaceIsa = Isa,
367: NdisInterfaceEisa = Eisa,
368: NdisInterfaceMca = MicroChannel,
369: NdisInterfaceTurboChannel = TurboChannel
370: } NDIS_INTERFACE_TYPE, *PNDIS_INTERFACE_TYPE;
371:
372:
373: //
374: // The structure passed up on a WAN_LINE_UP indication
375: //
376:
377: typedef struct _NDIS_WAN_LINE_UP {
378: ULONG LinkSpeed; // 100 bps units
379: ULONG MaximumTotalSize; // suggested max for send packets
380: NDIS_WAN_QUALITY Quality;
381: USHORT SendWindow; // suggested by the MAC
382: UCHAR Address[1]; // variable length, depends on address type
383: } NDIS_WAN_LINE_UP, *PNDIS_WAN_LINE_UP;
384:
385: //
386: // The structure passed up on a WAN_LINE_DOWN indication
387: //
388:
389: typedef struct _NDIS_WAN_LINE_DOWN {
390: UCHAR Address[1]; // variable length, depends on address type
391: } NDIS_WAN_LINE_DOWN, *PNDIS_WAN_LINE_DOWN;
392:
393: //
394: // The structure passed up on a WAN_FRAGMENT indication
395: //
396:
397: typedef struct _NDIS_WAN_FRAGMENT {
398: UCHAR Address[1]; // variable length, depends on address type
399: } NDIS_WAN_FRAGMENT, *PNDIS_WAN_FRAGMENT;
400:
401:
402: //
403: // Ndis Adapter Information
404: //
405:
406: typedef
407: NDIS_STATUS
408: (*PNDIS_ACTIVATE_CALLBACK) (
409: IN NDIS_HANDLE NdisAdatperHandle,
410: IN NDIS_HANDLE MacAdapterContext,
411: IN ULONG DmaChannel
412: );
413:
414: typedef struct _NDIS_PORT_DESCRIPTOR {
415: ULONG InitialPort;
416: ULONG NumberOfPorts;
417: PVOID *PortOffset;
418: } NDIS_PORT_DESCRIPTOR, *PNDIS_PORT_DESCRIPTOR;
419:
420: typedef struct _NDIS_ADAPTER_INFORMATION {
421: ULONG DmaChannel;
422: BOOLEAN Master;
423: BOOLEAN Dma32BitAddresses;
424: PNDIS_ACTIVATE_CALLBACK ActivateCallback;
425: NDIS_INTERFACE_TYPE AdapterType;
426: ULONG PhysicalMapRegistersNeeded;
427: ULONG MaximumPhysicalMapping;
428: ULONG NumberOfPortDescriptors;
429: NDIS_PORT_DESCRIPTOR PortDescriptors[1]; // as many as needed
430: } NDIS_ADAPTER_INFORMATION, *PNDIS_ADAPTER_INFORMATION;
431:
432: //
433: // DMA Channel information
434: //
435: typedef struct _NDIS_DMA_DESCRIPTION {
436: BOOLEAN DemandMode;
437: BOOLEAN AutoInitialize;
438: BOOLEAN DmaChannelSpecified;
439: DMA_WIDTH DmaWidth;
440: DMA_SPEED DmaSpeed;
441: ULONG DmaPort;
442: ULONG DmaChannel;
443: } NDIS_DMA_DESCRIPTION, *PNDIS_DMA_DESCRIPTION;
444:
445: //
446: // Internal structure representing an NDIS DMA channel
447: //
448: typedef struct _NDIS_DMA_BLOCK {
449: PVOID MapRegisterBase;
450: KEVENT AllocationEvent;
451: PADAPTER_OBJECT SystemAdapterObject;
452: BOOLEAN InProgress;
453: } NDIS_DMA_BLOCK, *PNDIS_DMA_BLOCK;
454:
455:
456: //
457: // Ndis Buffer is actually an Mdl
458: //
459: typedef MDL NDIS_BUFFER, * PNDIS_BUFFER;
460:
461: //
462: // packet pool definition
463: //
464: typedef struct _NDIS_PACKET_POOL {
465: NDIS_SPIN_LOCK SpinLock;
466: struct _NDIS_PACKET *FreeList; // linked list of free slots in pool
467: UINT PacketLength; // amount needed in each packet
468: UCHAR Buffer[1]; // actual pool memory
469: } NDIS_PACKET_POOL, * PNDIS_PACKET_POOL;
470:
471:
472: //
473: // wrapper-specific part of a packet
474: //
475:
476: typedef struct _NDIS_PACKET_PRIVATE {
477: UINT PhysicalCount; // number of physical pages in packet.
478: UINT TotalLength; // Total amount of data in the packet.
479: PNDIS_BUFFER Head; // first buffer in the chain
480: PNDIS_BUFFER Tail; // last buffer in the chain
481:
482: // if Head is NULL the chain is empty; Tail doesn't have to be NULL also
483:
484: PNDIS_PACKET_POOL Pool; // so we know where to free it back to
485: UINT Count;
486: ULONG Flags;
487: BOOLEAN ValidCounts;
488: } NDIS_PACKET_PRIVATE, * PNDIS_PACKET_PRIVATE;
489:
490:
491: //
492: // packet definition
493: //
494:
495: typedef struct _NDIS_PACKET {
496: NDIS_PACKET_PRIVATE Private;
497: UCHAR MacReserved[16];
498: UCHAR ProtocolReserved[1];
499: } NDIS_PACKET, * PNDIS_PACKET;
500:
501:
502: //
503: // Request types used by NdisRequest; constants are added for
504: // all entry points in the MAC, for those that want to create
505: // their own internal requests.
506: //
507:
508: typedef enum _NDIS_REQUEST_TYPE {
509: NdisRequestQueryInformation,
510: NdisRequestSetInformation,
511: NdisRequestQueryStatistics,
512: NdisRequestOpen,
513: NdisRequestClose,
514: NdisRequestSend,
515: NdisRequestTransferData,
516: NdisRequestReset,
517: NdisRequestGeneric1,
518: NdisRequestGeneric2,
519: NdisRequestGeneric3,
520: NdisRequestGeneric4
521: } NDIS_REQUEST_TYPE, *PNDIS_REQUEST_TYPE;
522:
523:
524: //
525: // Structure of requests sent via NdisRequest
526: //
527:
528: typedef struct _NDIS_REQUEST {
529: UCHAR MacReserved[16];
530: NDIS_REQUEST_TYPE RequestType;
531: union _DATA {
532:
533: struct _QUERY_INFORMATION {
534: NDIS_OID Oid;
535: PVOID InformationBuffer;
536: UINT InformationBufferLength;
537: UINT BytesWritten;
538: UINT BytesNeeded;
539: } QUERY_INFORMATION;
540:
541: struct _SET_INFORMATION {
542: NDIS_OID Oid;
543: PVOID InformationBuffer;
544: UINT InformationBufferLength;
545: UINT BytesRead;
546: UINT BytesNeeded;
547: } SET_INFORMATION;
548:
549: } DATA;
550:
551: } NDIS_REQUEST, *PNDIS_REQUEST;
552:
553:
554: //
555: // Definitions for physical address.
556: //
557:
558: typedef PHYSICAL_ADDRESS NDIS_PHYSICAL_ADDRESS, *PNDIS_PHYSICAL_ADDRESS;
559: typedef struct _NDIS_PHYSICAL_ADDRESS_UNIT {
560: NDIS_PHYSICAL_ADDRESS PhysicalAddress;
561: UINT Length;
562: } NDIS_PHYSICAL_ADDRESS_UNIT, *PNDIS_PHYSICAL_ADDRESS_UNIT;
563:
564:
565: /*++
566:
567: ULONG
568: NdisGetPhysicalAddressHigh(
569: IN NDIS_PHYSICAL_ADDRESS PhysicalAddress
570: );
571:
572: --*/
573:
574: #define NdisGetPhysicalAddressHigh(_PhysicalAddress)\
575: ((_PhysicalAddress).HighPart)
576:
577:
578: /*++
579:
580: VOID
581: NdisSetPhysicalAddressHigh(
582: IN NDIS_PHYSICAL_ADDRESS PhysicalAddress,
583: IN ULONG Value
584: );
585:
586: --*/
587:
588: #define NdisSetPhysicalAddressHigh(_PhysicalAddress, _Value)\
589: ((_PhysicalAddress).HighPart) = (_Value)
590:
591:
592: /*++
593:
594: ULONG
595: NdisGetPhysicalAddressLow(
596: IN NDIS_PHYSICAL_ADDRESS PhysicalAddress
597: );
598:
599: --*/
600:
601: #define NdisGetPhysicalAddressLow(_PhysicalAddress) \
602: ((_PhysicalAddress).LowPart)
603:
604:
605: /*++
606:
607: VOID
608: NdisSetPhysicalAddressLow(
609: IN NDIS_PHYSICAL_ADDRESS PhysicalAddress,
610: IN ULONG Value
611: );
612:
613: --*/
614:
615: #define NdisSetPhysicalAddressLow(_PhysicalAddress, _Value) \
616: ((_PhysicalAddress).LowPart) = (_Value)
617:
618:
619: //
620: // Macro to initialize an NDIS_PHYSICAL_ADDRESS constant
621: //
622:
623: #define NDIS_PHYSICAL_ADDRESS_CONST(_Low, _High) \
624: { (ULONG)(_Low), (LONG)(_High) }
625:
626:
627: //
628: // Include an incomplete type for NDIS_PACKET structure so that
629: // function types can refer to a type to be defined later.
630: //
631: struct _NDIS_PACKET;
632:
633: //
634: // Function types for NDIS_PROTOCOL_CHARACTERISTICS
635: //
636: //
637:
638: typedef
639: VOID
640: (*OPEN_ADAPTER_COMPLETE_HANDLER) (
641: IN NDIS_HANDLE ProtocolBindingContext,
642: IN NDIS_STATUS Status,
643: IN NDIS_STATUS OpenErrorStatus
644: );
645:
646: typedef
647: VOID
648: (*CLOSE_ADAPTER_COMPLETE_HANDLER) (
649: IN NDIS_HANDLE ProtocolBindingContext,
650: IN NDIS_STATUS Status
651: );
652:
653: typedef
654: VOID
655: (*SEND_COMPLETE_HANDLER) (
656: IN NDIS_HANDLE ProtocolBindingContext,
657: IN PNDIS_PACKET Packet,
658: IN NDIS_STATUS Status
659: );
660:
661: typedef
662: VOID
663: (*TRANSFER_DATA_COMPLETE_HANDLER) (
664: IN NDIS_HANDLE ProtocolBindingContext,
665: IN PNDIS_PACKET Packet,
666: IN NDIS_STATUS Status,
667: IN UINT BytesTransferred
668: );
669:
670: typedef
671: VOID
672: (*RESET_COMPLETE_HANDLER) (
673: IN NDIS_HANDLE ProtocolBindingContext,
674: IN NDIS_STATUS Status
675: );
676:
677: typedef
678: VOID
679: (*REQUEST_COMPLETE_HANDLER) (
680: IN NDIS_HANDLE ProtocolBindingContext,
681: IN PNDIS_REQUEST NdisRequest,
682: IN NDIS_STATUS Status
683: );
684:
685: typedef
686: NDIS_STATUS
687: (*RECEIVE_HANDLER) (
688: IN NDIS_HANDLE ProtocolBindingContext,
689: IN NDIS_HANDLE MacReceiveContext,
690: IN PVOID HeaderBuffer,
691: IN UINT HeaderBufferSize,
692: IN PVOID LookAheadBuffer,
693: IN UINT LookaheadBufferSize,
694: IN UINT PacketSize
695: );
696:
697: typedef
698: VOID
699: (*RECEIVE_COMPLETE_HANDLER) (
700: IN NDIS_HANDLE ProtocolBindingContext
701: );
702:
703: typedef
704: VOID
705: (*STATUS_HANDLER) (
706: IN NDIS_HANDLE ProtocolBindingContext,
707: IN NDIS_STATUS GeneralStatus,
708: IN PVOID StatusBuffer,
709: IN UINT StatusBufferSize
710: );
711:
712: typedef
713: VOID
714: (*STATUS_COMPLETE_HANDLER) (
715: IN NDIS_HANDLE ProtocolBindingContext
716: );
717:
718:
719: typedef struct _NDIS_PROTOCOL_CHARACTERISTICS {
720: UCHAR MajorNdisVersion;
721: UCHAR MinorNdisVersion;
722: UINT Reserved;
723: OPEN_ADAPTER_COMPLETE_HANDLER OpenAdapterCompleteHandler;
724: CLOSE_ADAPTER_COMPLETE_HANDLER CloseAdapterCompleteHandler;
725: SEND_COMPLETE_HANDLER SendCompleteHandler;
726: TRANSFER_DATA_COMPLETE_HANDLER TransferDataCompleteHandler;
727: RESET_COMPLETE_HANDLER ResetCompleteHandler;
728: REQUEST_COMPLETE_HANDLER RequestCompleteHandler;
729: RECEIVE_HANDLER ReceiveHandler;
730: RECEIVE_COMPLETE_HANDLER ReceiveCompleteHandler;
731: STATUS_HANDLER StatusHandler;
732: STATUS_COMPLETE_HANDLER StatusCompleteHandler;
733: NDIS_STRING Name;
734: } NDIS_PROTOCOL_CHARACTERISTICS, *PNDIS_PROTOCOL_CHARACTERISTICS;
735:
736:
737: typedef
738: VOID
739: (*PNDIS_SYNCHRONIZE_ROUTINE) (
740: IN PVOID SynchronizeContext
741: );
742:
743: //
744: // Function types for NDIS_MAC_CHARACTERISTICS
745: //
746:
747:
748: typedef
749: NDIS_STATUS
750: (*OPEN_ADAPTER_HANDLER) (
751: OUT PNDIS_STATUS OpenErrorStatus,
752: OUT NDIS_HANDLE *MacBindingHandle,
753: OUT PUINT SelectedMediumIndex,
754: IN PNDIS_MEDIUM MediumArray,
755: IN UINT MediumArraySize,
756: IN NDIS_HANDLE NdisBindingContext,
757: IN NDIS_HANDLE MacAdapterContext,
758: IN UINT OpenOptions,
759: IN PSTRING AddressingInformation OPTIONAL
760: );
761:
762: typedef
763: NDIS_STATUS
764: (*CLOSE_ADAPTER_HANDLER) (
765: IN NDIS_HANDLE MacBindingHandle
766: );
767:
768: typedef
769: NDIS_STATUS
770: (*SEND_HANDLER) (
771: IN NDIS_HANDLE MacBindingHandle,
772: IN PNDIS_PACKET Packet
773: );
774:
775: typedef
776: NDIS_STATUS
777: (*TRANSFER_DATA_HANDLER) (
778: IN NDIS_HANDLE MacBindingHandle,
779: IN NDIS_HANDLE MacReceiveContext,
780: IN UINT ByteOffset,
781: IN UINT BytesToTransfer,
782: OUT PNDIS_PACKET Packet,
783: OUT PUINT BytesTransferred
784: );
785:
786: typedef
787: NDIS_STATUS
788: (*RESET_HANDLER) (
789: IN NDIS_HANDLE MacBindingHandle
790: );
791:
792: typedef
793: NDIS_STATUS
794: (*REQUEST_HANDLER) (
795: IN NDIS_HANDLE MacBindingHandle,
796: IN PNDIS_REQUEST NdisRequest
797: );
798:
799: typedef
800: NDIS_STATUS
801: (*QUERY_GLOBAL_STATISTICS_HANDLER) (
802: IN NDIS_HANDLE MacAdapterContext,
803: IN PNDIS_REQUEST NdisRequest
804: );
805:
806: typedef
807: VOID
808: (*UNLOAD_MAC_HANDLER) (
809: IN NDIS_HANDLE MacMacContext
810: );
811:
812: typedef
813: NDIS_STATUS
814: (*ADD_ADAPTER_HANDLER) (
815: IN NDIS_HANDLE MacMacContext,
816: IN NDIS_HANDLE WrapperConfigurationContext,
817: IN PNDIS_STRING AdapterName
818: );
819:
820: typedef
821: VOID
822: (*REMOVE_ADAPTER_HANDLER) (
823: IN NDIS_HANDLE MacAdapterContext
824: );
825:
826:
827: typedef struct _NDIS_MAC_CHARACTERISTICS {
828: UCHAR MajorNdisVersion;
829: UCHAR MinorNdisVersion;
830: UINT Reserved;
831: OPEN_ADAPTER_HANDLER OpenAdapterHandler;
832: CLOSE_ADAPTER_HANDLER CloseAdapterHandler;
833: SEND_HANDLER SendHandler;
834: TRANSFER_DATA_HANDLER TransferDataHandler;
835: RESET_HANDLER ResetHandler;
836: REQUEST_HANDLER RequestHandler;
837: QUERY_GLOBAL_STATISTICS_HANDLER QueryGlobalStatisticsHandler;
838: UNLOAD_MAC_HANDLER UnloadMacHandler;
839: ADD_ADAPTER_HANDLER AddAdapterHandler;
840: REMOVE_ADAPTER_HANDLER RemoveAdapterHandler;
841: NDIS_STRING Name;
842: } NDIS_MAC_CHARACTERISTICS, *PNDIS_MAC_CHARACTERISTICS;
843:
844:
845: //
846: // Definition for shutdown handler
847: //
848:
849: typedef
850: VOID
851: (*ADAPTER_SHUTDOWN_HANDLER) (
852: IN PVOID ShutdownContext
853: );
854:
855:
856:
857: //
858: // block used for references...
859: //
860:
861: typedef struct _REFERENCE {
862: NDIS_SPIN_LOCK SpinLock;
863: USHORT ReferenceCount;
864: BOOLEAN Closing;
865: } REFERENCE, * PREFERENCE;
866:
867:
868: //
869: // This holds a map register entry.
870: //
871:
872: typedef struct _MAP_REGISTER_ENTRY {
873: PVOID MapRegister;
874: BOOLEAN WriteToDevice;
875: } MAP_REGISTER_ENTRY, * PMAP_REGISTER_ENTRY;
876:
877: //
878: // declare these first since they point to each other
879: //
880:
881: typedef struct _NDIS_WRAPPER_HANDLE NDIS_WRAPPER_HANDLE, * PNDIS_WRAPPER_HANDLE;
882: typedef struct _NDIS_MAC_BLOCK NDIS_MAC_BLOCK, * PNDIS_MAC_BLOCK;
883: typedef struct _NDIS_ADAPTER_BLOCK NDIS_ADAPTER_BLOCK, * PNDIS_ADAPTER_BLOCK;
884: typedef struct _NDIS_PROTOCOL_BLOCK NDIS_PROTOCOL_BLOCK, * PNDIS_PROTOCOL_BLOCK;
885: typedef struct _NDIS_OPEN_BLOCK NDIS_OPEN_BLOCK, * PNDIS_OPEN_BLOCK;
886:
887:
888: //
889: // MAC specific considerations.
890: //
891:
892: struct _NDIS_WRAPPER_HANDLE {
893:
894: //
895: // These store the PDRIVER_OBJECT that
896: // the MAC passes to NdisInitializeWrapper until it can be
897: // used by NdisRegisterMac and NdisTerminateWrapper.
898: //
899:
900: PDRIVER_OBJECT NdisWrapperDriver;
901:
902: HANDLE NdisWrapperConfigurationHandle;
903:
904: };
905:
906:
907:
908:
909: //
910: // one of these per MAC
911: //
912:
913: struct _NDIS_MAC_BLOCK {
914: PNDIS_ADAPTER_BLOCK AdapterQueue; // queue of adapters for this MAC
915: NDIS_HANDLE MacMacContext; // Context for calling MACUnload and
916: // MACAddAdapter.
917:
918: REFERENCE Ref; // contains spinlock for AdapterQueue
919: UINT Length; // of this NDIS_MAC_BLOCK structure
920: NDIS_MAC_CHARACTERISTICS MacCharacteristics; // handler addresses
921: PNDIS_WRAPPER_HANDLE NdisMacInfo; // Mac information.
922: PNDIS_MAC_BLOCK NextMac;
923: KEVENT AdaptersRemovedEvent; // used to find when all adapters are gone.
924: BOOLEAN Unloading; // TRUE if unloading
925:
926: };
927:
928: //
929: // one of these per adapter registered on a MAC
930: //
931:
932: struct _NDIS_ADAPTER_BLOCK {
933: PDEVICE_OBJECT DeviceObject; // created by NdisRegisterAdapter
934: PNDIS_MAC_BLOCK MacHandle; // pointer to our MAC block
935: NDIS_HANDLE MacAdapterContext; // context when calling MacOpenAdapter
936: NDIS_STRING AdapterName; // how NdisOpenAdapter refers to us
937: PNDIS_OPEN_BLOCK OpenQueue; // queue of opens for this adapter
938: PNDIS_ADAPTER_BLOCK NextAdapter; // used by MAC's AdapterQueue
939: REFERENCE Ref; // contains spinlock for OpenQueue
940: BOOLEAN BeingRemoved; // TRUE if adapter is being removed
941:
942: //
943: // Resource information
944: //
945: PCM_RESOURCE_LIST Resources;
946:
947: //
948: // Handling of shutdown
949: //
950: ADAPTER_SHUTDOWN_HANDLER ShutdownRoutine;
951: PVOID ShutdownContext;
952:
953: //
954: // contains adapter information
955: //
956: ULONG BusNumber;
957: NDIS_INTERFACE_TYPE BusType;
958: ULONG ChannelNumber;
959: NDIS_INTERFACE_TYPE AdapterType;
960: BOOLEAN Master;
961: ULONG PhysicalMapRegistersNeeded;
962: ULONG MaximumPhysicalMapping;
963: ULONG InitialPort;
964: ULONG NumberOfPorts;
965:
966: //
967: // Holds the mapping for ports, if needed.
968: //
969: PUCHAR InitialPortMapping;
970:
971: //
972: // TRUE if InitialPortMapping was mapped with NdisMapIoSpace.
973: //
974: BOOLEAN InitialPortMapped;
975:
976: //
977: // This is the offset added to the port passed to NdisXXXPort to
978: // get to the real value to be passed to the NDIS_XXX_PORT macros.
979: // It equals InitialPortMapping - InitialPort; that is, the
980: // mapped "address" of port 0, even if we didn't actually
981: // map port 0.
982: //
983: PUCHAR PortOffset;
984:
985: //
986: // Holds the map registers for this adapter.
987: //
988: PMAP_REGISTER_ENTRY MapRegisters;
989:
990: //
991: // These two are used temporarily while allocating
992: // the map registers.
993: //
994: KEVENT AllocationEvent;
995: UINT CurrentMapRegister;
996: PADAPTER_OBJECT SystemAdapterObject;
997:
998: };
999:
1000: //
1001: // one of these per protocol registered
1002: //
1003:
1004: struct _NDIS_PROTOCOL_BLOCK {
1005: PNDIS_OPEN_BLOCK OpenQueue; // queue of opens for this protocol
1006: REFERENCE Ref; // contains spinlock for OpenQueue
1007: UINT Length; // of this NDIS_PROTOCOL_BLOCK struct
1008: NDIS_PROTOCOL_CHARACTERISTICS ProtocolCharacteristics; // handler addresses
1009: };
1010:
1011: //
1012: // one of these per open on an adapter/protocol
1013: //
1014:
1015: struct _NDIS_OPEN_BLOCK {
1016: PNDIS_MAC_BLOCK MacHandle; // pointer to our MAC
1017: NDIS_HANDLE MacBindingHandle; // context when calling MacXX funcs
1018: PNDIS_ADAPTER_BLOCK AdapterHandle; // pointer to our adapter
1019: PNDIS_PROTOCOL_BLOCK ProtocolHandle; // pointer to our protocol
1020: NDIS_HANDLE ProtocolBindingContext; // context when calling ProtXX funcs
1021: PNDIS_OPEN_BLOCK AdapterNextOpen; // used by adapter's OpenQueue
1022: PNDIS_OPEN_BLOCK ProtocolNextOpen; // used by protocol's OpenQueue
1023: PFILE_OBJECT FileObject; // created by operating system
1024: BOOLEAN Closing; // TRUE when removing this struct
1025: NDIS_HANDLE CloseRequestHandle; // 0 indicates an internal close
1026: NDIS_SPIN_LOCK SpinLock; // guards Closing
1027:
1028: //
1029: // These are optimizations for getting to MAC routines. They are not
1030: // necessary, but are here to save a dereference through the MAC block.
1031: //
1032:
1033: SEND_HANDLER SendHandler;
1034: TRANSFER_DATA_HANDLER TransferDataHandler;
1035:
1036: //
1037: // These are optimizations for getting to PROTOCOL routines. They are not
1038: // necessary, but are here to save a dereference through the PROTOCOL block.
1039: //
1040:
1041: SEND_COMPLETE_HANDLER SendCompleteHandler;
1042: TRANSFER_DATA_COMPLETE_HANDLER TransferDataCompleteHandler;
1043: RECEIVE_HANDLER ReceiveHandler;
1044: RECEIVE_COMPLETE_HANDLER ReceiveCompleteHandler;
1045:
1046: };
1047:
1048: //
1049: // Types of Memory (not mutually exclusive)
1050: //
1051:
1052: #define NDIS_MEMORY_CONTIGUOUS 0x00000001
1053: #define NDIS_MEMORY_NONCACHED 0x00000002
1054:
1055: //
1056: // Open options
1057: //
1058: #define NDIS_OPEN_RECEIVE_NOT_REENTRANT 0x00000001
1059:
1060: //
1061: // NDIS_STATUS values
1062: //
1063:
1064: #define NDIS_STATUS_SUCCESS ((NDIS_STATUS) STATUS_SUCCESS)
1065: #define NDIS_STATUS_PENDING ((NDIS_STATUS) STATUS_PENDING)
1066: #define NDIS_STATUS_NOT_RECOGNIZED ((NDIS_STATUS)0x00010001L)
1067: #define NDIS_STATUS_NOT_COPIED ((NDIS_STATUS)0x00010002L)
1068:
1069: #define NDIS_STATUS_ONLINE ((NDIS_STATUS)0x40010003L)
1070: #define NDIS_STATUS_RESET_START ((NDIS_STATUS)0x40010004L)
1071: #define NDIS_STATUS_RESET_END ((NDIS_STATUS)0x40010005L)
1072: #define NDIS_STATUS_RING_STATUS ((NDIS_STATUS)0x40010006L)
1073: #define NDIS_STATUS_CLOSED ((NDIS_STATUS)0x40010007L)
1074: #define NDIS_STATUS_WAN_LINE_UP ((NDIS_STATUS)0x40010008L)
1075: #define NDIS_STATUS_WAN_LINE_DOWN ((NDIS_STATUS)0x40010009L)
1076: #define NDIS_STATUS_WAN_FRAGMENT ((NDIS_STATUS)0x4001000AL)
1077:
1078: #define NDIS_STATUS_NOT_RESETTABLE ((NDIS_STATUS)0x80010001L)
1079: #define NDIS_STATUS_SOFT_ERRORS ((NDIS_STATUS)0x80010003L)
1080: #define NDIS_STATUS_HARD_ERRORS ((NDIS_STATUS)0x80010004L)
1081:
1082: #define NDIS_STATUS_FAILURE ((NDIS_STATUS) STATUS_UNSUCCESSFUL)
1083: #define NDIS_STATUS_RESOURCES ((NDIS_STATUS) \
1084: STATUS_INSUFFICIENT_RESOURCES)
1085: #define NDIS_STATUS_CLOSING ((NDIS_STATUS)0xC0010002L)
1086: #define NDIS_STATUS_BAD_VERSION ((NDIS_STATUS)0xC0010004L)
1087: #define NDIS_STATUS_BAD_CHARACTERISTICS ((NDIS_STATUS)0xC0010005L)
1088: #define NDIS_STATUS_ADAPTER_NOT_FOUND ((NDIS_STATUS)0xC0010006L)
1089: #define NDIS_STATUS_OPEN_FAILED ((NDIS_STATUS)0xC0010007L)
1090: #define NDIS_STATUS_DEVICE_FAILED ((NDIS_STATUS)0xC0010008L)
1091: #define NDIS_STATUS_MULTICAST_FULL ((NDIS_STATUS)0xC0010009L)
1092: #define NDIS_STATUS_MULTICAST_EXISTS ((NDIS_STATUS)0xC001000AL)
1093: #define NDIS_STATUS_MULTICAST_NOT_FOUND ((NDIS_STATUS)0xC001000BL)
1094: #define NDIS_STATUS_REQUEST_ABORTED ((NDIS_STATUS)0xC001000CL)
1095: #define NDIS_STATUS_RESET_IN_PROGRESS ((NDIS_STATUS)0xC001000DL)
1096: #define NDIS_STATUS_CLOSING_INDICATING ((NDIS_STATUS)0xC001000EL)
1097: #define NDIS_STATUS_NOT_SUPPORTED ((NDIS_STATUS)STATUS_NOT_SUPPORTED)
1098: #define NDIS_STATUS_INVALID_PACKET ((NDIS_STATUS)0xC001000FL)
1099: #define NDIS_STATUS_OPEN_LIST_FULL ((NDIS_STATUS)0xC0010010L)
1100: #define NDIS_STATUS_ADAPTER_NOT_READY ((NDIS_STATUS)0xC0010011L)
1101: #define NDIS_STATUS_ADAPTER_NOT_OPEN ((NDIS_STATUS)0xC0010012L)
1102: #define NDIS_STATUS_NOT_INDICATING ((NDIS_STATUS)0xC0010013L)
1103: #define NDIS_STATUS_INVALID_LENGTH ((NDIS_STATUS)0xC0010014L)
1104: #define NDIS_STATUS_INVALID_DATA ((NDIS_STATUS)0xC0010015L)
1105: #define NDIS_STATUS_BUFFER_TOO_SHORT ((NDIS_STATUS)0xC0010016L)
1106: #define NDIS_STATUS_INVALID_OID ((NDIS_STATUS)0xC0010017L)
1107: #define NDIS_STATUS_ADAPTER_REMOVED ((NDIS_STATUS)0xC0010018L)
1108: #define NDIS_STATUS_UNSUPPORTED_MEDIA ((NDIS_STATUS)0xC0010019L)
1109: #define NDIS_STATUS_GROUP_ADDRESS_IN_USE ((NDIS_STATUS)0xC001001AL)
1110: #define NDIS_STATUS_FILE_NOT_FOUND ((NDIS_STATUS)0xC001001BL)
1111: #define NDIS_STATUS_ERROR_READING_FILE ((NDIS_STATUS)0xC001001CL)
1112: #define NDIS_STATUS_ALREADY_MAPPED ((NDIS_STATUS)0xC001001DL)
1113: #define NDIS_STATUS_RESOURCE_CONFLICT ((NDIS_STATUS)0xC001001EL)
1114:
1115: #define NDIS_STATUS_TOKEN_RING_OPEN_ERROR ((NDIS_STATUS)0xC0011000L)
1116:
1117:
1118: //
1119: // used in error logging
1120: //
1121:
1122: #define NDIS_ERROR_CODE ULONG
1123:
1124: #define NDIS_ERROR_CODE_RESOURCE_CONFLICT EVENT_NDIS_RESOURCE_CONFLICT
1125: #define NDIS_ERROR_CODE_OUT_OF_RESOURCES EVENT_NDIS_OUT_OF_RESOURCE
1126: #define NDIS_ERROR_CODE_HARDWARE_FAILURE EVENT_NDIS_HARDWARE_FAILURE
1127: #define NDIS_ERROR_CODE_ADAPTER_NOT_FOUND EVENT_NDIS_ADAPTER_NOT_FOUND
1128: #define NDIS_ERROR_CODE_INTERRUPT_CONNECT EVENT_NDIS_INTERRUPT_CONNECT
1129: #define NDIS_ERROR_CODE_DRIVER_FAILURE EVENT_NDIS_DRIVER_FAILURE
1130: #define NDIS_ERROR_CODE_BAD_VERSION EVENT_NDIS_BAD_VERSION
1131: #define NDIS_ERROR_CODE_TIMEOUT EVENT_NDIS_TIMEOUT
1132: #define NDIS_ERROR_CODE_NETWORK_ADDRESS EVENT_NDIS_NETWORK_ADDRESS
1133: #define NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION EVENT_NDIS_UNSUPPORTED_CONFIGURATION
1134: #define NDIS_ERROR_CODE_INVALID_VALUE_FROM_ADAPTER EVENT_NDIS_INVALID_VALUE_FROM_ADAPTER
1135: #define NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER EVENT_NDIS_MISSING_CONFIGURATION_PARAMETER
1136: #define NDIS_ERROR_CODE_BAD_IO_BASE_ADDRESS EVENT_NDIS_BAD_IO_BASE_ADDRESS
1137: #define NDIS_ERROR_CODE_RECEIVE_SPACE_SMALL EVENT_NDIS_RECEIVE_SPACE_SMALL
1138: #define NDIS_ERROR_CODE_ADAPTER_DISABLED EVENT_NDIS_ADAPTER_DISABLED
1139:
1140:
1141:
1142: #define INTERNAL
1143:
1144:
1145:
1146: //
1147: // Ndis Spin Locks
1148: //
1149:
1150: /*++
1151:
1152: VOID
1153: NdisAllocateSpinLock(
1154: IN PNDIS_SPIN_LOCK SpinLock;
1155: );
1156:
1157: --*/
1158:
1159:
1160: #ifdef NDISDBG
1161: #define NdisAllocateSpinLock(_SpinLock) { \
1162: IF_TRACE(TRACE_ALL) { \
1163: NdisPrint1("==>NdisAllocateSpinLock\n"); \
1164: } \
1165: KeInitializeSpinLock(&(_SpinLock)->SpinLock); \
1166: IF_TRACE(TRACE_ALL) { \
1167: NdisPrint1("<==NdisAllocateSpinLock\n"); \
1168: } \
1169: }
1170: #else
1171: #define NdisAllocateSpinLock(_SpinLock) { \
1172: KeInitializeSpinLock(&(_SpinLock)->SpinLock); \
1173: }
1174: #endif
1175:
1176: /*++
1177:
1178: VOID
1179: NdisFreeSpinLock(
1180: IN PNDIS_SPIN_LOCK SpinLock;
1181: );
1182:
1183: --*/
1184:
1185: #ifdef NDISDBG
1186: #define NdisFreeSpinLock(_SpinLock) { \
1187: IF_TRACE(TRACE_ALL) { \
1188: NdisPrint1("==>NdisFreeSpinLock\n"); \
1189: } \
1190: IF_TRACE(TRACE_ALL) { \
1191: NdisPrint1("<==NdisFreeSpinLock\n"); \
1192: } \
1193: }
1194: #else
1195: #define NdisFreeSpinLock(_SpinLock) { \
1196: }
1197: #endif
1198:
1199:
1200: /*++
1201:
1202: VOID
1203: NdisAcquireSpinLock(
1204: IN PNDIS_SPIN_LOCK SpinLock;
1205: );
1206:
1207: --*/
1208:
1209: #ifdef NDISDBG
1210: #define NdisAcquireSpinLock(_SpinLock) { \
1211: KIRQL OldIrql; \
1212: IF_TRACE(TRACE_ALL) { \
1213: NdisPrint1("==>NdisAcquireSpinLock\n"); \
1214: } \
1215: KeAcquireSpinLock(&(_SpinLock)->SpinLock, &OldIrql); \
1216: (_SpinLock)->OldIrql = OldIrql; \
1217: IF_TRACE(TRACE_ALL) { \
1218: NdisPrint1("<==NdisAcquireSpinLock\n"); \
1219: } \
1220: }
1221: #else
1222: #define NdisAcquireSpinLock(_SpinLock) { \
1223: KeAcquireSpinLock(&(_SpinLock)->SpinLock, &(_SpinLock)->OldIrql); \
1224: }
1225: #endif
1226:
1227:
1228: /*++
1229:
1230: VOID
1231: NdisReleaseSpinLock(
1232: IN PNDIS_SPIN_LOCK SpinLock;
1233: );
1234:
1235: --*/
1236:
1237: #ifdef NDISDBG
1238: #define NdisReleaseSpinLock(_SpinLock) { \
1239: KIRQL CurrentIrql = (_SpinLock)->OldIrql; \
1240: IF_TRACE(TRACE_ALL) { \
1241: NdisPrint1("==>NdisReleaseSpinLock \n"); \
1242: } \
1243: KeReleaseSpinLock(&(_SpinLock)->SpinLock, CurrentIrql); \
1244: IF_TRACE(TRACE_ALL) { \
1245: NdisPrint1("<==NdisReleaseSpinLock\n"); \
1246: }\
1247: }
1248: #else
1249: #define NdisReleaseSpinLock(_SpinLock) { \
1250: KeReleaseSpinLock(&(_SpinLock)->SpinLock,(_SpinLock)->OldIrql); \
1251: }
1252: #endif
1253:
1254: /*++
1255:
1256: VOID
1257: NdisDprAcquireSpinLock(
1258: IN PNDIS_SPIN_LOCK SpinLock;
1259: );
1260:
1261: --*/
1262:
1263: #ifdef NDISDBG
1264: #define NdisDprAcquireSpinLock(_SpinLock) { \
1265: IF_TRACE(TRACE_ALL) { \
1266: NdisPrint1("==>NdisDprAcquireSpinLock\n"); \
1267: } \
1268: KeAcquireSpinLockAtDpcLevel(&(_SpinLock)->SpinLock); \
1269: (_SpinLock)->OldIrql = DISPATCH_LEVEL; \
1270: IF_TRACE(TRACE_ALL) { \
1271: NdisPrint1("<==NdisDprAcquireSpinLock\n"); \
1272: } \
1273: }
1274: #else
1275: #define NdisDprAcquireSpinLock(_SpinLock) { \
1276: KeAcquireSpinLockAtDpcLevel(&(_SpinLock)->SpinLock); \
1277: (_SpinLock)->OldIrql = DISPATCH_LEVEL; \
1278: }
1279: #endif
1280:
1281:
1282: /*++
1283:
1284: VOID
1285: NdisDprReleaseSpinLock(
1286: IN PNDIS_SPIN_LOCK SpinLock;
1287: );
1288:
1289: --*/
1290:
1291: #ifdef NDISDBG
1292: #define NdisDprReleaseSpinLock(_SpinLock) { \
1293: IF_TRACE(TRACE_ALL) { \
1294: NdisPrint1("==>NdisDprReleaseSpinLock \n"); \
1295: } \
1296: KeReleaseSpinLockFromDpcLevel(&(_SpinLock)->SpinLock); \
1297: IF_TRACE(TRACE_ALL) { \
1298: NdisPrint1("<==NdisDprReleaseSpinLock\n"); \
1299: }\
1300: }
1301: #else
1302: #define NdisDprReleaseSpinLock(_SpinLock) { \
1303: KeReleaseSpinLockFromDpcLevel(&(_SpinLock)->SpinLock); \
1304: }
1305: #endif
1306:
1307:
1308:
1309: //
1310: // Interlocked support functions
1311: //
1312:
1313: /*++
1314:
1315: VOID
1316: NdisInterlockedAddUlong(
1317: IN PULONG Addend,
1318: IN ULONG Increment,
1319: IN PNDIS_SPIN_LOCK SpinLock
1320: );
1321:
1322: --*/
1323:
1324: #define NdisInterlockedAddUlong(_Addend, _Increment, _SpinLock) \
1325: ExInterlockedAddUlong(_Addend, _Increment, &(_SpinLock)->SpinLock)
1326:
1327:
1328: /*++
1329:
1330: PLIST_ENTRY
1331: NdisInterlockedInsertHeadList(
1332: IN PLIST_ENTRY ListHead,
1333: IN PLIST_ENTRY ListEntry,
1334: IN PNDIS_SPIN_LOCK SpinLock
1335: );
1336:
1337: --*/
1338:
1339: #define NdisInterlockedInsertHeadList(_ListHead, _ListEntry, _SpinLock) \
1340: ExInterlockedInsertHeadList(_ListHead, _ListEntry, &(_SpinLock)->SpinLock)
1341:
1342:
1343: /*++
1344:
1345: PLIST_ENTRY
1346: NdisInterlockedInsertTailList(
1347: IN PLIST_ENTRY ListHead,
1348: IN PLIST_ENTRY ListEntry,
1349: IN PNDIS_SPIN_LOCK SpinLock
1350: );
1351:
1352: --*/
1353:
1354: #define NdisInterlockedInsertTailList(_ListHead, _ListEntry, _SpinLock) \
1355: ExInterlockedInsertTailList(_ListHead, _ListEntry, &(_SpinLock)->SpinLock)
1356:
1357:
1358: /*++
1359:
1360: PLIST_ENTRY
1361: NdisInterlockedRemoveHeadList(
1362: IN PLIST_ENTRY ListHead,
1363: IN PNDIS_SPIN_LOCK SpinLock
1364: );
1365:
1366: --*/
1367:
1368: #define NdisInterlockedRemoveHeadList(_ListHead, _SpinLock) \
1369: ExInterlockedRemoveHeadList(_ListHead, &(_SpinLock)->SpinLock)
1370:
1371:
1372: //
1373: // Routines to access packet flags
1374: //
1375:
1376: /*++
1377:
1378: VOID
1379: NdisSetSendFlags(
1380: IN PNDIS_PACKET Packet,
1381: IN UINT Flags
1382: );
1383:
1384: --*/
1385:
1386: #define NdisSetSendFlags(_Packet,_Flags) \
1387: (_Packet)->Private.Flags = (_Flags)
1388:
1389: /*++
1390:
1391: VOID
1392: NdisQuerySendFlags(
1393: IN PNDIS_PACKET Packet,
1394: OUT PUINT Flags
1395: );
1396:
1397: --*/
1398:
1399: #define NdisQuerySendFlags(_Packet,_Flags) \
1400: *(_Flags) = (_Packet)->Private.Flags
1401:
1402:
1403:
1404:
1405: //
1406: // general reference/dereference functions
1407: //
1408:
1409: INTERNAL
1410: BOOLEAN
1411: NdisReferenceRef(
1412: IN PREFERENCE RefP
1413: );
1414:
1415:
1416: INTERNAL
1417: BOOLEAN
1418: NdisDereferenceRef(
1419: PREFERENCE RefP
1420: );
1421:
1422:
1423: INTERNAL
1424: VOID
1425: NdisInitializeRef(
1426: PREFERENCE RefP
1427: );
1428:
1429:
1430: INTERNAL
1431: BOOLEAN
1432: NdisCloseRef(
1433: PREFERENCE RefP
1434: );
1435:
1436:
1437: /*++
1438: INTERNAL
1439: BOOLEAN
1440: NdisReferenceProtocol(
1441: IN PNDIS_PROTOCOL_BLOCK ProtP
1442: );
1443: --*/
1444:
1445: #define NdisReferenceProtocol(ProtP) \
1446: NdisReferenceRef(&(ProtP)->Ref)
1447:
1448:
1449:
1450: INTERNAL
1451: BOOLEAN
1452: QueueOpenOnProtocol(
1453: IN PNDIS_OPEN_BLOCK OpenP,
1454: IN PNDIS_PROTOCOL_BLOCK ProtP
1455: );
1456:
1457:
1458: /*++
1459: INTERNAL
1460: VOID
1461: NdisDereferenceProtocol(
1462: PNDIS_PROTOCOL_BLOCK ProtP
1463: );
1464: --*/
1465: #define NdisDereferenceProtocol(ProtP) { \
1466: if (NdisDereferenceRef(&(ProtP)->Ref)) { \
1467: ExFreePool((PVOID)(ProtP)); \
1468: } \
1469: }
1470:
1471:
1472:
1473: INTERNAL
1474: VOID
1475: NdisDeQueueOpenOnProtocol(
1476: PNDIS_OPEN_BLOCK OpenP,
1477: PNDIS_PROTOCOL_BLOCK ProtP
1478: );
1479:
1480:
1481: INTERNAL
1482: BOOLEAN
1483: NdisFinishOpen(
1484: PNDIS_OPEN_BLOCK OpenP
1485: );
1486:
1487:
1488: INTERNAL
1489: VOID
1490: NdisKillOpenAndNotifyProtocol(
1491: PNDIS_OPEN_BLOCK OldOpenP
1492: );
1493:
1494:
1495: INTERNAL
1496: BOOLEAN
1497: NdisKillOpen(
1498: PNDIS_OPEN_BLOCK OldOpenP
1499: );
1500:
1501: /*++
1502: INTERNAL
1503: BOOLEAN
1504: NdisReferenceMac(
1505: IN PNDIS_MAC_BLOCK MacP
1506: );
1507: --*/
1508: #define NdisReferenceMac(MacP) \
1509: NdisReferenceRef(&(MacP)->Ref)
1510:
1511: static
1512: VOID
1513: NdisDereferenceMac(
1514: PNDIS_MAC_BLOCK MacP
1515: );
1516:
1517: INTERNAL
1518: BOOLEAN
1519: NdisQueueAdapterOnMac(
1520: PNDIS_ADAPTER_BLOCK AdaptP,
1521: PNDIS_MAC_BLOCK MacP
1522: );
1523:
1524: INTERNAL
1525: VOID
1526: NdisDeQueueAdapterOnMac(
1527: PNDIS_ADAPTER_BLOCK AdaptP,
1528: PNDIS_MAC_BLOCK MacP
1529: );
1530:
1531: /*++
1532: INTERNAL
1533: BOOLEAN
1534: NdisReferenceAdapter(
1535: IN PNDIS_ADAPTER_BLOCK AdaptP
1536: );
1537: --*/
1538: #define NdisReferenceAdapter(AdaptP) \
1539: NdisReferenceRef(&(AdaptP)->Ref)
1540:
1541:
1542: INTERNAL
1543: BOOLEAN
1544: NdisQueueOpenOnAdapter(
1545: PNDIS_OPEN_BLOCK OpenP,
1546: PNDIS_ADAPTER_BLOCK AdaptP
1547: );
1548:
1549: INTERNAL
1550: VOID
1551: NdisKillAdapter(
1552: PNDIS_ADAPTER_BLOCK OldAdaptP
1553: );
1554:
1555: INTERNAL
1556: VOID
1557: NdisDereferenceAdapter(
1558: PNDIS_ADAPTER_BLOCK AdaptP
1559: );
1560:
1561: INTERNAL
1562: VOID
1563: NdisDeQueueOpenOnAdapter(
1564: PNDIS_OPEN_BLOCK OpenP,
1565: PNDIS_ADAPTER_BLOCK AdaptP
1566: );
1567:
1568: INTERNAL
1569: NDIS_STATUS
1570: NdisCallDriverAddAdapter(
1571: IN PNDIS_MAC_BLOCK NewMacP
1572: );
1573:
1574: //
1575: // Configuration Requests
1576: //
1577:
1578: VOID
1579: NdisOpenConfiguration(
1580: OUT PNDIS_STATUS Status,
1581: OUT PNDIS_HANDLE ConfigurationHandle,
1582: IN NDIS_HANDLE WrapperConfigurationContext
1583: );
1584:
1585: VOID
1586: NdisReadConfiguration(
1587: OUT PNDIS_STATUS Status,
1588: OUT PNDIS_CONFIGURATION_PARAMETER *ParameterValue,
1589: IN NDIS_HANDLE ConfigurationHandle,
1590: IN PNDIS_STRING Keyword,
1591: IN NDIS_PARAMETER_TYPE ParameterType
1592: );
1593:
1594: VOID
1595: NdisCloseConfiguration(
1596: IN NDIS_HANDLE ConfigurationHandle
1597: );
1598:
1599: VOID
1600: NdisReadNetworkAddress(
1601: OUT PNDIS_STATUS Status,
1602: OUT PVOID * NetworkAddress,
1603: OUT PUINT NetworkAddressLength,
1604: IN NDIS_HANDLE ConfigurationHandle
1605: );
1606:
1607: VOID
1608: NdisReadBindingInformation(
1609: OUT PNDIS_STATUS Status,
1610: OUT PNDIS_STRING * Binding,
1611: IN NDIS_HANDLE ConfigurationHandle
1612: );
1613:
1614:
1615: VOID
1616: NdisReadEisaSlotInformation(
1617: OUT PNDIS_STATUS Status,
1618: IN NDIS_HANDLE WrapperConfigurationContext,
1619: OUT PUINT SlotNumber,
1620: OUT PNDIS_EISA_FUNCTION_INFORMATION EisaData
1621: );
1622:
1623: VOID
1624: NdisReadEisaSlotInformationEx(
1625: OUT PNDIS_STATUS Status,
1626: IN NDIS_HANDLE WrapperConfigurationContext,
1627: OUT PUINT SlotNumber,
1628: OUT PNDIS_EISA_FUNCTION_INFORMATION *EisaData,
1629: OUT PUINT NumberOfFunctions
1630: );
1631:
1632: VOID
1633: NdisReadMcaPosInformation(
1634: OUT PNDIS_STATUS Status,
1635: IN NDIS_HANDLE WrapperConfigurationContext,
1636: IN PUINT ChannelNumber,
1637: OUT PNDIS_MCA_POS_DATA McaData
1638: );
1639:
1640: //
1641: // Packet and Buffer Requests
1642: //
1643:
1644: VOID
1645: NdisAllocatePacketPool(
1646: OUT PNDIS_STATUS Status,
1647: OUT PNDIS_HANDLE PoolHandle,
1648: IN UINT NumberOfDescriptors,
1649: IN UINT ProtocolReservedLength
1650: );
1651:
1652:
1653: #ifdef NDISDBG
1654: VOID
1655: NdisFreePacketPool(
1656: IN NDIS_HANDLE PoolHandle
1657: );
1658: #else
1659: #define NdisFreePacketPool(PoolHandle) {\
1660: NdisFreeSpinLock(&((PNDIS_PACKET_POOL)PoolHandle)->SpinLock);\
1661: ExFreePool(PoolHandle); \
1662: }
1663: #endif
1664:
1665: VOID
1666: NdisAllocateBufferPool(
1667: OUT PNDIS_STATUS Status,
1668: OUT PNDIS_HANDLE PoolHandle,
1669: IN UINT NumberOfDescriptors
1670: );
1671:
1672: VOID
1673: NdisFreeBufferPool(
1674: IN NDIS_HANDLE PoolHandle
1675: );
1676:
1677: VOID
1678: NdisAllocateBuffer(
1679: OUT PNDIS_STATUS Status,
1680: OUT PNDIS_BUFFER * Buffer,
1681: IN NDIS_HANDLE PoolHandle,
1682: IN PVOID VirtualAddress,
1683: IN UINT Length
1684: );
1685:
1686:
1687: VOID
1688: NdisCopyBuffer(
1689: OUT PNDIS_STATUS Status,
1690: OUT PNDIS_BUFFER * Buffer,
1691: IN NDIS_HANDLE PoolHandle,
1692: IN PVOID MemoryDescriptor,
1693: IN UINT Offset,
1694: IN UINT Length
1695: );
1696:
1697:
1698: /*++
1699:
1700: VOID
1701: NdisFreeBuffer(
1702: IN PNDIS_BUFFER Buffer
1703: );
1704:
1705: --*/
1706:
1707: #define NdisFreeBuffer(Buffer) \
1708: IoFreeMdl(Buffer)
1709:
1710:
1711:
1712: VOID
1713: NdisQueryBuffer(
1714: IN PNDIS_BUFFER Buffer,
1715: OUT PVOID * VirtualAddress,
1716: OUT PUINT Length
1717: );
1718:
1719:
1720: /*++
1721:
1722: VOID
1723: NdisGetBufferPhysicalArraySize(
1724: IN PNDIS_BUFFER Buffer,
1725: OUT PUINT ArraySize
1726: );
1727:
1728: --*/
1729:
1730: #define NdisGetBufferPhysicalArraySize(Buffer, ArraySize) \
1731: (*(ArraySize) = NDIS_BUFFER_TO_SPAN_PAGES(Buffer))
1732:
1733:
1734:
1735:
1736: /*++
1737: VOID
1738: NdisBufferGetSystemSpecific(
1739: IN PNDIS_BUFFER Buffer,
1740: OUT PVOID * SystemSpecific
1741: );
1742: --*/
1743:
1744: //
1745: //BUGBUG: What's system specific about this buffer anyway....
1746: // Ask adam when he comes back.
1747: #define NdisBufferGetSystemSpecific(Buffer, SystemSpecific) \
1748: *(SystemSpecific) = (Buffer)
1749:
1750:
1751: /*++
1752:
1753: VOID
1754: NdisAdjustBufferLength(
1755: IN PNDIS_BUFFER Buffer,
1756: IN UINT Length
1757: );
1758:
1759: --*/
1760:
1761: #define NdisAdjustBufferLength(Buffer, Length) \
1762: (((Buffer)->ByteCount) = (Length))
1763:
1764:
1765: /*++
1766:
1767: NDIS_BUFFER_LINKAGE(
1768: IN PNDIS_BUFFER Buffer
1769: );
1770:
1771: --*/
1772:
1773: #define NDIS_BUFFER_LINKAGE(Buffer) \
1774: ((Buffer)->Next)
1775:
1776:
1777:
1778: VOID
1779: NdisAllocatePacket(
1780: OUT PNDIS_STATUS Status,
1781: OUT PNDIS_PACKET * Packet,
1782: IN NDIS_HANDLE PoolHandle
1783: );
1784:
1785:
1786: #ifdef NDISDBG
1787: VOID
1788: NdisFreePacket(
1789: IN PNDIS_PACKET Packet
1790: );
1791: #else
1792: #define NdisFreePacket(Packet) {\
1793: NdisAcquireSpinLock(&(Packet)->Private.Pool->SpinLock); \
1794: (Packet)->Private.Head = (PNDIS_BUFFER)(Packet)->Private.Pool->FreeList; \
1795: (Packet)->Private.Pool->FreeList = (Packet); \
1796: NdisReleaseSpinLock(&(Packet)->Private.Pool->SpinLock); \
1797: }
1798: #endif
1799:
1800:
1801: #ifdef NDISDBG
1802: VOID
1803: NdisReinitializePacket( \
1804: IN OUT PNDIS_PACKET Packet \
1805: );
1806: #else
1807: #define NdisReinitializePacket(Packet) { \
1808: (Packet)->Private.Head = (PNDIS_BUFFER)NULL; \
1809: (Packet)->Private.ValidCounts = FALSE; \
1810: }
1811: #endif
1812:
1813:
1814: /*++
1815:
1816: VOID
1817: NdisRecalculatePacketCounts(
1818: IN OUT PNDIS_PACKET Packet
1819: );
1820:
1821: --*/
1822:
1823: #define NdisRecalculatePacketCounts(Packet) { \
1824: { \
1825: PNDIS_BUFFER TmpBuffer = (Packet)->Private.Head; \
1826: if (TmpBuffer) { \
1827: while (TmpBuffer->Next) { \
1828: TmpBuffer = TmpBuffer->Next; \
1829: } \
1830: (Packet)->Private.Tail = TmpBuffer; \
1831: } \
1832: (Packet)->Private.ValidCounts = FALSE; \
1833: } \
1834: }
1835:
1836:
1837: #ifdef NDISDBG
1838: VOID
1839: NdisChainBufferAtFront(
1840: IN OUT PNDIS_PACKET Packet,
1841: IN OUT PNDIS_BUFFER Buffer
1842: );
1843: #else
1844: #define NdisChainBufferAtFront(Packet, Buffer) { \
1845: PNDIS_BUFFER TmpBuffer = (Buffer); \
1846: \
1847: for (;;) { \
1848: if (TmpBuffer->Next == (PNDIS_BUFFER)NULL) \
1849: break; \
1850: TmpBuffer = TmpBuffer->Next; \
1851: } \
1852: if ((Packet)->Private.Head == (PNDIS_BUFFER)NULL) { \
1853: (Packet)->Private.Tail = TmpBuffer; \
1854: } \
1855: TmpBuffer->Next = (Packet)->Private.Head; \
1856: (Packet)->Private.Head = (Buffer); \
1857: (Packet)->Private.ValidCounts = FALSE; \
1858: }
1859: #endif
1860:
1861: #ifdef NDISDBG
1862: VOID
1863: NdisChainBufferAtBack(
1864: IN OUT PNDIS_PACKET Packet,
1865: IN OUT PNDIS_BUFFER Buffer
1866: );
1867: #else
1868: #define NdisChainBufferAtBack(Packet, Buffer) { \
1869: PNDIS_BUFFER TmpBuffer = (Buffer); \
1870: \
1871: for (;;) { \
1872: if (TmpBuffer->Next == (PNDIS_BUFFER)NULL) \
1873: break; \
1874: TmpBuffer = TmpBuffer->Next; \
1875: } \
1876: if ((Packet)->Private.Head != (PNDIS_BUFFER)NULL) { \
1877: (Packet)->Private.Tail->Next = (Buffer); \
1878: } else { \
1879: (Packet)->Private.Head = (Buffer); \
1880: } \
1881: (Packet)->Private.Tail = TmpBuffer; \
1882: TmpBuffer->Next = (PNDIS_BUFFER)NULL; \
1883: (Packet)->Private.ValidCounts = FALSE; \
1884: }
1885: #endif
1886:
1887: VOID
1888: NdisUnchainBufferAtFront(
1889: IN OUT PNDIS_PACKET Packet,
1890: OUT PNDIS_BUFFER * Buffer
1891: );
1892:
1893: VOID
1894: NdisUnchainBufferAtBack(
1895: IN OUT PNDIS_PACKET Packet,
1896: OUT PNDIS_BUFFER * Buffer
1897: );
1898:
1899:
1900: #ifdef NDISDBG
1901: VOID
1902: NdisQueryPacket(
1903: IN PNDIS_PACKET Packet,
1904: OUT PUINT PhysicalBufferCount OPTIONAL,
1905: OUT PUINT BufferCount OPTIONAL,
1906: OUT PNDIS_BUFFER * FirstBuffer OPTIONAL,
1907: OUT PUINT TotalPacketLength OPTIONAL
1908: );
1909: #else
1910: #define NdisQueryPacket(Packet, PhysicalBufferCount, BufferCount, FirstBuffer, TotalPacketLength) \
1911: { \
1912: PNDIS_PACKET _Packet = Packet; \
1913: PUINT _PhysicalBufferCount = PhysicalBufferCount; \
1914: PUINT _BufferCount = BufferCount; \
1915: PNDIS_BUFFER *_FirstBuffer = FirstBuffer; \
1916: PUINT _TotalPacketLength = TotalPacketLength; \
1917: \
1918: if (_FirstBuffer) *_FirstBuffer = (Packet)->Private.Head; \
1919: if (_PhysicalBufferCount || _BufferCount || _TotalPacketLength) { \
1920: if (!(Packet)->Private.ValidCounts) { \
1921: PNDIS_BUFFER TmpBuffer = (Packet)->Private.Head; \
1922: UINT PTotalLength = 0, PPhysicalCount = 0, PAddedCount = 0; \
1923: \
1924: while (TmpBuffer != (PNDIS_BUFFER)NULL) { \
1925: PTotalLength += MmGetMdlByteCount(TmpBuffer); \
1926: PPhysicalCount += NDIS_BUFFER_TO_SPAN_PAGES(TmpBuffer); \
1927: ++PAddedCount; \
1928: TmpBuffer = TmpBuffer->Next; \
1929: } \
1930: (Packet)->Private.Count = PAddedCount; \
1931: (Packet)->Private.TotalLength = PTotalLength; \
1932: (Packet)->Private.PhysicalCount = PPhysicalCount; \
1933: (Packet)->Private.ValidCounts = TRUE; \
1934: } \
1935: if (_PhysicalBufferCount) *_PhysicalBufferCount = (Packet)->Private.PhysicalCount; \
1936: if (_BufferCount) *_BufferCount = (Packet)->Private.Count; \
1937: if (_TotalPacketLength) *_TotalPacketLength = (Packet)->Private.TotalLength; \
1938: } \
1939: }
1940: #endif
1941:
1942:
1943: #ifdef NDISDBG
1944: VOID
1945: NdisGetNextBuffer(
1946: IN PNDIS_BUFFER CurrentBuffer,
1947: OUT PNDIS_BUFFER * NextBuffer
1948: );
1949: #else
1950: #define NdisGetNextBuffer(CurrentBuffer, NextBuffer) {\
1951: *(NextBuffer) = (CurrentBuffer)->Next; \
1952: }
1953: #endif
1954:
1955:
1956: VOID
1957: NdisCopyFromPacketToPacket(
1958: IN PNDIS_PACKET Destination,
1959: IN UINT DestinationOffset,
1960: IN UINT BytesToCopy,
1961: IN PNDIS_PACKET Source,
1962: IN UINT SourceOffset,
1963: OUT PUINT BytesCopied
1964: );
1965:
1966:
1967: //
1968: // Operating System Requests
1969: //
1970:
1971: VOID
1972: NdisMapIoSpace(
1973: OUT PNDIS_STATUS Status,
1974: OUT PVOID * VirtualAddress,
1975: IN NDIS_HANDLE NdisAdapterHandle,
1976: IN NDIS_PHYSICAL_ADDRESS PhysicalAddress,
1977: IN UINT Length
1978: );
1979:
1980: #ifdef _ALPHA_
1981:
1982: /*++
1983: VOID
1984: NdisUnmapIoSpace(
1985: IN NDIS_HANDLE NdisAdapterHandle,
1986: IN PVOID VirtualAddress,
1987: IN UINT Length
1988: )
1989: --*/
1990: #define NdisUnmapIoSpace(Handle,VirtualAddress,Length) {}
1991:
1992: #else
1993:
1994: /*++
1995: VOID
1996: NdisUnmapIoSpace(
1997: IN NDIS_HANDLE NdisAdapterHandle,
1998: IN PVOID VirtualAddress,
1999: IN UINT Length
2000: )
2001: --*/
2002: #define NdisUnmapIoSpace(Handle,VirtualAddress,Length) \
2003: MmUnmapIoSpace((VirtualAddress), (Length));
2004:
2005: #endif
2006:
2007:
2008: NDIS_STATUS
2009: NdisAllocateMemory(
2010: OUT PVOID *VirtualAddress,
2011: IN UINT Length,
2012: IN UINT MemoryFlags,
2013: IN NDIS_PHYSICAL_ADDRESS HighestAcceptableAddress
2014: );
2015:
2016:
2017: VOID
2018: NdisFreeMemory(
2019: IN PVOID VirtualAddress,
2020: IN UINT Length,
2021: IN UINT MemoryFlags
2022: );
2023:
2024: typedef
2025: VOID
2026: (*PNDIS_TIMER_FUNCTION) (
2027: IN PVOID SystemSpecific1,
2028: IN PVOID FunctionContext,
2029: IN PVOID SystemSpecific2,
2030: IN PVOID SystemSpecific3
2031: );
2032:
2033: VOID
2034: NdisInitializeTimer(
2035: IN OUT PNDIS_TIMER Timer,
2036: IN PNDIS_TIMER_FUNCTION TimerFunction,
2037: IN PVOID FunctionContext
2038: );
2039:
2040: VOID
2041: NdisSetTimer(
2042: IN PNDIS_TIMER Timer,
2043: IN UINT MillisecondsToDelay
2044: );
2045:
2046: /*++
2047: VOID
2048: NdisCancelTimer(
2049: IN PNDIS_TIMER Timer,
2050: OUT PBOOLEAN TimerCancelled
2051: )
2052: --*/
2053: #define NdisCancelTimer(NdisTimer,TimerCancelled) \
2054: (*(TimerCancelled) = KeCancelTimer(&((NdisTimer)->Timer)))
2055:
2056: /*++
2057: VOID
2058: NdisStallExecution(
2059: IN UINT MicrosecondsToStall
2060: )
2061: --*/
2062:
2063: #define NdisStallExecution(MicroSecondsToStall) \
2064: KeStallExecutionProcessor(MicroSecondsToStall)
2065:
2066:
2067: VOID
2068: NdisInitializeInterrupt(
2069: OUT PNDIS_STATUS Status,
2070: IN OUT PNDIS_INTERRUPT Interrupt,
2071: IN NDIS_HANDLE NdisAdapterHandle,
2072: IN PNDIS_INTERRUPT_SERVICE InterruptServiceRoutine,
2073: IN PVOID InterruptContext,
2074: IN PNDIS_DEFERRED_PROCESSING DeferredProcessingRoutine,
2075: IN UINT InterruptVector,
2076: IN UINT InterruptLevel,
2077: IN BOOLEAN SharedInterrupt,
2078: IN NDIS_INTERRUPT_MODE InterruptMode
2079: );
2080:
2081: VOID
2082: NdisRemoveInterrupt(
2083: IN PNDIS_INTERRUPT Interrupt
2084: );
2085:
2086: /*++
2087: BOOLEAN
2088: NdisSynchronizeWithInterrupt(
2089: IN PNDIS_INTERRUPT Interrupt,
2090: IN PVOID SynchronizeFunction,
2091: IN PVOID SynchronizeContext
2092: )
2093: --*/
2094:
2095: #define NdisSynchronizeWithInterrupt(Interrupt,Function,Context) \
2096: KeSynchronizeExecution( \
2097: (Interrupt)->InterruptObject,\
2098: (PKSYNCHRONIZE_ROUTINE)Function,\
2099: Context \
2100: )
2101:
2102: //
2103: // Simple I/O support
2104: //
2105:
2106: VOID
2107: NdisOpenFile(
2108: OUT PNDIS_STATUS Status,
2109: OUT PNDIS_HANDLE FileHandle,
2110: OUT PUINT FileLength,
2111: IN PNDIS_STRING FileName,
2112: IN NDIS_PHYSICAL_ADDRESS HighestAcceptableAddress
2113: );
2114:
2115: VOID
2116: NdisCloseFile(
2117: IN NDIS_HANDLE FileHandle
2118: );
2119:
2120: VOID
2121: NdisMapFile(
2122: OUT PNDIS_STATUS Status,
2123: OUT PVOID * MappedBuffer,
2124: IN NDIS_HANDLE FileHandle
2125: );
2126:
2127: VOID
2128: NdisUnmapFile(
2129: IN NDIS_HANDLE FileHandle
2130: );
2131:
2132:
2133: //
2134: // Portability extensions
2135: //
2136:
2137: /*++
2138: VOID
2139: NdisFlushBuffer(
2140: IN PNDIS_BUFFER Buffer,
2141: IN BOOLEAN WriteToDevice
2142: )
2143: --*/
2144:
2145: #define NdisFlushBuffer(Buffer,WriteToDevice) \
2146: KeFlushIoBuffers((Buffer),!(WriteToDevice), TRUE)
2147:
2148:
2149: /*++
2150: ULONG
2151: NdisGetCacheFillSize(
2152: )
2153: --*/
2154: #define NdisGetCacheFillSize() \
2155: HalGetDmaAlignmentRequirement()
2156:
2157: //
2158: // This macro is used to convert a port number as the caller
2159: // thinks of it, to a port number as it should be passed to
2160: // READ/WRITE_PORT.
2161: //
2162:
2163: #define NDIS_PORT_TO_PORT(Handle,Port) (((PNDIS_ADAPTER_BLOCK)(Handle))->PortOffset + (Port))
2164:
2165:
2166: //
2167: // Write Port
2168: //
2169:
2170: /*++
2171: VOID
2172: NdisWritePortUchar(
2173: IN NDIS_HANDLE NdisAdapterHandle,
2174: IN ULONG Port,
2175: IN UCHAR Data
2176: )
2177: --*/
2178: #define NdisWritePortUchar(Handle,Port,Data) \
2179: WRITE_PORT_UCHAR((PUCHAR)(NDIS_PORT_TO_PORT(Handle,Port)),(UCHAR)(Data))
2180:
2181: /*++
2182: VOID
2183: NdisWritePortUshort(
2184: IN NDIS_HANDLE NdisAdapterHandle,
2185: IN ULONG Port,
2186: IN USHORT Data
2187: )
2188: --*/
2189: #define NdisWritePortUshort(Handle,Port,Data) \
2190: WRITE_PORT_USHORT((PUSHORT)(NDIS_PORT_TO_PORT(Handle,Port)),(USHORT)(Data))
2191:
2192:
2193: /*++
2194: VOID
2195: NdisWritePortUlong(
2196: IN NDIS_HANDLE NdisAdapterHandle,
2197: IN ULONG Port,
2198: IN ULONG Data
2199: )
2200: --*/
2201: #define NdisWritePortUlong(Handle,Port,Data) \
2202: WRITE_PORT_ULONG((PULONG)(NDIS_PORT_TO_PORT(Handle,Port)),(ULONG)(Data))
2203:
2204:
2205: //
2206: // Write Port Buffers
2207: //
2208:
2209: /*++
2210: VOID
2211: NdisWritePortBufferUchar(
2212: IN NDIS_HANDLE NdisAdapterHandle,
2213: IN ULONG Port,
2214: IN PUCHAR Buffer,
2215: IN ULONG Length
2216: )
2217: --*/
2218: #ifdef _M_IX86
2219: #define NdisWritePortBufferUchar(Handle,Port,Buffer,Length) \
2220: WRITE_PORT_BUFFER_UCHAR((PUCHAR)(NDIS_PORT_TO_PORT(Handle,Port)),(PUCHAR)(Buffer),(Length))
2221: #else
2222: #define NdisWritePortBufferUchar(Handle,Port,Buffer,Length) \
2223: { \
2224: ULONG _Port = (ULONG)NDIS_PORT_TO_PORT(Handle, Port); \
2225: PUCHAR _Current = (Buffer); \
2226: PUCHAR _End = _Current + (Length); \
2227: for ( ; _Current < _End; ++_Current) { \
2228: WRITE_PORT_UCHAR((PUCHAR)_Port,*_Current); \
2229: } \
2230: }
2231: #endif
2232:
2233: /*++
2234: VOID
2235: NdisWritePortBufferUshort(
2236: IN NDIS_HANDLE NdisAdapterHandle,
2237: IN ULONG Port,
2238: IN PUSHORT Buffer,
2239: IN ULONG Length
2240: )
2241: --*/
2242: #ifdef _M_IX86
2243: #define NdisWritePortBufferUshort(Handle,Port,Buffer,Length) \
2244: WRITE_PORT_BUFFER_USHORT((PUSHORT)(NDIS_PORT_TO_PORT(Handle,Port)),(PUSHORT)(Buffer),(Length))
2245: #else
2246: #define NdisWritePortBufferUshort(Handle,Port,Buffer,Length) \
2247: { \
2248: ULONG _Port = (ULONG)NDIS_PORT_TO_PORT(Handle, Port); \
2249: PUSHORT _Current = (Buffer); \
2250: PUSHORT _End = _Current + (Length); \
2251: for ( ; _Current < _End; ++_Current) { \
2252: WRITE_PORT_USHORT((PUSHORT)_Port,*(UNALIGNED USHORT *)_Current); \
2253: } \
2254: }
2255: #endif
2256:
2257:
2258: /*++
2259: VOID
2260: NdisWritePortBufferUlong(
2261: IN NDIS_HANDLE NdisAdapterHandle,
2262: IN ULONG Port,
2263: IN PULONG Buffer,
2264: IN ULONG Length
2265: )
2266: --*/
2267: #ifdef _M_IX86
2268: #define NdisWritePortBufferUlong(Handle,Port,Buffer,Length) \
2269: WRITE_PORT_BUFFER_ULONG((PULONG)(NDIS_PORT_TO_PORT(Handle,Port)),(PULONG)(Buffer),(Length))
2270: #else
2271: #define NdisWritePortBufferUlong(Handle,Port,Buffer,Length) \
2272: { \
2273: ULONG _Port = (ULONG)NDIS_PORT_TO_PORT(Handle, Port); \
2274: PULONG _Current = (Buffer); \
2275: PULONG _End = _Current + (Length); \
2276: for ( ; _Current < _End; ++_Current) { \
2277: WRITE_PORT_ULONG((PULONG)_Port,*(UNALIGNED ULONG *)_Current); \
2278: } \
2279: }
2280: #endif
2281:
2282:
2283: //
2284: // Read Ports
2285: //
2286:
2287: /*++
2288: VOID
2289: NdisReadPortUchar(
2290: IN NDIS_HANDLE NdisAdapterHandle,
2291: IN ULONG Port,
2292: OUT PUCHAR Data
2293: )
2294: --*/
2295: #define NdisReadPortUchar(Handle,Port, Data) \
2296: *(Data) = READ_PORT_UCHAR((PUCHAR)(NDIS_PORT_TO_PORT(Handle,Port)))
2297:
2298: /*++
2299: VOID
2300: NdisReadPortUshort(
2301: IN NDIS_HANDLE NdisAdapterHandle,
2302: IN ULONG Port,
2303: OUT PUSHORT Data
2304: )
2305: --*/
2306: #define NdisReadPortUshort(Handle,Port,Data) \
2307: *(Data) = READ_PORT_USHORT((PUSHORT)(NDIS_PORT_TO_PORT(Handle,Port)))
2308:
2309:
2310: /*++
2311: VOID
2312: NdisReadPortUlong(
2313: IN NDIS_HANDLE NdisAdapterHandle,
2314: IN ULONG Port,
2315: OUT PULONG Data
2316: )
2317: --*/
2318: #define NdisReadPortUlong(Handle,Port,Data) \
2319: *(Data) = READ_PORT_ULONG((PULONG)(NDIS_PORT_TO_PORT(Handle,Port)))
2320:
2321: //
2322: // Read Buffer Ports
2323: //
2324:
2325: /*++
2326: VOID
2327: NdisReadPortBufferUchar(
2328: IN NDIS_HANDLE NdisAdapterHandle,
2329: IN ULONG Port,
2330: OUT PUCHAR Buffer,
2331: IN ULONG Length
2332: )
2333: --*/
2334: #ifdef _M_IX86
2335: #define NdisReadPortBufferUchar(Handle,Port,Buffer,Length) \
2336: READ_PORT_BUFFER_UCHAR((PUCHAR)(NDIS_PORT_TO_PORT(Handle,Port)),(PUCHAR)(Buffer),(Length))
2337: #else
2338: #define NdisReadPortBufferUchar(Handle,Port,Buffer,Length) \
2339: { \
2340: ULONG _Port = (ULONG)NDIS_PORT_TO_PORT(Handle, Port); \
2341: PUCHAR _Current = (Buffer); \
2342: PUCHAR _End = _Current + (Length); \
2343: for ( ; _Current < _End; ++_Current) { \
2344: *_Current = READ_PORT_UCHAR((PUCHAR)_Port); \
2345: } \
2346: }
2347: #endif
2348:
2349: /*++
2350: VOID
2351: NdisReadPortBufferUshort(
2352: IN NDIS_HANDLE NdisAdapterHandle,
2353: IN ULONG Port,
2354: OUT PUSHORT Buffer,
2355: IN ULONG Length
2356: )
2357: --*/
2358: #ifdef _M_IX86
2359: #define NdisReadPortBufferUshort(Handle,Port,Buffer,Length) \
2360: READ_PORT_BUFFER_USHORT((PUSHORT)(NDIS_PORT_TO_PORT(Handle,Port)),(PUSHORT)(Buffer),(Length))
2361: #else
2362: #define NdisReadPortBufferUshort(Handle,Port,Buffer,Length) \
2363: { \
2364: ULONG _Port = (ULONG)NDIS_PORT_TO_PORT(Handle, Port); \
2365: PUSHORT _Current = (Buffer); \
2366: PUSHORT _End = _Current + (Length); \
2367: for ( ; _Current < _End; ++_Current) { \
2368: *(UNALIGNED USHORT *)_Current = READ_PORT_USHORT((PUSHORT)_Port); \
2369: } \
2370: }
2371: #endif
2372:
2373:
2374: /*++
2375: VOID
2376: NdisReadPortBufferUlong(
2377: IN NDIS_HANDLE NdisAdapterHandle,
2378: IN ULONG Port,
2379: OUT PULONG Buffer,
2380: IN ULONG Length
2381: )
2382: --*/
2383: #ifdef _M_IX86
2384: #define NdisReadPortBufferUlong(Handle,Port,Buffer) \
2385: READ_PORT_BUFFER_ULONG((PULONG)(NDIS_PORT_TO_PORT(Handle,Port)),(PULONG)(Buffer),(Length))
2386: #else
2387: #define NdisReadPortBufferUlong(Handle,Port,Buffer,Length) \
2388: { \
2389: ULONG _Port = (ULONG)NDIS_PORT_TO_PORT(Handle, Port); \
2390: PULONG _Current = (Buffer); \
2391: PULONG _End = _Current + (Length); \
2392: for ( ; _Current < _End; ++_Current) { \
2393: *(UNALIGNED ULONG *)_Current = READ_PORT_ULONG((PULONG)_Port); \
2394: } \
2395: }
2396: #endif
2397:
2398:
2399: //
2400: // Raw Routines
2401: //
2402:
2403: //
2404: // Write Port Raw
2405: //
2406:
2407: /*++
2408: VOID
2409: NdisRawWritePortUchar(
2410: IN ULONG Port,
2411: IN UCHAR Data
2412: )
2413: --*/
2414: #define NdisRawWritePortUchar(Port,Data) \
2415: WRITE_PORT_UCHAR((PUCHAR)(Port),(UCHAR)(Data))
2416:
2417: /*++
2418: VOID
2419: NdisRawWritePortUshort(
2420: IN ULONG Port,
2421: IN USHORT Data
2422: )
2423: --*/
2424: #define NdisRawWritePortUshort(Port,Data) \
2425: WRITE_PORT_USHORT((PUSHORT)(Port),(USHORT)(Data))
2426:
2427:
2428: /*++
2429: VOID
2430: NdisRawWritePortUlong(
2431: IN ULONG Port,
2432: IN ULONG Data
2433: )
2434: --*/
2435: #define NdisRawWritePortUlong(Port,Data) \
2436: WRITE_PORT_ULONG((PULONG)(Port),(ULONG)(Data))
2437:
2438:
2439: //
2440: // Raw Write Port Buffers
2441: //
2442:
2443: /*++
2444: VOID
2445: NdisRawWritePortBufferUchar(
2446: IN ULONG Port,
2447: IN PUCHAR Buffer,
2448: IN ULONG Length
2449: )
2450: --*/
2451: #ifdef _M_IX86
2452: #define NdisRawWritePortBufferUchar(Port,Buffer,Length) \
2453: WRITE_PORT_BUFFER_UCHAR((PUCHAR)(Port),(PUCHAR)(Buffer),(Length))
2454: #else
2455: #define NdisRawWritePortBufferUchar(Port,Buffer,Length) \
2456: { \
2457: ULONG _Port = (ULONG)(Port); \
2458: PUCHAR _Current = (Buffer); \
2459: PUCHAR _End = _Current + (Length); \
2460: for ( ; _Current < _End; ++_Current) { \
2461: WRITE_PORT_UCHAR((PUCHAR)_Port,*_Current); \
2462: } \
2463: }
2464: #endif
2465:
2466: /*++
2467: VOID
2468: NdisRawWritePortBufferUshort(
2469: IN ULONG Port,
2470: IN PUSHORT Buffer,
2471: IN ULONG Length
2472: )
2473: --*/
2474: #ifdef _M_IX86
2475: #define NdisRawWritePortBufferUshort(Port,Buffer,Length) \
2476: WRITE_PORT_BUFFER_USHORT((PUSHORT)(Port),(PUSHORT)(Buffer),(Length))
2477: #else
2478: #define NdisRawWritePortBufferUshort(Port,Buffer,Length) \
2479: { \
2480: ULONG _Port = (ULONG)(Port); \
2481: PUSHORT _Current = (Buffer); \
2482: PUSHORT _End = _Current + (Length); \
2483: for ( ; _Current < _End; ++_Current) { \
2484: WRITE_PORT_USHORT((PUSHORT)_Port,*(UNALIGNED USHORT *)_Current); \
2485: } \
2486: }
2487: #endif
2488:
2489:
2490: /*++
2491: VOID
2492: NdisRawWritePortBufferUlong(
2493: IN ULONG Port,
2494: IN PULONG Buffer,
2495: IN ULONG Length
2496: )
2497: --*/
2498: #ifdef _M_IX86
2499: #define NdisRawWritePortBufferUlong(Port,Buffer,Length) \
2500: WRITE_PORT_BUFFER_ULONG((PULONG)(Port),(PULONG)(Buffer),(Length))
2501: #else
2502: #define NdisRawWritePortBufferUlong(Port,Buffer,Length) \
2503: { \
2504: ULONG _Port = (ULONG)(Port); \
2505: PULONG _Current = (Buffer); \
2506: PULONG _End = _Current + (Length); \
2507: for ( ; _Current < _End; ++_Current) { \
2508: WRITE_PORT_ULONG((PULONG)_Port,*(UNALIGNED ULONG *)_Current); \
2509: } \
2510: }
2511: #endif
2512:
2513:
2514: //
2515: // Raw Read Ports
2516: //
2517:
2518: /*++
2519: VOID
2520: NdisRawReadPortUchar(
2521: IN ULONG Port,
2522: OUT PUCHAR Data
2523: )
2524: --*/
2525: #define NdisRawReadPortUchar(Port, Data) \
2526: *(Data) = READ_PORT_UCHAR((PUCHAR)(Port))
2527:
2528: /*++
2529: VOID
2530: NdisRawReadPortUshort(
2531: IN ULONG Port,
2532: OUT PUSHORT Data
2533: )
2534: --*/
2535: #define NdisRawReadPortUshort(Port,Data) \
2536: *(Data) = READ_PORT_USHORT((PUSHORT)(Port))
2537:
2538:
2539: /*++
2540: VOID
2541: NdisRawReadPortUlong(
2542: IN ULONG Port,
2543: OUT PULONG Data
2544: )
2545: --*/
2546: #define NdisRawReadPortUlong(Port,Data) \
2547: *(Data) = READ_PORT_ULONG((PULONG)(Port))
2548:
2549: //
2550: // Raw Read Buffer Ports
2551: //
2552:
2553: /*++
2554: VOID
2555: NdisRawReadPortBufferUchar(
2556: IN ULONG Port,
2557: OUT PUCHAR Buffer,
2558: IN ULONG Length
2559: )
2560: --*/
2561: #ifdef _M_IX86
2562: #define NdisRawReadPortBufferUchar(Port,Buffer,Length) \
2563: READ_PORT_BUFFER_UCHAR((PUCHAR)(Port),(PUCHAR)(Buffer),(Length))
2564: #else
2565: #define NdisRawReadPortBufferUchar(Port,Buffer,Length) \
2566: { \
2567: ULONG _Port = (ULONG)(Port); \
2568: PUCHAR _Current = (Buffer); \
2569: PUCHAR _End = _Current + (Length); \
2570: for ( ; _Current < _End; ++_Current) { \
2571: *_Current = READ_PORT_UCHAR((PUCHAR)_Port); \
2572: } \
2573: }
2574: #endif
2575:
2576: /*++
2577: VOID
2578: NdisRawReadPortBufferUshort(
2579: IN ULONG Port,
2580: OUT PUSHORT Buffer,
2581: IN ULONG Length
2582: )
2583: --*/
2584: #ifdef _M_IX86
2585: #define NdisRawReadPortBufferUshort(Port,Buffer,Length) \
2586: READ_PORT_BUFFER_USHORT((PUSHORT)(Port),(PUSHORT)(Buffer),(Length))
2587: #else
2588: #define NdisRawReadPortBufferUshort(Port,Buffer,Length) \
2589: { \
2590: ULONG _Port = (ULONG)(Port); \
2591: PUSHORT _Current = (Buffer); \
2592: PUSHORT _End = _Current + (Length); \
2593: for ( ; _Current < _End; ++_Current) { \
2594: *(UNALIGNED USHORT *)_Current = READ_PORT_USHORT((PUSHORT)_Port); \
2595: } \
2596: }
2597: #endif
2598:
2599:
2600: /*++
2601: VOID
2602: NdisRawReadPortBufferUlong(
2603: IN ULONG Port,
2604: OUT PULONG Buffer,
2605: IN ULONG Length
2606: )
2607: --*/
2608: #ifdef _M_IX86
2609: #define NdisRawReadPortBufferUlong(Port,Buffer,Length) \
2610: READ_PORT_BUFFER_ULONG((PULONG)(Port),(PULONG)(Buffer),(Length))
2611: #else
2612: #define NdisRawReadPortBufferUlong(Port,Buffer,Length) \
2613: { \
2614: ULONG _Port = (ULONG)(Port); \
2615: PULONG _Current = (Buffer); \
2616: PULONG _End = _Current + (Length); \
2617: for ( ; _Current < _End; ++_Current) { \
2618: *(UNALIGNED ULONG *)_Current = READ_PORT_ULONG((PULONG)_Port); \
2619: } \
2620: }
2621: #endif
2622:
2623:
2624:
2625:
2626:
2627:
2628: //
2629: // Write Registers
2630: //
2631:
2632: /*++
2633: VOID
2634: NdisWriteRegisterUchar(
2635: IN PUCHAR Register,
2636: IN UCHAR Data
2637: )
2638: --*/
2639:
2640: #ifdef _M_IX86
2641:
2642: #define NdisWriteRegisterUchar(Register,Data) \
2643: *((PUCHAR)(Register)) = (Data)
2644:
2645: #else
2646:
2647: #define NdisWriteRegisterUchar(Register,Data) \
2648: { \
2649: WRITE_REGISTER_UCHAR((Register),(Data)); \
2650: READ_REGISTER_UCHAR(Register); \
2651: }
2652:
2653: #endif
2654:
2655: /*++
2656: VOID
2657: NdisWriteRegisterUshort(
2658: IN PUSHORT Register,
2659: IN USHORT Data
2660: )
2661: --*/
2662:
2663: #ifdef _M_IX86
2664:
2665: #define NdisWriteRegisterUshort(Register,Data) \
2666: *((PUSHORT)(Register)) = (Data)
2667:
2668: #else
2669:
2670: #define NdisWriteRegisterUshort(Register,Data) \
2671: { \
2672: WRITE_REGISTER_USHORT((Register),(Data)); \
2673: READ_REGISTER_USHORT(Register); \
2674: }
2675:
2676: #endif
2677:
2678: /*++
2679: VOID
2680: NdisWriteRegisterUlong(
2681: IN PULONG Register,
2682: IN ULONG Data
2683: )
2684: --*/
2685:
2686: #ifdef _M_IX86
2687:
2688: #define NdisWriteRegisterUlong(Register,Data) \
2689: *((PULONG)(Register)) = (Data)
2690:
2691: #else
2692:
2693: #define NdisWriteRegisterUlong(Register,Data) \
2694: { \
2695: WRITE_REGISTER_ULONG((Register),(Data)); \
2696: READ_REGISTER_ULONG(Register); \
2697: }
2698:
2699: #endif
2700:
2701: /*++
2702: VOID
2703: NdisReadRegisterUchar(
2704: IN PUCHAR Register,
2705: OUT PUCHAR Data
2706: )
2707: --*/
2708: #ifdef _M_IX86
2709:
2710: #define NdisReadRegisterUchar(Register,Data) \
2711: *((PUCHAR)(Data)) = *(Register)
2712:
2713: #else
2714:
2715: #define NdisReadRegisterUchar(Register,Data) \
2716: *(Data) = READ_REGISTER_UCHAR((PUCHAR)(Register))
2717: #endif
2718:
2719: /*++
2720: VOID
2721: NdisReadRegisterUshort(
2722: IN PUSHORT Register,
2723: OUT PUSHORT Data
2724: )
2725: --*/
2726: #ifdef _M_IX86
2727:
2728: #define NdisReadRegisterUshort(Register,Data) \
2729: *((PUSHORT)(Data)) = *(Register)
2730:
2731: #else
2732:
2733: #define NdisReadRegisterUshort(Register,Data) \
2734: *(Data) = READ_REGISTER_USHORT((PUSHORT)(Register))
2735: #endif
2736:
2737: /*++
2738: VOID
2739: NdisReadRegisterUlong(
2740: IN PULONG Register,
2741: OUT PULONG Data
2742: )
2743: --*/
2744: #ifdef _M_IX86
2745:
2746: #define NdisReadRegisterUlong(Register,Data) \
2747: *((PULONG)(Data)) = *(Register)
2748:
2749: #else
2750:
2751: #define NdisReadRegisterUlong(Register,Data) \
2752: *(Data) = READ_REGISTER_ULONG((PULONG)(Register))
2753: #endif
2754:
2755: //
2756: // BOOLEAN
2757: // NdisEqualString(
2758: // IN PNDIS_STRING _String1,
2759: // IN PNDIS_STRING _String2,
2760: // IN BOOLEAN CaseInsensitive
2761: // );
2762: //
2763:
2764: #define NdisEqualString(_String1,_String2,CaseInsensitive) \
2765: RtlEqualUnicodeString((_String1), (_String2), CaseInsensitive)
2766:
2767:
2768: //
2769: // Physical Mapping
2770: //
2771:
2772: //
2773: // VOID
2774: // NdisStartBufferPhysicalMapping(
2775: // IN NDIS_HANDLE NdisAdapterHandle,
2776: // IN PNDIS_BUFFER Buffer,
2777: // IN ULONG PhysicalMapRegister,
2778: // IN BOOLEAN WriteToDevice,
2779: // OUT PNDIS_PHYSICAL_ADDRESS_UNIT PhysicalAddressArray,
2780: // OUT PUINT ArraySize
2781: // );
2782: //
2783:
2784: #define NdisStartBufferPhysicalMapping( \
2785: NdisAdapterHandle, \
2786: Buffer, \
2787: PhysicalMapRegister, \
2788: Write, \
2789: PhysicalAddressArray, \
2790: ArraySize \
2791: ) \
2792: { \
2793: PNDIS_ADAPTER_BLOCK _AdaptP = (PNDIS_ADAPTER_BLOCK)(NdisAdapterHandle); \
2794: ULONG _PhysicalMapRegister = (PhysicalMapRegister); \
2795: PNDIS_PHYSICAL_ADDRESS_UNIT _PhysicalAddressArray = (PhysicalAddressArray); \
2796: PNDIS_BUFFER _Buffer = (Buffer); \
2797: BOOLEAN _WriteToDevice = (Write); \
2798: PUINT _ArraySize = (ArraySize); \
2799: PHYSICAL_ADDRESS _LogicalAddress; \
2800: PUCHAR _VirtualAddress; \
2801: ULONG _LengthRemaining; \
2802: ULONG _LengthMapped; \
2803: UINT _CurrentArrayLocation; \
2804: _VirtualAddress = MmGetMdlVirtualAddress(_Buffer); \
2805: _LengthRemaining = MmGetMdlByteCount(_Buffer); \
2806: _CurrentArrayLocation = 0; \
2807: while (_LengthRemaining > 0) { \
2808: _LengthMapped = _LengthRemaining; \
2809: _LogicalAddress = IoMapTransfer( \
2810: NULL, \
2811: _Buffer, \
2812: _AdaptP->MapRegisters[_PhysicalMapRegister].MapRegister, \
2813: _VirtualAddress, \
2814: &_LengthMapped, \
2815: _WriteToDevice); \
2816: _PhysicalAddressArray[_CurrentArrayLocation].PhysicalAddress = _LogicalAddress; \
2817: _PhysicalAddressArray[_CurrentArrayLocation].Length = _LengthMapped; \
2818: _LengthRemaining -= _LengthMapped; \
2819: _VirtualAddress += _LengthMapped; \
2820: ++_CurrentArrayLocation; \
2821: } \
2822: _AdaptP->MapRegisters[_PhysicalMapRegister].WriteToDevice = _WriteToDevice; \
2823: *(_ArraySize) = _CurrentArrayLocation; \
2824: }
2825:
2826:
2827: //
2828: // VOID
2829: // NdisCompleteBufferPhysicalMapping(
2830: // IN NDIS_HANDLE NdisAdapterHandle,
2831: // IN PNDIS_BUFFER Buffer,
2832: // IN ULONG PhysicalMapRegister
2833: // );
2834: //
2835:
2836: #define NdisCompleteBufferPhysicalMapping( \
2837: NdisAdapterHandle, \
2838: Buffer, \
2839: PhysicalMapRegister \
2840: ) \
2841: { \
2842: PNDIS_ADAPTER_BLOCK _AdaptP = (PNDIS_ADAPTER_BLOCK)NdisAdapterHandle; \
2843: IoFlushAdapterBuffers( \
2844: NULL, \
2845: Buffer, \
2846: _AdaptP->MapRegisters[PhysicalMapRegister].MapRegister, \
2847: MmGetMdlVirtualAddress(Buffer), \
2848: MmGetMdlByteCount(Buffer), \
2849: _AdaptP->MapRegisters[PhysicalMapRegister].WriteToDevice); \
2850: }
2851:
2852:
2853: //
2854: // Shared memory
2855: //
2856:
2857: VOID
2858: NdisAllocateSharedMemory(
2859: IN NDIS_HANDLE NdisAdapterHandle,
2860: IN ULONG Length,
2861: IN BOOLEAN Cached,
2862: OUT PVOID *VirtualAddress,
2863: OUT PNDIS_PHYSICAL_ADDRESS PhysicalAddress
2864: );
2865:
2866: VOID
2867: NdisUpdateSharedMemory(
2868: IN NDIS_HANDLE NdisAdapterHandle,
2869: IN ULONG Length,
2870: IN PVOID VirtualAddress,
2871: IN NDIS_PHYSICAL_ADDRESS PhysicalAddress
2872: );
2873:
2874: VOID
2875: NdisFreeSharedMemory(
2876: IN NDIS_HANDLE NdisAdapterHandle,
2877: IN ULONG Length,
2878: IN BOOLEAN Cached,
2879: IN PVOID VirtualAddress,
2880: IN NDIS_PHYSICAL_ADDRESS PhysicalAddress
2881: );
2882:
2883:
2884: //
2885: // DMA operations.
2886: //
2887:
2888: VOID
2889: NdisAllocateDmaChannel(
2890: OUT PNDIS_STATUS Status,
2891: OUT PNDIS_HANDLE NdisDmaHandle,
2892: IN NDIS_HANDLE NdisAdapterHandle,
2893: IN PNDIS_DMA_DESCRIPTION DmaDescription,
2894: IN ULONG MaximumLength
2895: );
2896:
2897: VOID
2898: NdisFreeDmaChannel(
2899: IN PNDIS_HANDLE NdisDmaHandle
2900: );
2901:
2902: VOID
2903: NdisSetupDmaTransfer(
2904: OUT PNDIS_STATUS Status,
2905: IN PNDIS_HANDLE NdisDmaHandle,
2906: IN PNDIS_BUFFER Buffer,
2907: IN ULONG Offset,
2908: IN ULONG Length,
2909: IN BOOLEAN WriteToDevice
2910: );
2911:
2912: VOID
2913: NdisCompleteDmaTransfer(
2914: OUT PNDIS_STATUS Status,
2915: IN PNDIS_HANDLE NdisDmaHandle,
2916: IN PNDIS_BUFFER Buffer,
2917: IN ULONG Offset,
2918: IN ULONG Length,
2919: IN BOOLEAN WriteToDevice
2920: );
2921:
2922: /*++
2923: ULONG
2924: NdisReadDmaCounter(
2925: IN NDIS_HANDLE NdisDmaHandle
2926: )
2927: --*/
2928:
2929: #define NdisReadDmaCounter(_NdisDmaHandle) \
2930: HalReadDmaCounter(((PNDIS_DMA_BLOCK)(_NdisDmaHandle))->SystemAdapterObject)
2931:
2932:
2933:
2934: //
2935: // Requests used by Protocol Modules
2936: //
2937:
2938:
2939:
2940: VOID
2941: NdisRegisterProtocol(
2942: OUT PNDIS_STATUS Status,
2943: OUT PNDIS_HANDLE NdisProtocolHandle,
2944: IN PNDIS_PROTOCOL_CHARACTERISTICS ProtocolCharacteristics,
2945: IN UINT CharacteristicsLength
2946: );
2947:
2948: VOID
2949: NdisDeregisterProtocol(
2950: OUT PNDIS_STATUS Status,
2951: IN NDIS_HANDLE NdisProtocolHandle
2952: );
2953:
2954:
2955: VOID
2956: NdisOpenAdapter(
2957: OUT PNDIS_STATUS Status,
2958: OUT PNDIS_STATUS OpenErrorStatus,
2959: OUT PNDIS_HANDLE NdisBindingHandle,
2960: OUT PUINT SelectedMediumIndex,
2961: IN PNDIS_MEDIUM MediumArray,
2962: IN UINT MediumArraySize,
2963: IN NDIS_HANDLE NdisProtocolHandle,
2964: IN NDIS_HANDLE ProtocolBindingContext,
2965: IN PNDIS_STRING AdapterName,
2966: IN UINT OpenOptions,
2967: IN PSTRING AddressingInformation OPTIONAL
2968: );
2969:
2970:
2971: VOID
2972: NdisCloseAdapter(
2973: OUT PNDIS_STATUS Status,
2974: IN NDIS_HANDLE NdisBindingHandle
2975: );
2976:
2977:
2978: #ifdef NDISDBG
2979: VOID
2980: NdisSend(
2981: OUT PNDIS_STATUS Status,
2982: IN NDIS_HANDLE NdisBindingHandle,
2983: IN PNDIS_PACKET Packet
2984: );
2985: #else
2986: #define NdisSend(Status, \
2987: NdisBindingHandle, \
2988: Packet \
2989: ) \
2990: {\
2991: *(Status) = \
2992: (((PNDIS_OPEN_BLOCK)(NdisBindingHandle))->SendHandler) ( \
2993: ((PNDIS_OPEN_BLOCK)(NdisBindingHandle))->MacBindingHandle, \
2994: (Packet)); \
2995: }
2996: #endif
2997:
2998:
2999: #ifdef NDISDBG
3000: VOID
3001: NdisTransferData(
3002: OUT PNDIS_STATUS Status,
3003: IN NDIS_HANDLE NdisBindingHandle,
3004: IN NDIS_HANDLE MacReceiveContext,
3005: IN UINT ByteOffset,
3006: IN UINT BytesToTransfer,
3007: IN OUT PNDIS_PACKET Packet,
3008: OUT PUINT BytesTransferred
3009: );
3010: #else
3011: #define NdisTransferData( \
3012: Status, \
3013: NdisBindingHandle, \
3014: MacReceiveContext, \
3015: ByteOffset, \
3016: BytesToTransfer, \
3017: Packet, \
3018: BytesTransferred \
3019: ) \
3020: {\
3021: *(Status) = \
3022: (((PNDIS_OPEN_BLOCK)(NdisBindingHandle))->TransferDataHandler) ( \
3023: ((PNDIS_OPEN_BLOCK)(NdisBindingHandle))->MacBindingHandle, \
3024: (MacReceiveContext), \
3025: (ByteOffset), \
3026: (BytesToTransfer), \
3027: (Packet), \
3028: (BytesTransferred)); \
3029: }
3030: #endif
3031:
3032:
3033: #ifdef NDISDBG
3034: VOID
3035: NdisReset(
3036: OUT PNDIS_STATUS Status,
3037: IN NDIS_HANDLE NdisBindingHandle
3038: );
3039: #else
3040: #define NdisReset( \
3041: Status, \
3042: NdisBindingHandle \
3043: ) \
3044: { \
3045: *(Status) = \
3046: (((PNDIS_OPEN_BLOCK)(NdisBindingHandle))->MacHandle->MacCharacteristics.ResetHandler) ( \
3047: ((PNDIS_OPEN_BLOCK)(NdisBindingHandle))->MacBindingHandle); \
3048: }
3049: #endif
3050:
3051: #ifdef NDISDBG
3052: VOID
3053: NdisRequest(
3054: OUT PNDIS_STATUS Status,
3055: IN NDIS_HANDLE NdisBindingHandle,
3056: IN PNDIS_REQUEST NdisRequest
3057: );
3058: #else
3059: #define NdisRequest( \
3060: Status,\
3061: NdisBindingHandle, \
3062: NdisRequest \
3063: ) \
3064: { \
3065: *(Status) = \
3066: (((PNDIS_OPEN_BLOCK)(NdisBindingHandle))->MacHandle->MacCharacteristics.RequestHandler) ( \
3067: ((PNDIS_OPEN_BLOCK)(NdisBindingHandle))->MacBindingHandle, \
3068: (NdisRequest)); \
3069: }
3070: #endif
3071:
3072: //
3073: // Requests Used by MAC Drivers
3074: //
3075:
3076: extern PDRIVER_OBJECT Driver; // set by initialization routine
3077:
3078:
3079: VOID
3080: NdisInitializeWrapper(
3081: OUT PNDIS_HANDLE NdisWrapperHandle,
3082: IN PVOID SystemSpecific1,
3083: IN PVOID SystemSpecific2,
3084: IN PVOID SystemSpecific3
3085: );
3086:
3087:
3088: VOID
3089: NdisTerminateWrapper(
3090: IN NDIS_HANDLE NdisWrapperHandle,
3091: IN PVOID SystemSpecific
3092: );
3093:
3094: VOID
3095: NdisRegisterMac(
3096: OUT PNDIS_STATUS Status,
3097: OUT PNDIS_HANDLE NdisMacHandle,
3098: IN NDIS_HANDLE NdisWrapperHandle,
3099: IN NDIS_HANDLE MacMacContext,
3100: IN PNDIS_MAC_CHARACTERISTICS MacCharacteristics,
3101: IN UINT CharacteristicsLength
3102: );
3103:
3104: VOID
3105: NdisDeregisterMac(
3106: OUT PNDIS_STATUS Status,
3107: IN NDIS_HANDLE NdisMacHandle
3108: );
3109:
3110:
3111: NDIS_STATUS
3112: NdisRegisterAdapter(
3113: OUT PNDIS_HANDLE NdisAdapterHandle,
3114: IN NDIS_HANDLE NdisMacHandle,
3115: IN NDIS_HANDLE MacAdapterContext,
3116: IN NDIS_HANDLE WrapperConfigurationContext,
3117: IN PNDIS_STRING AdapterName,
3118: IN PVOID AdapterInformation
3119: );
3120:
3121: NDIS_STATUS
3122: NdisDeregisterAdapter(
3123: IN NDIS_HANDLE NdisAdapterHandle
3124: );
3125:
3126: VOID
3127: NdisRegisterAdapterShutdownHandler(
3128: IN NDIS_HANDLE NdisAdapterHandle,
3129: IN PVOID ShutdownContext,
3130: IN ADAPTER_SHUTDOWN_HANDLER ShutdownHandler
3131: );
3132:
3133: VOID
3134: NdisDeregisterAdapterShutdownHandler(
3135: IN NDIS_HANDLE NdisAdapterHandle
3136: );
3137:
3138: VOID
3139: NdisReleaseAdapterResources(
3140: IN NDIS_HANDLE NdisAdapterHandle
3141: );
3142:
3143: VOID
3144: NdisWriteErrorLogEntry(
3145: IN NDIS_HANDLE NdisAdapterHandle,
3146: IN NDIS_ERROR_CODE ErrorCode,
3147: IN ULONG NumberOfErrorValues,
3148: ...
3149: );
3150:
3151: VOID
3152: NdisCompleteOpenAdapter(
3153: IN NDIS_HANDLE NdisBindingContext,
3154: IN NDIS_STATUS Status,
3155: IN NDIS_STATUS OpenErrorStatus
3156: );
3157:
3158:
3159: VOID
3160: NdisCompleteCloseAdapter(
3161: IN NDIS_HANDLE NdisBindingContext,
3162: IN NDIS_STATUS Status
3163: );
3164:
3165:
3166: #ifdef NDISDBG
3167: VOID
3168: NdisCompleteSend(
3169: IN NDIS_HANDLE NdisBindingContext,
3170: IN PNDIS_PACKET Packet,
3171: IN NDIS_STATUS Status
3172: );
3173: #else
3174: #define NdisCompleteSend( \
3175: NdisBindingContext, \
3176: Packet, \
3177: Status \
3178: ) \
3179: {\
3180: (((PNDIS_OPEN_BLOCK)(NdisBindingContext))->SendCompleteHandler) ( \
3181: ((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolBindingContext, \
3182: (Packet), \
3183: (Status)); \
3184: }
3185: #endif
3186:
3187:
3188: #ifdef NDISDBG
3189: VOID
3190: NdisCompleteTransferData(
3191: IN NDIS_HANDLE NdisBindingContext,
3192: IN PNDIS_PACKET Packet,
3193: IN NDIS_STATUS Status,
3194: IN UINT BytesTransferred
3195: );
3196: #else
3197: #define NdisCompleteTransferData( \
3198: NdisBindingContext, \
3199: Packet, \
3200: Status, \
3201: BytesTransferred \
3202: ) \
3203: {\
3204: (((PNDIS_OPEN_BLOCK)(NdisBindingContext))->TransferDataCompleteHandler) ( \
3205: ((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolBindingContext, \
3206: (Packet), \
3207: (Status), \
3208: (BytesTransferred)); \
3209: }
3210: #endif
3211:
3212: #ifdef NDISDBG
3213: VOID
3214: NdisCompleteReset(
3215: IN NDIS_HANDLE NdisBindingContext,
3216: IN NDIS_STATUS Status
3217: );
3218: #else
3219: #define NdisCompleteReset( \
3220: NdisBindingContext, \
3221: Status \
3222: ) \
3223: { \
3224: (((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolHandle->ProtocolCharacteristics.ResetCompleteHandler) ( \
3225: ((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolBindingContext, \
3226: Status); \
3227: }
3228: #endif
3229:
3230:
3231: #ifdef NDISDBG
3232: VOID
3233: NdisCompleteRequest(
3234: IN NDIS_HANDLE NdisBindingContext,
3235: IN PNDIS_REQUEST NdisRequest,
3236: IN NDIS_STATUS Status
3237: );
3238: #else
3239: #define NdisCompleteRequest( \
3240: NdisBindingContext, \
3241: NdisRequest, \
3242: Status) \
3243: { \
3244: (((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolHandle->ProtocolCharacteristics.RequestCompleteHandler) ( \
3245: ((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolBindingContext, \
3246: NdisRequest, \
3247: Status); \
3248: }
3249: #endif
3250:
3251: #ifdef NDISDBG
3252: VOID
3253: NdisIndicateReceive(
3254: OUT PNDIS_STATUS Status,
3255: IN NDIS_HANDLE NdisBindingContext,
3256: IN NDIS_HANDLE MacReceiveContext,
3257: IN PVOID HeaderBuffer,
3258: IN UINT HeaderBufferSize,
3259: IN PVOID LookaheadBuffer,
3260: IN UINT LookaheadBufferSize,
3261: IN UINT PacketSize
3262: );
3263: #else
3264: #define NdisIndicateReceive( \
3265: Status, \
3266: NdisBindingContext, \
3267: MacReceiveContext, \
3268: HeaderBuffer, \
3269: HeaderBufferSize, \
3270: LookaheadBuffer, \
3271: LookaheadBufferSize, \
3272: PacketSize \
3273: ) \
3274: {\
3275: *(Status) = \
3276: (((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ReceiveHandler) ( \
3277: ((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolBindingContext, \
3278: (MacReceiveContext), \
3279: (HeaderBuffer), \
3280: (HeaderBufferSize), \
3281: (LookaheadBuffer), \
3282: (LookaheadBufferSize), \
3283: (PacketSize)); \
3284: }
3285: #endif
3286:
3287:
3288: #ifdef NDISDBG
3289: VOID
3290: NdisIndicateReceiveComplete(
3291: IN NDIS_HANDLE NdisBindingContext
3292: );
3293: #else
3294: #define NdisIndicateReceiveComplete( \
3295: NdisBindingContext \
3296: ) \
3297: (((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ReceiveCompleteHandler) ( \
3298: ((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolBindingContext);
3299: #endif
3300:
3301:
3302: #ifdef NDISDBG
3303: VOID
3304: NdisIndicateStatus(
3305: IN NDIS_HANDLE NdisBindingContext,
3306: IN NDIS_STATUS GeneralStatus,
3307: IN PVOID StatusBuffer,
3308: IN UINT StatusBufferSize
3309: );
3310: #else
3311: #define NdisIndicateStatus( \
3312: NdisBindingContext, \
3313: GeneralStatus, \
3314: StatusBuffer, \
3315: StatusBufferSize \
3316: ) \
3317: {\
3318: (((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolHandle->ProtocolCharacteristics.StatusHandler) ( \
3319: ((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolBindingContext, \
3320: (GeneralStatus), \
3321: (StatusBuffer), \
3322: (StatusBufferSize)); \
3323: }
3324: #endif
3325:
3326:
3327: #ifdef NDISDBG
3328: VOID
3329: NdisIndicateStatusComplete(
3330: IN NDIS_HANDLE NdisBindingContext
3331: );
3332: #else
3333: #define NdisIndicateStatusComplete( \
3334: NdisBindingContext \
3335: ) \
3336: { \
3337: (((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolHandle->ProtocolCharacteristics.StatusCompleteHandler) ( \
3338: ((PNDIS_OPEN_BLOCK)(NdisBindingContext))->ProtocolBindingContext); \
3339: }
3340: #endif
3341:
3342: VOID
3343: NdisCompleteQueryStatistics(
3344: IN NDIS_HANDLE NdisAdapterHandle,
3345: IN PNDIS_REQUEST NdisRequest,
3346: IN NDIS_STATUS Status
3347: );
3348:
3349: #define NdisInitializeString(Destination,Source) \
3350: {\
3351: PNDIS_STRING _D = (Destination);\
3352: UCHAR *_S = (Source);\
3353: WCHAR *_P;\
3354: _D->Length = (strlen(_S)) * sizeof(WCHAR);\
3355: _D->MaximumLength = _D->Length + sizeof(WCHAR);\
3356: NdisAllocateMemory((PVOID *)&(_D->Buffer), _D->MaximumLength, 0, (-1));\
3357: _P = _D->Buffer;\
3358: while(*_S != '\0'){\
3359: *_P = (WCHAR)(*_S);\
3360: _S++;\
3361: _P++;\
3362: }\
3363: *_P = UNICODE_NULL;\
3364: }
3365:
3366:
3367: #define NdisFreeString(String) NdisFreeMemory((String).Buffer, (String).MaximumLength, 0)
3368:
3369: #define NdisPrintString(String) DbgPrint("%ls",(String).Buffer)
3370:
3371:
3372: #ifdef _M_IX86
3373: /*++
3374:
3375: VOID
3376: NdisCreateLookaheadBufferFromSharedMemory(
3377: IN PVOID pSharedMemory,
3378: IN UINT LookaheadLength,
3379: OUT PVOID *pLookaheadBuffer
3380: );
3381:
3382: --*/
3383:
3384: #define NdisCreateLookaheadBufferFromSharedMemory(_S, _L, _B) \
3385: ((*(_B)) = (_S))
3386:
3387:
3388:
3389: /*++
3390:
3391: VOID
3392: NdisDestroyLookaheadBufferFromSharedMemory(
3393: IN PVOID pLookaheadBuffer
3394: );
3395:
3396: --*/
3397:
3398: #define NdisDestroyLookaheadBufferFromSharedMemory(_B)
3399:
3400: #else
3401: #ifdef mips
3402:
3403: /*++
3404:
3405: VOID
3406: NdisCreateLookaheadBufferFromSharedMemory(
3407: IN PVOID pSharedMemory,
3408: IN UINT LookaheadLength,
3409: OUT PVOID *pLookaheadBuffer
3410: );
3411:
3412: --*/
3413:
3414: #define NdisCreateLookaheadBufferFromSharedMemory(_S, _L, _B) \
3415: ((*(_B)) = (_S))
3416:
3417:
3418:
3419: /*++
3420:
3421: VOID
3422: NdisDestroyLookaheadBufferFromSharedMemory(
3423: IN PVOID pLookaheadBuffer
3424: );
3425:
3426: --*/
3427:
3428: #define NdisDestroyLookaheadBufferFromSharedMemory(_B)
3429:
3430: #else
3431:
3432: VOID
3433: NdisCreateLookaheadBufferFromSharedMemory(
3434: IN PVOID pSharedMemory,
3435: IN UINT LookaheadLength,
3436: OUT PVOID *pLookaheadBuffer
3437: );
3438:
3439: VOID
3440: NdisDestroyLookaheadBufferFromSharedMemory(
3441: IN PVOID pLookaheadBuffer
3442: );
3443:
3444: #endif // mips
3445: #endif // i386
3446:
3447:
3448: //
3449: //*\\ Stubs to compile with Ndis 3.0 Kernel
3450: //
3451:
3452: extern
3453: NDIS_STATUS
3454: EthAddFilterAddress();
3455:
3456: extern
3457: NDIS_STATUS
3458: EthDeleteFilterAddress();
3459:
3460: extern
3461: NDIS_STATUS
3462: NdisInitializePacketPool();
3463:
3464: // ZZZZ
3465:
3466: #ifdef NDISDBG
3467: VOID
3468: DbgChkPktLength(
3469: IN PNDIS_PACKET Packet
3470: );
3471: #endif
3472:
3473: #endif // _NDIS_
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.