![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stndis.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / tdi|
Return to stndis.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / tdi |
1.1 root 1: /*++
2:
3: Copyright (c) 1989-1993 Microsoft Corporation
4:
5: Module Name:
6:
7: stndis.c
8:
9: Abstract:
10:
11: This module contains code which implements the routines used to interface
12: ST and NDIS. All callback routines (except for Transfer Data,
13: Send Complete, and ReceiveIndication) are here, as well as those routines
14: called to initialize NDIS.
15:
16: Environment:
17:
18: Kernel mode
19:
20: --*/
21:
22: #include "st.h"
23:
24:
25: //
26: // This is a one-per-driver variable used in binding
27: // to the NDIS interface.
28: //
29:
30: NDIS_HANDLE StNdisProtocolHandle = (NDIS_HANDLE)NULL;
31:
32: NDIS_STATUS
33: StSubmitNdisRequest(
34: IN PDEVICE_CONTEXT DeviceContext,
35: IN PNDIS_REQUEST NdisRequest,
36: IN PNDIS_STRING AdapterString
37: );
38:
39: #ifdef ALLOC_PRAGMA
40: #pragma alloc_text(init,StRegisterProtocol)
41: #pragma alloc_text(init,StSubmitNdisRequest)
42: #pragma alloc_text(init,StInitializeNdis)
43: #endif
44:
45:
46: NTSTATUS
47: StRegisterProtocol (
48: IN STRING *NameString
49: )
50:
51: /*++
52:
53: Routine Description:
54:
55: This routine introduces this transport to the NDIS interface.
56:
57: Arguments:
58:
59: Irp - Pointer to the request packet representing the I/O request.
60:
61: Return Value:
62:
63: The function value is the status of the operation.
64: STATUS_SUCCESS if all goes well,
65: Failure status if we tried to register and couldn't,
66: STATUS_INSUFFICIENT_RESOURCES if we couldn't even try to register.
67:
68: --*/
69:
70: {
71: NDIS_STATUS ndisStatus;
72:
73: NDIS_PROTOCOL_CHARACTERISTICS ProtChars; // Used temporarily to register
74:
75:
76: //
77: // Set up the characteristics of this protocol
78: //
79:
80: ProtChars.MajorNdisVersion = 3;
81: ProtChars.MinorNdisVersion = 0;
82:
83: ProtChars.Name.Length = NameString->Length;
84: ProtChars.Name.Buffer = (PVOID)NameString->Buffer;
85:
86: ProtChars.OpenAdapterCompleteHandler = StOpenAdapterComplete;
87: ProtChars.CloseAdapterCompleteHandler = StCloseAdapterComplete;
88: ProtChars.ResetCompleteHandler = StResetComplete;
89: ProtChars.RequestCompleteHandler = StRequestComplete;
90:
91: ProtChars.SendCompleteHandler = StSendCompletionHandler;
92: ProtChars.TransferDataCompleteHandler = StTransferDataComplete;
93:
94: ProtChars.ReceiveHandler = StReceiveIndication;
95: ProtChars.ReceiveCompleteHandler = StReceiveComplete;
96: ProtChars.StatusHandler = StStatusIndication;
97: ProtChars.StatusCompleteHandler = StStatusComplete;
98:
99: NdisRegisterProtocol (
100: &ndisStatus,
101: &StNdisProtocolHandle,
102: &ProtChars,
103: (UINT)sizeof(NDIS_PROTOCOL_CHARACTERISTICS) + NameString->Length);
104:
105: if (ndisStatus != NDIS_STATUS_SUCCESS) {
106: return (NTSTATUS)ndisStatus;
107: }
108:
109: return STATUS_SUCCESS;
110: }
111:
112:
113: VOID
114: StDeregisterProtocol (
115: VOID
116: )
117:
118: /*++
119:
120: Routine Description:
121:
122: This routine removes this transport to the NDIS interface.
123:
124: Arguments:
125:
126: None.
127:
128: Return Value:
129:
130: None.
131:
132: --*/
133:
134: {
135: NDIS_STATUS ndisStatus;
136:
137: if (StNdisProtocolHandle != (NDIS_HANDLE)NULL) {
138: NdisDeregisterProtocol (
139: &ndisStatus,
140: StNdisProtocolHandle);
141: StNdisProtocolHandle = (NDIS_HANDLE)NULL;
142: }
143: }
144:
145:
146: NDIS_STATUS
147: StSubmitNdisRequest(
148: IN PDEVICE_CONTEXT DeviceContext,
149: IN PNDIS_REQUEST NdisRequest,
150: IN PNDIS_STRING AdapterString
151: )
152:
153: /*++
154:
155: Routine Description:
156:
157: This routine passed an NDIS_REQUEST to the MAC and waits
158: until it has completed before returning the final status.
159:
160: Arguments:
161:
162: DeviceContext - Pointer to the device context for this driver.
163:
164: NdisRequest - Pointer to the NDIS_REQUEST to submit.
165:
166: AdapterString - The name of the adapter, in case an error needs
167: to be logged.
168:
169: Return Value:
170:
171: The function value is the status of the operation.
172:
173: --*/
174: {
175: NDIS_STATUS NdisStatus;
176:
177: NdisRequest(
178: &NdisStatus,
179: DeviceContext->NdisBindingHandle,
180: NdisRequest);
181:
182: if (NdisStatus == NDIS_STATUS_PENDING) {
183:
184: //
185: // The completion routine will set NdisRequestStatus.
186: //
187:
188: KeWaitForSingleObject(
189: &DeviceContext->NdisRequestEvent,
190: Executive,
191: KernelMode,
192: TRUE,
193: (PLARGE_INTEGER)NULL
194: );
195:
196: NdisStatus = DeviceContext->NdisRequestStatus;
197:
198: KeResetEvent(
199: &DeviceContext->NdisRequestEvent
200: );
201:
202: }
203:
204: if (NdisStatus != NDIS_STATUS_SUCCESS) {
205:
206: StWriteOidErrorLog(
207: DeviceContext,
208: NdisRequest->RequestType == NdisRequestSetInformation ?
209: EVENT_TRANSPORT_SET_OID_FAILED : EVENT_TRANSPORT_QUERY_OID_FAILED,
210: NdisStatus,
211: AdapterString->Buffer,
212: NdisRequest->DATA.QUERY_INFORMATION.Oid);
213: }
214:
215: return NdisStatus;
216: }
217:
218:
219: NTSTATUS
220: StInitializeNdis (
221: IN PDEVICE_CONTEXT DeviceContext,
222: IN PCONFIG_DATA StConfig,
223: IN UINT ConfigInfoNameIndex
224: )
225:
226: /*++
227:
228: Routine Description:
229:
230: This routine introduces this transport to the NDIS interface and sets up
231: any necessary NDIS data structures (Buffer pools and such). It will be
232: called for each adapter opened by this transport.
233:
234: Arguments:
235:
236: DeviceObject - Pointer to the device object for this driver.
237:
238: Irp - Pointer to the request packet representing the I/O request.
239:
240: Return Value:
241:
242: The function value is the status of the operation.
243:
244: --*/
245: {
246: ULONG SendPacketReservedLength;
247: ULONG ReceivePacketReservedLen;
248: ULONG SendPacketPoolSize;
249: ULONG ReceivePacketPoolSize;
250: NDIS_STATUS NdisStatus;
251: NDIS_STATUS OpenErrorStatus;
252: NDIS_MEDIUM StSupportedMedia[] = { NdisMedium802_3, NdisMedium802_5, NdisMediumFddi };
253: UINT SelectedMedium;
254: NDIS_REQUEST StRequest;
255: UCHAR StDataBuffer[6];
256: NDIS_OID StOid;
257: ULONG MinimumLookahead = 128 + sizeof(ST_HEADER);
258: ULONG ProtocolOptions, MacOptions;
259: PNDIS_STRING AdapterString;
260:
261: //
262: // Initialize this adapter for ST use through NDIS
263: //
264:
265: //
266: // This event is used in case any of the NDIS requests
267: // pend; we wait until it is set by the completion
268: // routine, which also sets NdisRequestStatus.
269: //
270:
271: KeInitializeEvent(
272: &DeviceContext->NdisRequestEvent,
273: NotificationEvent,
274: FALSE
275: );
276:
277: DeviceContext->NdisBindingHandle = NULL;
278: AdapterString = (PNDIS_STRING)&StConfig->Names[ConfigInfoNameIndex];
279:
280: NdisOpenAdapter (
281: &NdisStatus,
282: &OpenErrorStatus,
283: &DeviceContext->NdisBindingHandle,
284: &SelectedMedium,
285: StSupportedMedia,
286: sizeof (StSupportedMedia) / sizeof(NDIS_MEDIUM),
287: StNdisProtocolHandle,
288: (NDIS_HANDLE)DeviceContext,
289: AdapterString,
290: 0,
291: NULL);
292:
293: if (NdisStatus == NDIS_STATUS_PENDING) {
294:
295: //
296: // The completion routine will set NdisRequestStatus.
297: //
298:
299: KeWaitForSingleObject(
300: &DeviceContext->NdisRequestEvent,
301: Executive,
302: KernelMode,
303: TRUE,
304: (PLARGE_INTEGER)NULL
305: );
306:
307: NdisStatus = DeviceContext->NdisRequestStatus;
308:
309: KeResetEvent(
310: &DeviceContext->NdisRequestEvent
311: );
312:
313: }
314:
315: if (NdisStatus != NDIS_STATUS_SUCCESS) {
316:
317: StWriteGeneralErrorLog(
318: DeviceContext,
319: EVENT_TRANSPORT_ADAPTER_NOT_FOUND,
320: 807,
321: NdisStatus,
322: AdapterString->Buffer,
323: 0,
324: NULL);
325: return STATUS_INSUFFICIENT_RESOURCES;
326: }
327:
328:
329: //
330: // Get the information we need about the adapter, based on
331: // the media type.
332: //
333:
334: MacInitializeMacInfo(
335: StSupportedMedia[SelectedMedium],
336: &DeviceContext->MacInfo);
337:
338:
339: //
340: // Set the multicast/functional addresses first so we avoid windows where we
341: // receive only part of the addresses.
342: //
343:
344: MacSetMulticastAddress (
345: DeviceContext->MacInfo.MediumType,
346: DeviceContext->MulticastAddress.Address);
347:
348:
349: switch (DeviceContext->MacInfo.MediumType) {
350:
351: case NdisMedium802_3:
352:
353: //
354: // Fill in the data for our multicast list.
355: //
356:
357: RtlCopyMemory(StDataBuffer, DeviceContext->MulticastAddress.Address, 6);
358:
359: //
360: // Now fill in the NDIS_REQUEST.
361: //
362:
363: StRequest.RequestType = NdisRequestSetInformation;
364: StRequest.DATA.SET_INFORMATION.Oid = OID_802_3_MULTICAST_LIST;
365: StRequest.DATA.SET_INFORMATION.InformationBuffer = &StDataBuffer;
366: StRequest.DATA.SET_INFORMATION.InformationBufferLength = 6;
367:
368: break;
369:
370: case NdisMedium802_5:
371:
372: //
373: // For token-ring, we pass the last four bytes of the
374: // Netbios functional address.
375: //
376:
377: //
378: // Fill in the data for our functional address.
379: //
380:
381: RtlCopyMemory(StDataBuffer, ((PUCHAR)(DeviceContext->MulticastAddress.Address)) + 2, 4);
382:
383: //
384: // Now fill in the NDIS_REQUEST.
385: //
386:
387: StRequest.RequestType = NdisRequestSetInformation;
388: StRequest.DATA.SET_INFORMATION.Oid = OID_802_5_CURRENT_FUNCTIONAL;
389: StRequest.DATA.SET_INFORMATION.InformationBuffer = &StDataBuffer;
390: StRequest.DATA.SET_INFORMATION.InformationBufferLength = 4;
391:
392: break;
393:
394: case NdisMediumFddi:
395:
396: //
397: // Fill in the data for our multicast list.
398: //
399:
400: RtlCopyMemory(StDataBuffer, DeviceContext->MulticastAddress.Address, 6);
401:
402: //
403: // Now fill in the NDIS_REQUEST.
404: //
405:
406: StRequest.RequestType = NdisRequestSetInformation;
407: StRequest.DATA.SET_INFORMATION.Oid = OID_FDDI_LONG_MULTICAST_LIST;
408: StRequest.DATA.SET_INFORMATION.InformationBuffer = &StDataBuffer;
409: StRequest.DATA.SET_INFORMATION.InformationBufferLength = 6;
410:
411: break;
412:
413: }
414:
415: NdisStatus = StSubmitNdisRequest (DeviceContext, &StRequest, AdapterString);
416:
417: if (NdisStatus != NDIS_STATUS_SUCCESS) {
418: StCloseNdis (DeviceContext);
419: return STATUS_INSUFFICIENT_RESOURCES;
420: }
421:
422:
423:
424: switch (DeviceContext->MacInfo.MediumType) {
425:
426: case NdisMedium802_3:
427:
428: StOid = OID_802_3_CURRENT_ADDRESS;
429: break;
430:
431: case NdisMedium802_5:
432:
433: StOid = OID_802_5_CURRENT_ADDRESS;
434: break;
435:
436: case NdisMediumFddi:
437:
438: StOid = OID_FDDI_LONG_CURRENT_ADDR;
439: break;
440:
441: default:
442:
443: NdisStatus = NDIS_STATUS_FAILURE;
444: break;
445:
446: }
447:
448: StRequest.RequestType = NdisRequestQueryInformation;
449: StRequest.DATA.QUERY_INFORMATION.Oid = StOid;
450: StRequest.DATA.QUERY_INFORMATION.InformationBuffer = DeviceContext->LocalAddress.Address;
451: StRequest.DATA.QUERY_INFORMATION.InformationBufferLength = 6;
452:
453: NdisStatus = StSubmitNdisRequest (DeviceContext, &StRequest, AdapterString);
454:
455: if (NdisStatus != NDIS_STATUS_SUCCESS) {
456: StCloseNdis (DeviceContext);
457: return STATUS_INSUFFICIENT_RESOURCES;
458: }
459:
460: //
461: // Set up the reserved Netbios address.
462: //
463:
464: RtlZeroMemory(DeviceContext->ReservedNetBIOSAddress, 10);
465: RtlCopyMemory(&DeviceContext->ReservedNetBIOSAddress[10], DeviceContext->LocalAddress.Address, 6);
466:
467:
468: //
469: // Now query the maximum packet sizes.
470: //
471:
472: StRequest.RequestType = NdisRequestQueryInformation;
473: StRequest.DATA.QUERY_INFORMATION.Oid = OID_GEN_MAXIMUM_FRAME_SIZE;
474: StRequest.DATA.QUERY_INFORMATION.InformationBuffer = &(DeviceContext->MaxReceivePacketSize);
475: StRequest.DATA.QUERY_INFORMATION.InformationBufferLength = 4;
476:
477: NdisStatus = StSubmitNdisRequest (DeviceContext, &StRequest, AdapterString);
478:
479: if (NdisStatus != NDIS_STATUS_SUCCESS) {
480: StCloseNdis (DeviceContext);
481: return STATUS_INSUFFICIENT_RESOURCES;
482: }
483:
484:
485: StRequest.RequestType = NdisRequestQueryInformation;
486: StRequest.DATA.QUERY_INFORMATION.Oid = OID_GEN_MAXIMUM_TOTAL_SIZE;
487: StRequest.DATA.QUERY_INFORMATION.InformationBuffer = &(DeviceContext->MaxSendPacketSize);
488: StRequest.DATA.QUERY_INFORMATION.InformationBufferLength = 4;
489:
490: NdisStatus = StSubmitNdisRequest (DeviceContext, &StRequest, AdapterString);
491:
492: if (NdisStatus != NDIS_STATUS_SUCCESS) {
493: StCloseNdis (DeviceContext);
494: return STATUS_INSUFFICIENT_RESOURCES;
495: }
496:
497:
498: //
499: // Now set the minimum lookahead size.
500: //
501:
502: StRequest.RequestType = NdisRequestSetInformation;
503: StRequest.DATA.QUERY_INFORMATION.Oid = OID_GEN_CURRENT_LOOKAHEAD;
504: StRequest.DATA.QUERY_INFORMATION.InformationBuffer = &MinimumLookahead;
505: StRequest.DATA.QUERY_INFORMATION.InformationBufferLength = 4;
506:
507: NdisStatus = StSubmitNdisRequest (DeviceContext, &StRequest, AdapterString);
508:
509: if (NdisStatus != NDIS_STATUS_SUCCESS) {
510: StCloseNdis (DeviceContext);
511: return STATUS_INSUFFICIENT_RESOURCES;
512: }
513:
514:
515: //
516: // Now query the link speed
517: //
518:
519: StRequest.RequestType = NdisRequestQueryInformation;
520: StRequest.DATA.QUERY_INFORMATION.Oid = OID_GEN_LINK_SPEED;
521: StRequest.DATA.QUERY_INFORMATION.InformationBuffer = &(DeviceContext->MediumSpeed);
522: StRequest.DATA.QUERY_INFORMATION.InformationBufferLength = 4;
523:
524: NdisStatus = StSubmitNdisRequest (DeviceContext, &StRequest, AdapterString);
525:
526: if (NdisStatus != NDIS_STATUS_SUCCESS) {
527: StCloseNdis (DeviceContext);
528: return STATUS_INSUFFICIENT_RESOURCES;
529: }
530:
531:
532: //
533: // Now query the MAC's optional characteristics.
534: //
535:
536: StRequest.RequestType = NdisRequestQueryInformation;
537: StRequest.DATA.QUERY_INFORMATION.Oid = OID_GEN_MAC_OPTIONS;
538: StRequest.DATA.QUERY_INFORMATION.InformationBuffer = &MacOptions;
539: StRequest.DATA.QUERY_INFORMATION.InformationBufferLength = 4;
540:
541: NdisStatus = StSubmitNdisRequest (DeviceContext, &StRequest, AdapterString);
542:
543: if (NdisStatus != NDIS_STATUS_SUCCESS) {
544: StCloseNdis (DeviceContext);
545: return STATUS_INSUFFICIENT_RESOURCES;
546: }
547:
548: //
549: // Since the sample transport does not try to optimize for the
550: // cases where transfer data is always synchronous or indications
551: // are not reentered, we ignore those bits in MacOptions.
552: //
553:
554: DeviceContext->MacInfo.CopyLookahead =
555: (BOOLEAN)((MacOptions & NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA) != 0);
556:
557:
558: //
559: // Now set our options if needed. We can only support
560: // partial indications if running over 802.3 where the
561: // real packet length can be obtained from the header.
562: //
563:
564: if (DeviceContext->MacInfo.MediumType == NdisMedium802_3) {
565:
566: ProtocolOptions = NDIS_PROT_OPTION_ESTIMATED_LENGTH;
567:
568: StRequest.RequestType = NdisRequestSetInformation;
569: StRequest.DATA.QUERY_INFORMATION.Oid = OID_GEN_PROTOCOL_OPTIONS;
570: StRequest.DATA.QUERY_INFORMATION.InformationBuffer = &ProtocolOptions;
571: StRequest.DATA.QUERY_INFORMATION.InformationBufferLength = 4;
572:
573: NdisStatus = StSubmitNdisRequest (DeviceContext, &StRequest, AdapterString);
574:
575: if (NdisStatus != NDIS_STATUS_SUCCESS) {
576: StCloseNdis (DeviceContext);
577: return STATUS_INSUFFICIENT_RESOURCES;
578: }
579:
580: }
581:
582:
583: //
584: // Calculate the NDIS-related stuff.
585: //
586:
587: SendPacketReservedLength = sizeof (SEND_PACKET_TAG);
588: ReceivePacketReservedLen = sizeof (RECEIVE_PACKET_TAG);
589:
590: //
591: // The send packet pool is used for UI frames and regular packets.
592: //
593:
594: SendPacketPoolSize = StConfig->SendPacketPoolSize;
595:
596: //
597: // The receive packet pool is used in transfer data.
598: //
599:
600: ReceivePacketPoolSize = StConfig->ReceivePacketPoolSize;
601:
602:
603: NdisAllocatePacketPool (
604: &NdisStatus,
605: &DeviceContext->SendPacketPoolHandle,
606: SendPacketPoolSize,
607: SendPacketReservedLength);
608:
609: if (NdisStatus != NDIS_STATUS_SUCCESS) {
610: DeviceContext->SendPacketPoolHandle = NULL;
611: StCloseNdis (DeviceContext);
612: return STATUS_INSUFFICIENT_RESOURCES;
613: }
614:
615: DeviceContext->MemoryUsage +=
616: (SendPacketPoolSize *
617: (sizeof(NDIS_PACKET) + SendPacketReservedLength));
618:
619:
620: NdisAllocatePacketPool(
621: &NdisStatus,
622: &DeviceContext->ReceivePacketPoolHandle,
623: ReceivePacketPoolSize,
624: ReceivePacketReservedLen);
625:
626: if (NdisStatus != NDIS_STATUS_SUCCESS) {
627: DeviceContext->ReceivePacketPoolHandle = NULL;
628: StCloseNdis (DeviceContext);
629: return STATUS_INSUFFICIENT_RESOURCES;
630: }
631:
632: DeviceContext->MemoryUsage +=
633: (ReceivePacketPoolSize *
634: (sizeof(NDIS_PACKET) + ReceivePacketReservedLen));
635:
636:
637: //
638: // Allocate the buffer pool; as an estimate, allocate
639: // one per send or receive packet.
640: //
641:
642: NdisAllocateBufferPool (
643: &NdisStatus,
644: &DeviceContext->NdisBufferPoolHandle,
645: SendPacketPoolSize + ReceivePacketPoolSize);
646:
647: if (NdisStatus != NDIS_STATUS_SUCCESS) {
648: DeviceContext->NdisBufferPoolHandle = NULL;
649: StCloseNdis (DeviceContext);
650: return STATUS_INSUFFICIENT_RESOURCES;
651: }
652:
653:
654: //
655: // Now that everything is set up, we enable the filter
656: // for packet reception.
657: //
658:
659: //
660: // Fill in the OVB for packet filter.
661: //
662:
663: switch (DeviceContext->MacInfo.MediumType) {
664:
665: case NdisMedium802_3:
666: case NdisMediumFddi:
667:
668: RtlStoreUlong((PULONG)StDataBuffer,
669: (NDIS_PACKET_TYPE_DIRECTED | NDIS_PACKET_TYPE_MULTICAST));
670: break;
671:
672: case NdisMedium802_5:
673:
674: RtlStoreUlong((PULONG)StDataBuffer,
675: (NDIS_PACKET_TYPE_DIRECTED | NDIS_PACKET_TYPE_FUNCTIONAL));
676: break;
677:
678: default:
679:
680: ASSERT (FALSE);
681: break;
682:
683: }
684:
685: //
686: // Now fill in the NDIS_REQUEST.
687: //
688:
689: StRequest.RequestType = NdisRequestSetInformation;
690: StRequest.DATA.SET_INFORMATION.Oid = OID_GEN_CURRENT_PACKET_FILTER;
691: StRequest.DATA.SET_INFORMATION.InformationBuffer = &StDataBuffer;
692: StRequest.DATA.SET_INFORMATION.InformationBufferLength = sizeof(ULONG);
693:
694: NdisStatus = StSubmitNdisRequest (DeviceContext, &StRequest, AdapterString);
695:
696: if (NdisStatus != NDIS_STATUS_SUCCESS) {
697: StCloseNdis (DeviceContext);
698: return STATUS_INSUFFICIENT_RESOURCES;
699: }
700:
701:
702: return STATUS_SUCCESS;
703:
704: } /* StInitializeNdis */
705:
706:
707: VOID
708: StCloseNdis (
709: IN PDEVICE_CONTEXT DeviceContext
710: )
711:
712: /*++
713:
714: Routine Description:
715:
716: This routine unbinds the transport from the NDIS interface and does
717: any other work required to undo what was done in StInitializeNdis.
718: It is written so that it can be called from within StInitializeNdis
719: if it fails partway through.
720:
721: Arguments:
722:
723: DeviceObject - Pointer to the device object for this driver.
724:
725: Return Value:
726:
727: The function value is the status of the operation.
728:
729: --*/
730: {
731: NDIS_STATUS ndisStatus;
732:
733: //
734: // Close the NDIS binding.
735: //
736:
737: if (DeviceContext->NdisBindingHandle != (NDIS_HANDLE)NULL) {
738:
739: //
740: // This event is used in case any of the NDIS requests
741: // pend; we wait until it is set by the completion
742: // routine, which also sets NdisRequestStatus.
743: //
744:
745: KeInitializeEvent(
746: &DeviceContext->NdisRequestEvent,
747: NotificationEvent,
748: FALSE
749: );
750:
751: NdisCloseAdapter(
752: &ndisStatus,
753: DeviceContext->NdisBindingHandle);
754:
755: if (ndisStatus == NDIS_STATUS_PENDING) {
756:
757: //
758: // The completion routine will set NdisRequestStatus.
759: //
760:
761: KeWaitForSingleObject(
762: &DeviceContext->NdisRequestEvent,
763: Executive,
764: KernelMode,
765: TRUE,
766: (PLARGE_INTEGER)NULL
767: );
768:
769: ndisStatus = DeviceContext->NdisRequestStatus;
770:
771: KeResetEvent(
772: &DeviceContext->NdisRequestEvent
773: );
774:
775: }
776:
777: //
778: // We ignore ndisStatus.
779: //
780:
781: }
782:
783: if (DeviceContext->SendPacketPoolHandle != NULL) {
784: NdisFreePacketPool (DeviceContext->SendPacketPoolHandle);
785: }
786:
787: if (DeviceContext->ReceivePacketPoolHandle != NULL) {
788: NdisFreePacketPool (DeviceContext->ReceivePacketPoolHandle);
789: }
790:
791: if (DeviceContext->NdisBufferPoolHandle != NULL) {
792: NdisFreeBufferPool (DeviceContext->NdisBufferPoolHandle);
793: }
794:
795: } /* StCloseNdis */
796:
797:
798: VOID
799: StOpenAdapterComplete (
800: IN NDIS_HANDLE BindingContext,
801: IN NDIS_STATUS NdisStatus,
802: IN NDIS_STATUS OpenErrorStatus
803: )
804:
805: /*++
806:
807: Routine Description:
808:
809: This routine is called by NDIS to indicate that an open adapter
810: is complete. Since we only ever have one outstanding, and then only
811: during initialization, all we do is record the status and set
812: the event to signalled to unblock the initialization thread.
813:
814: Arguments:
815:
816: BindingContext - Pointer to the device object for this driver.
817:
818: NdisStatus - The request completion code.
819:
820: OpenErrorStatus - More status information.
821:
822: Return Value:
823:
824: None.
825:
826: --*/
827:
828: {
829: PDEVICE_CONTEXT DeviceContext = (PDEVICE_CONTEXT)BindingContext;
830:
831: DeviceContext->NdisRequestStatus = NdisStatus;
832: KeSetEvent(
833: &DeviceContext->NdisRequestEvent,
834: 0L,
835: FALSE);
836:
837: return;
838: }
839:
840: VOID
841: StCloseAdapterComplete (
842: IN NDIS_HANDLE BindingContext,
843: IN NDIS_STATUS NdisStatus
844: )
845:
846: /*++
847:
848: Routine Description:
849:
850: This routine is called by NDIS to indicate that a close adapter
851: is complete. Currently we don't close adapters, so this is not
852: a problem.
853:
854: Arguments:
855:
856: BindingContext - Pointer to the device object for this driver.
857:
858: NdisStatus - The request completion code.
859:
860: Return Value:
861:
862: None.
863:
864: --*/
865:
866: {
867: PDEVICE_CONTEXT DeviceContext = (PDEVICE_CONTEXT)BindingContext;
868:
869: DeviceContext->NdisRequestStatus = NdisStatus;
870: KeSetEvent(
871: &DeviceContext->NdisRequestEvent,
872: 0L,
873: FALSE);
874:
875: return;
876: }
877:
878: VOID
879: StResetComplete (
880: IN NDIS_HANDLE BindingContext,
881: IN NDIS_STATUS NdisStatus
882: )
883:
884: /*++
885:
886: Routine Description:
887:
888: This routine is called by NDIS to indicate that a reset adapter
889: is complete. Currently we don't reset adapters, so this is not
890: a problem.
891:
892: Arguments:
893:
894: BindingContext - Pointer to the device object for this driver.
895:
896: NdisStatus - The request completion code.
897:
898: Return Value:
899:
900: None.
901:
902: --*/
903:
904: {
905: UNREFERENCED_PARAMETER(BindingContext);
906: UNREFERENCED_PARAMETER(NdisStatus);
907:
908: return;
909: }
910:
911: VOID
912: StRequestComplete (
913: IN NDIS_HANDLE BindingContext,
914: IN PNDIS_REQUEST NdisRequest,
915: IN NDIS_STATUS NdisStatus
916: )
917:
918: /*++
919:
920: Routine Description:
921:
922: This routine is called by NDIS to indicate that a request is complete.
923: Since we only ever have one request outstanding, and then only
924: during initialization, all we do is record the status and set
925: the event to signalled to unblock the initialization thread.
926:
927: Arguments:
928:
929: BindingContext - Pointer to the device object for this driver.
930:
931: NdisRequest - The object describing the request.
932:
933: NdisStatus - The request completion code.
934:
935: Return Value:
936:
937: None.
938:
939: --*/
940:
941: {
942: PDEVICE_CONTEXT DeviceContext = (PDEVICE_CONTEXT)BindingContext;
943:
944: DeviceContext->NdisRequestStatus = NdisStatus;
945: KeSetEvent(
946: &DeviceContext->NdisRequestEvent,
947: 0L,
948: FALSE);
949:
950: return;
951: }
952:
953: VOID
954: StStatusIndication (
955: IN NDIS_HANDLE NdisBindingContext,
956: IN NDIS_STATUS NdisStatus,
957: IN PVOID StatusBuffer,
958: IN UINT StatusBufferSize
959: )
960:
961: {
962: PDEVICE_CONTEXT DeviceContext;
963:
964: DeviceContext = (PDEVICE_CONTEXT)NdisBindingContext;
965:
966: switch (NdisStatus) {
967:
968: //
969: // Handle various status codes here.
970: //
971:
972: default:
973: break;
974:
975: }
976: }
977:
978:
979: VOID
980: StStatusComplete (
981: IN NDIS_HANDLE NdisBindingContext
982: )
983: {
984: UNREFERENCED_PARAMETER (NdisBindingContext);
985:
986: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.