3 Copyright (c) 1992-2000 Microsoft Corporation
\r
11 Ndis Intermediate Miniport driver sample. This is a passthru driver.
\r
23 #include "precomp.h"
\r
30 OUT PNDIS_STATUS OpenErrorStatus,
\r
31 OUT PUINT SelectedMediumIndex,
\r
32 IN PNDIS_MEDIUM MediumArray,
\r
33 IN UINT MediumArraySize,
\r
34 IN NDIS_HANDLE MiniportAdapterHandle,
\r
35 IN NDIS_HANDLE WrapperConfigurationContext
\r
39 Routine Description:
\r
41 This is the initialize handler which gets called as a result of
\r
42 the BindAdapter handler calling NdisIMInitializeDeviceInstanceEx.
\r
43 The context parameter which we pass there is the adapter structure
\r
44 which we retrieve here.
\r
48 OpenErrorStatus Not used by us.
\r
49 SelectedMediumIndex Place-holder for what media we are using
\r
50 MediumArray Array of ndis media passed down to us to pick from
\r
51 MediumArraySize Size of the array
\r
52 MiniportAdapterHandle The handle NDIS uses to refer to us
\r
53 WrapperConfigurationContext For use by NdisOpenConfiguration
\r
57 NDIS_STATUS_SUCCESS unless something goes wrong
\r
63 NDIS_STATUS Status = NDIS_STATUS_FAILURE;
\r
66 UNREFERENCED_PARAMETER(WrapperConfigurationContext);
\r
71 // Start off by retrieving our adapter context and storing
\r
72 // the Miniport handle in it.
\r
74 pAdapt = NdisIMGetDeviceContext(MiniportAdapterHandle);
\r
75 pAdapt->MiniportIsHalted = FALSE;
\r
77 DBGPRINT(("==> Miniport Initialize: Adapt %p\n", pAdapt));
\r
80 // Usually we export the medium type of the adapter below as our
\r
81 // virtual miniport's medium type. However if the adapter below us
\r
82 // is a WAN device, then we claim to be of medium type 802.3.
\r
84 Medium = pAdapt->Medium;
\r
86 if (Medium == NdisMediumWan)
\r
88 Medium = NdisMedium802_3;
\r
91 for (i = 0; i < MediumArraySize; i++)
\r
93 if (MediumArray[i] == Medium)
\r
95 *SelectedMediumIndex = i;
\r
100 if (i == MediumArraySize)
\r
102 Status = NDIS_STATUS_UNSUPPORTED_MEDIA;
\r
108 // Set the attributes now. NDIS_ATTRIBUTE_DESERIALIZE enables us
\r
109 // to make up-calls to NDIS without having to call NdisIMSwitchToMiniport
\r
110 // or NdisIMQueueCallBack. This also forces us to protect our data using
\r
111 // spinlocks where appropriate. Also in this case NDIS does not queue
\r
112 // packets on our behalf. Since this is a very simple pass-thru
\r
113 // miniport, we do not have a need to protect anything. However in
\r
114 // a general case there will be a need to use per-adapter spin-locks
\r
115 // for the packet queues at the very least.
\r
117 NdisMSetAttributesEx(MiniportAdapterHandle,
\r
119 0, // CheckForHangTimeInSeconds
\r
120 NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT |
\r
121 NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT|
\r
122 NDIS_ATTRIBUTE_INTERMEDIATE_DRIVER |
\r
123 NDIS_ATTRIBUTE_DESERIALIZE |
\r
124 NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND,
\r
127 pAdapt->MiniportHandle = MiniportAdapterHandle;
\r
129 // Initialize LastIndicatedStatus to be NDIS_STATUS_MEDIA_CONNECT
\r
131 pAdapt->LastIndicatedStatus = NDIS_STATUS_MEDIA_CONNECT;
\r
134 // Initialize the power states for both the lower binding (PTDeviceState)
\r
135 // and our miniport edge to Powered On.
\r
137 pAdapt->MPDeviceState = NdisDeviceStateD0;
\r
138 pAdapt->PTDeviceState = NdisDeviceStateD0;
\r
141 // Add this adapter to the global pAdapt List
\r
143 NdisAcquireSpinLock(&GlobalLock);
\r
145 pAdapt->Next = pAdaptList;
\r
146 pAdaptList = pAdapt;
\r
148 NdisReleaseSpinLock(&GlobalLock);
\r
151 // Create an ioctl interface
\r
153 (VOID)PtRegisterDevice();
\r
155 Status = NDIS_STATUS_SUCCESS;
\r
160 // If we had received an UnbindAdapter notification on the underlying
\r
161 // adapter, we would have blocked that thread waiting for the IM Init
\r
162 // process to complete. Wake up any such thread.
\r
164 ASSERT(pAdapt->MiniportInitPending == TRUE);
\r
165 pAdapt->MiniportInitPending = FALSE;
\r
166 NdisSetEvent(&pAdapt->MiniportInitEvent);
\r
168 if (Status == NDIS_STATUS_SUCCESS)
\r
170 PtReferenceAdapt(pAdapt);
\r
173 DBGPRINT(("<== Miniport Initialize: Adapt %p, Status %x\n", pAdapt, Status));
\r
175 *OpenErrorStatus = Status;
\r
184 IN NDIS_HANDLE MiniportAdapterContext,
\r
185 IN PNDIS_PACKET Packet,
\r
190 Routine Description:
\r
192 Send Packet handler. Either this or our SendPackets (array) handler is called
\r
193 based on which one is enabled in our Miniport Characteristics.
\r
197 MiniportAdapterContext Pointer to the adapter
\r
198 Packet Packet to send
\r
199 Flags Unused, passed down below
\r
203 Return code from NdisSend
\r
207 PADAPT pAdapt = (PADAPT)MiniportAdapterContext;
\r
208 NDIS_STATUS Status;
\r
209 PNDIS_PACKET MyPacket;
\r
210 PVOID MediaSpecificInfo = NULL;
\r
211 ULONG MediaSpecificInfoSize = 0;
\r
214 // The driver should fail the send if the virtual miniport is in low
\r
217 if (pAdapt->MPDeviceState > NdisDeviceStateD0)
\r
219 return NDIS_STATUS_FAILURE;
\r
224 // Use NDIS 5.1 packet stacking:
\r
227 PNDIS_PACKET_STACK pStack;
\r
231 // Packet stacks: Check if we can use the same packet for sending down.
\r
234 pStack = NdisIMGetCurrentPacketStack(Packet, &Remaining);
\r
238 // We can reuse "Packet".
\r
240 // NOTE: if we needed to keep per-packet information in packets
\r
241 // sent down, we can use pStack->IMReserved[].
\r
245 // If the below miniport is going to low power state, stop sending down any packet.
\r
247 NdisAcquireSpinLock(&pAdapt->Lock);
\r
248 if (pAdapt->PTDeviceState > NdisDeviceStateD0)
\r
250 NdisReleaseSpinLock(&pAdapt->Lock);
\r
251 return NDIS_STATUS_FAILURE;
\r
253 pAdapt->OutstandingSends++;
\r
254 NdisReleaseSpinLock(&pAdapt->Lock);
\r
256 pAdapt->BindingHandle,
\r
259 if (Status != NDIS_STATUS_PENDING)
\r
261 ADAPT_DECR_PENDING_SENDS(pAdapt);
\r
270 // We are either not using packet stacks, or there isn't stack space
\r
271 // in the original packet passed down to us. Allocate a new packet
\r
272 // to wrap the data with.
\r
275 // If the below miniport is going to low power state, stop sending down any packet.
\r
277 NdisAcquireSpinLock(&pAdapt->Lock);
\r
278 if (pAdapt->PTDeviceState > NdisDeviceStateD0)
\r
280 NdisReleaseSpinLock(&pAdapt->Lock);
\r
281 return NDIS_STATUS_FAILURE;
\r
284 pAdapt->OutstandingSends++;
\r
285 NdisReleaseSpinLock(&pAdapt->Lock);
\r
287 NdisAllocatePacket(&Status,
\r
289 pAdapt->SendPacketPoolHandle);
\r
291 if (Status == NDIS_STATUS_SUCCESS)
\r
293 PSEND_RSVD SendRsvd;
\r
296 // Save a pointer to the original packet in our reserved
\r
297 // area in the new packet. This is needed so that we can
\r
298 // get back to the original packet when the new packet's send
\r
301 SendRsvd = (PSEND_RSVD)(MyPacket->ProtocolReserved);
\r
302 SendRsvd->OriginalPkt = Packet;
\r
304 NdisGetPacketFlags(MyPacket) = Flags;
\r
307 // Set up the new packet so that it describes the same
\r
308 // data as the original packet.
\r
310 NDIS_PACKET_FIRST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_FIRST_NDIS_BUFFER(Packet);
\r
311 NDIS_PACKET_LAST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_LAST_NDIS_BUFFER(Packet);
\r
314 // Work around the fact that NDIS does not initialize this
\r
315 // to FALSE on Win9x.
\r
317 NDIS_PACKET_VALID_COUNTS(MyPacket) = FALSE;
\r
321 // Copy the OOB Offset from the original packet to the new
\r
324 NdisMoveMemory(NDIS_OOB_DATA_FROM_PACKET(MyPacket),
\r
325 NDIS_OOB_DATA_FROM_PACKET(Packet),
\r
326 sizeof(NDIS_PACKET_OOB_DATA));
\r
330 // Copy the right parts of per packet info into the new packet.
\r
331 // This API is not available on Win9x since task offload is
\r
332 // not supported on that platform.
\r
334 NdisIMCopySendPerPacketInfo(MyPacket, Packet);
\r
338 // Copy the Media specific information
\r
340 NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO(Packet,
\r
341 &MediaSpecificInfo,
\r
342 &MediaSpecificInfoSize);
\r
344 if (MediaSpecificInfo || MediaSpecificInfoSize)
\r
346 NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO(MyPacket,
\r
348 MediaSpecificInfoSize);
\r
352 pAdapt->BindingHandle,
\r
356 if (Status != NDIS_STATUS_PENDING)
\r
359 NdisIMCopySendCompletePerPacketInfo (Packet, MyPacket);
\r
361 NdisFreePacket(MyPacket);
\r
362 ADAPT_DECR_PENDING_SENDS(pAdapt);
\r
367 ADAPT_DECR_PENDING_SENDS(pAdapt);
\r
369 // We are out of packets. Silently drop it. Alternatively we can deal with it:
\r
370 // - By keeping separate send and receive pools
\r
371 // - Dynamically allocate more pools as needed and free them when not needed
\r
381 IN NDIS_HANDLE MiniportAdapterContext,
\r
382 IN PPNDIS_PACKET PacketArray,
\r
383 IN UINT NumberOfPackets
\r
387 Routine Description:
\r
389 Send Packet Array handler. Either this or our SendPacket handler is called
\r
390 based on which one is enabled in our Miniport Characteristics.
\r
394 MiniportAdapterContext Pointer to our adapter
\r
395 PacketArray Set of packets to send
\r
396 NumberOfPackets Self-explanatory
\r
404 PADAPT pAdapt = (PADAPT)MiniportAdapterContext;
\r
405 NDIS_STATUS Status;
\r
407 PVOID MediaSpecificInfo = NULL;
\r
408 UINT MediaSpecificInfoSize = 0;
\r
411 for (i = 0; i < NumberOfPackets; i++)
\r
413 PNDIS_PACKET Packet, MyPacket;
\r
415 Packet = PacketArray[i];
\r
417 // The driver should fail the send if the virtual miniport is in low
\r
420 if (pAdapt->MPDeviceState > NdisDeviceStateD0)
\r
422 NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
\r
424 NDIS_STATUS_FAILURE);
\r
431 // Use NDIS 5.1 packet stacking:
\r
434 PNDIS_PACKET_STACK pStack;
\r
438 // Packet stacks: Check if we can use the same packet for sending down.
\r
440 pStack = NdisIMGetCurrentPacketStack(Packet, &Remaining);
\r
444 // We can reuse "Packet".
\r
446 // NOTE: if we needed to keep per-packet information in packets
\r
447 // sent down, we can use pStack->IMReserved[].
\r
451 // If the below miniport is going to low power state, stop sending down any packet.
\r
453 NdisAcquireSpinLock(&pAdapt->Lock);
\r
454 if (pAdapt->PTDeviceState > NdisDeviceStateD0)
\r
456 NdisReleaseSpinLock(&pAdapt->Lock);
\r
457 NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
\r
459 NDIS_STATUS_FAILURE);
\r
463 pAdapt->OutstandingSends++;
\r
464 NdisReleaseSpinLock(&pAdapt->Lock);
\r
467 pAdapt->BindingHandle,
\r
470 if (Status != NDIS_STATUS_PENDING)
\r
472 NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
\r
476 ADAPT_DECR_PENDING_SENDS(pAdapt);
\r
485 NdisAcquireSpinLock(&pAdapt->Lock);
\r
487 // If the below miniport is going to low power state, stop sending down any packet.
\r
489 if (pAdapt->PTDeviceState > NdisDeviceStateD0)
\r
491 NdisReleaseSpinLock(&pAdapt->Lock);
\r
492 Status = NDIS_STATUS_FAILURE;
\r
495 pAdapt->OutstandingSends++;
\r
496 NdisReleaseSpinLock(&pAdapt->Lock);
\r
498 NdisAllocatePacket(&Status,
\r
500 pAdapt->SendPacketPoolHandle);
\r
502 if (Status == NDIS_STATUS_SUCCESS)
\r
504 PSEND_RSVD SendRsvd;
\r
506 SendRsvd = (PSEND_RSVD)(MyPacket->ProtocolReserved);
\r
507 SendRsvd->OriginalPkt = Packet;
\r
509 NdisGetPacketFlags(MyPacket) = NdisGetPacketFlags(Packet);
\r
511 NDIS_PACKET_FIRST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_FIRST_NDIS_BUFFER(Packet);
\r
512 NDIS_PACKET_LAST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_LAST_NDIS_BUFFER(Packet);
\r
515 // Work around the fact that NDIS does not initialize this
\r
516 // to FALSE on Win9x.
\r
518 NDIS_PACKET_VALID_COUNTS(MyPacket) = FALSE;
\r
522 // Copy the OOB data from the original packet to the new
\r
525 NdisMoveMemory(NDIS_OOB_DATA_FROM_PACKET(MyPacket),
\r
526 NDIS_OOB_DATA_FROM_PACKET(Packet),
\r
527 sizeof(NDIS_PACKET_OOB_DATA));
\r
529 // Copy relevant parts of the per packet info into the new packet
\r
532 NdisIMCopySendPerPacketInfo(MyPacket, Packet);
\r
536 // Copy the Media specific information
\r
538 NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO(Packet,
\r
539 &MediaSpecificInfo,
\r
540 &MediaSpecificInfoSize);
\r
542 if (MediaSpecificInfo || MediaSpecificInfoSize)
\r
544 NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO(MyPacket,
\r
546 MediaSpecificInfoSize);
\r
550 pAdapt->BindingHandle,
\r
553 if (Status != NDIS_STATUS_PENDING)
\r
556 NdisIMCopySendCompletePerPacketInfo (Packet, MyPacket);
\r
558 NdisFreePacket(MyPacket);
\r
559 ADAPT_DECR_PENDING_SENDS(pAdapt);
\r
565 // The driver cannot allocate a packet.
\r
567 ADAPT_DECR_PENDING_SENDS(pAdapt);
\r
572 if (Status != NDIS_STATUS_PENDING)
\r
574 NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
\r
583 MPQueryInformation(
\r
584 IN NDIS_HANDLE MiniportAdapterContext,
\r
586 IN PVOID InformationBuffer,
\r
587 IN ULONG InformationBufferLength,
\r
588 OUT PULONG BytesWritten,
\r
589 OUT PULONG BytesNeeded
\r
593 Routine Description:
\r
595 Entry point called by NDIS to query for the value of the specified OID.
\r
596 Typical processing is to forward the query down to the underlying miniport.
\r
598 The following OIDs are filtered here:
\r
600 OID_PNP_QUERY_POWER - return success right here
\r
602 OID_GEN_SUPPORTED_GUIDS - do not forward, otherwise we will show up
\r
603 multiple instances of private GUIDs supported by the underlying miniport.
\r
605 OID_PNP_CAPABILITIES - we do send this down to the lower miniport, but
\r
606 the values returned are postprocessed before we complete this request;
\r
607 see PtRequestComplete.
\r
609 NOTE on OID_TCP_TASK_OFFLOAD - if this IM driver modifies the contents
\r
610 of data it passes through such that a lower miniport may not be able
\r
611 to perform TCP task offload, then it should not forward this OID down,
\r
612 but fail it here with the status NDIS_STATUS_NOT_SUPPORTED. This is to
\r
613 avoid performing incorrect transformations on data.
\r
615 If our miniport edge (upper edge) is at a low-power state, fail the request.
\r
617 If our protocol edge (lower edge) has been notified of a low-power state,
\r
618 we pend this request until the miniport below has been set to D0. Since
\r
619 requests to miniports are serialized always, at most a single request will
\r
624 MiniportAdapterContext Pointer to the adapter structure
\r
625 Oid Oid for this query
\r
626 InformationBuffer Buffer for information
\r
627 InformationBufferLength Size of this buffer
\r
628 BytesWritten Specifies how much info is written
\r
629 BytesNeeded In case the buffer is smaller than what we need, tell them how much is needed
\r
634 Return code from the NdisRequest below.
\r
638 PADAPT pAdapt = (PADAPT)MiniportAdapterContext;
\r
639 NDIS_STATUS Status = NDIS_STATUS_FAILURE;
\r
643 if (Oid == OID_PNP_QUERY_POWER)
\r
646 // Do not forward this.
\r
648 Status = NDIS_STATUS_SUCCESS;
\r
652 if (Oid == OID_GEN_SUPPORTED_GUIDS)
\r
655 // Do not forward this, otherwise we will end up with multiple
\r
656 // instances of private GUIDs that the underlying miniport
\r
659 Status = NDIS_STATUS_NOT_SUPPORTED;
\r
663 if (Oid == OID_TCP_TASK_OFFLOAD)
\r
666 // Fail this -if- this driver performs data transformations
\r
667 // that can interfere with a lower driver's ability to offload
\r
670 // Status = NDIS_STATUS_NOT_SUPPORTED;
\r
675 // If the miniport below is unbinding, just fail any request
\r
677 NdisAcquireSpinLock(&pAdapt->Lock);
\r
678 if (pAdapt->UnbindingInProcess == TRUE)
\r
680 NdisReleaseSpinLock(&pAdapt->Lock);
\r
681 Status = NDIS_STATUS_FAILURE;
\r
684 NdisReleaseSpinLock(&pAdapt->Lock);
\r
686 // All other queries are failed, if the miniport is not at D0,
\r
688 if (pAdapt->MPDeviceState > NdisDeviceStateD0)
\r
690 Status = NDIS_STATUS_FAILURE;
\r
694 pAdapt->Request.RequestType = NdisRequestQueryInformation;
\r
695 pAdapt->Request.DATA.QUERY_INFORMATION.Oid = Oid;
\r
696 pAdapt->Request.DATA.QUERY_INFORMATION.InformationBuffer = InformationBuffer;
\r
697 pAdapt->Request.DATA.QUERY_INFORMATION.InformationBufferLength = InformationBufferLength;
\r
698 pAdapt->BytesNeeded = BytesNeeded;
\r
699 pAdapt->BytesReadOrWritten = BytesWritten;
\r
702 // If the miniport below is binding, fail the request
\r
704 NdisAcquireSpinLock(&pAdapt->Lock);
\r
706 if (pAdapt->UnbindingInProcess == TRUE)
\r
708 NdisReleaseSpinLock(&pAdapt->Lock);
\r
709 Status = NDIS_STATUS_FAILURE;
\r
713 // If the Protocol device state is OFF, mark this request as being
\r
714 // pended. We queue this until the device state is back to D0.
\r
716 if ((pAdapt->PTDeviceState > NdisDeviceStateD0)
\r
717 && (pAdapt->StandingBy == FALSE))
\r
719 pAdapt->QueuedRequest = TRUE;
\r
720 NdisReleaseSpinLock(&pAdapt->Lock);
\r
721 Status = NDIS_STATUS_PENDING;
\r
725 // This is in the process of powering down the system, always fail the request
\r
727 if (pAdapt->StandingBy == TRUE)
\r
729 NdisReleaseSpinLock(&pAdapt->Lock);
\r
730 Status = NDIS_STATUS_FAILURE;
\r
733 pAdapt->OutstandingRequests = TRUE;
\r
735 NdisReleaseSpinLock(&pAdapt->Lock);
\r
738 // default case, most requests will be passed to the miniport below
\r
740 NdisRequest(&Status,
\r
741 pAdapt->BindingHandle,
\r
745 if (Status != NDIS_STATUS_PENDING)
\r
747 PtRequestComplete(pAdapt, &pAdapt->Request, Status);
\r
748 Status = NDIS_STATUS_PENDING;
\r
759 MPQueryPNPCapabilities(
\r
760 IN OUT PADAPT pAdapt,
\r
761 OUT PNDIS_STATUS pStatus
\r
765 Routine Description:
\r
767 Postprocess a request for OID_PNP_CAPABILITIES that was forwarded
\r
768 down to the underlying miniport, and has been completed by it.
\r
772 pAdapt - Pointer to the adapter structure
\r
773 pStatus - Place to return final status
\r
782 PNDIS_PNP_CAPABILITIES pPNPCapabilities;
\r
783 PNDIS_PM_WAKE_UP_CAPABILITIES pPMstruct;
\r
785 if (pAdapt->Request.DATA.QUERY_INFORMATION.InformationBufferLength >= sizeof(NDIS_PNP_CAPABILITIES))
\r
787 pPNPCapabilities = (PNDIS_PNP_CAPABILITIES)(pAdapt->Request.DATA.QUERY_INFORMATION.InformationBuffer);
\r
790 // The following fields must be overwritten by an IM driver.
\r
792 pPMstruct= & pPNPCapabilities->WakeUpCapabilities;
\r
793 pPMstruct->MinMagicPacketWakeUp = NdisDeviceStateUnspecified;
\r
794 pPMstruct->MinPatternWakeUp = NdisDeviceStateUnspecified;
\r
795 pPMstruct->MinLinkChangeWakeUp = NdisDeviceStateUnspecified;
\r
796 *pAdapt->BytesReadOrWritten = sizeof(NDIS_PNP_CAPABILITIES);
\r
797 *pAdapt->BytesNeeded = 0;
\r
801 // Setting our internal flags
\r
802 // Default, device is ON
\r
804 pAdapt->MPDeviceState = NdisDeviceStateD0;
\r
805 pAdapt->PTDeviceState = NdisDeviceStateD0;
\r
807 *pStatus = NDIS_STATUS_SUCCESS;
\r
811 *pAdapt->BytesNeeded= sizeof(NDIS_PNP_CAPABILITIES);
\r
812 *pStatus = NDIS_STATUS_RESOURCES;
\r
819 IN NDIS_HANDLE MiniportAdapterContext,
\r
821 __in_bcount(InformationBufferLength) IN PVOID InformationBuffer,
\r
822 IN ULONG InformationBufferLength,
\r
823 OUT PULONG BytesRead,
\r
824 OUT PULONG BytesNeeded
\r
828 Routine Description:
\r
830 Miniport SetInfo handler.
\r
832 In the case of OID_PNP_SET_POWER, record the power state and return the OID.
\r
834 If the device is suspended, do not block the SET_POWER_OID
\r
835 as it is used to reactivate the Passthru miniport
\r
838 PM- If the MP is not ON (DeviceState > D0) return immediately (except for 'query power' and 'set power')
\r
839 If MP is ON, but the PT is not at D0, then queue the queue the request for later processing
\r
841 Requests to miniports are always serialized
\r
846 MiniportAdapterContext Pointer to the adapter structure
\r
847 Oid Oid for this query
\r
848 InformationBuffer Buffer for information
\r
849 InformationBufferLength Size of this buffer
\r
850 BytesRead Specifies how much info is read
\r
851 BytesNeeded In case the buffer is smaller than what we need, tell them how much is needed
\r
855 Return code from the NdisRequest below.
\r
859 PADAPT pAdapt = (PADAPT)MiniportAdapterContext;
\r
860 NDIS_STATUS Status;
\r
862 Status = NDIS_STATUS_FAILURE;
\r
867 // The Set Power should not be sent to the miniport below the Passthru, but is handled internally
\r
869 if (Oid == OID_PNP_SET_POWER)
\r
871 MPProcessSetPowerOid(&Status,
\r
873 InformationBuffer,
\r
874 InformationBufferLength,
\r
882 // If the miniport below is unbinding, fail the request
\r
884 NdisAcquireSpinLock(&pAdapt->Lock);
\r
885 if (pAdapt->UnbindingInProcess == TRUE)
\r
887 NdisReleaseSpinLock(&pAdapt->Lock);
\r
888 Status = NDIS_STATUS_FAILURE;
\r
891 NdisReleaseSpinLock(&pAdapt->Lock);
\r
893 // All other Set Information requests are failed, if the miniport is
\r
894 // not at D0 or is transitioning to a device state greater than D0.
\r
896 if (pAdapt->MPDeviceState > NdisDeviceStateD0)
\r
898 Status = NDIS_STATUS_FAILURE;
\r
902 // Set up the Request and return the result
\r
903 pAdapt->Request.RequestType = NdisRequestSetInformation;
\r
904 pAdapt->Request.DATA.SET_INFORMATION.Oid = Oid;
\r
905 pAdapt->Request.DATA.SET_INFORMATION.InformationBuffer = InformationBuffer;
\r
906 pAdapt->Request.DATA.SET_INFORMATION.InformationBufferLength = InformationBufferLength;
\r
907 pAdapt->BytesNeeded = BytesNeeded;
\r
908 pAdapt->BytesReadOrWritten = BytesRead;
\r
911 // If the miniport below is unbinding, fail the request
\r
913 NdisAcquireSpinLock(&pAdapt->Lock);
\r
914 if (pAdapt->UnbindingInProcess == TRUE)
\r
916 NdisReleaseSpinLock(&pAdapt->Lock);
\r
917 Status = NDIS_STATUS_FAILURE;
\r
922 // If the device below is at a low power state, we cannot send it the
\r
923 // request now, and must pend it.
\r
925 if ((pAdapt->PTDeviceState > NdisDeviceStateD0)
\r
926 && (pAdapt->StandingBy == FALSE))
\r
928 pAdapt->QueuedRequest = TRUE;
\r
929 NdisReleaseSpinLock(&pAdapt->Lock);
\r
930 Status = NDIS_STATUS_PENDING;
\r
934 // This is in the process of powering down the system, always fail the request
\r
936 if (pAdapt->StandingBy == TRUE)
\r
938 NdisReleaseSpinLock(&pAdapt->Lock);
\r
939 Status = NDIS_STATUS_FAILURE;
\r
942 pAdapt->OutstandingRequests = TRUE;
\r
944 NdisReleaseSpinLock(&pAdapt->Lock);
\r
946 // Forward the request to the device below.
\r
948 NdisRequest(&Status,
\r
949 pAdapt->BindingHandle,
\r
952 if (Status != NDIS_STATUS_PENDING)
\r
954 *BytesRead = pAdapt->Request.DATA.SET_INFORMATION.BytesRead;
\r
955 *BytesNeeded = pAdapt->Request.DATA.SET_INFORMATION.BytesNeeded;
\r
956 pAdapt->OutstandingRequests = FALSE;
\r
966 MPProcessSetPowerOid(
\r
967 IN OUT PNDIS_STATUS pNdisStatus,
\r
969 __in_bcount(InformationBufferLength) IN PVOID InformationBuffer,
\r
970 IN ULONG InformationBufferLength,
\r
971 OUT PULONG BytesRead,
\r
972 OUT PULONG BytesNeeded
\r
976 Routine Description:
\r
977 This routine does all the procssing for a request with a SetPower Oid
\r
978 The miniport shoud accept the Set Power and transition to the new state
\r
980 The Set Power should not be passed to the miniport below
\r
982 If the IM miniport is going into a low power state, then there is no guarantee if it will ever
\r
983 be asked go back to D0, before getting halted. No requests should be pended or queued.
\r
987 pNdisStatus - Status of the operation
\r
988 pAdapt - The Adapter structure
\r
989 InformationBuffer - The New DeviceState
\r
990 InformationBufferLength
\r
991 BytesRead - No of bytes read
\r
992 BytesNeeded - No of bytes needed
\r
996 Status - NDIS_STATUS_SUCCESS if all the wait events succeed.
\r
1002 NDIS_DEVICE_POWER_STATE NewDeviceState;
\r
1004 DBGPRINT(("==>MPProcessSetPowerOid: Adapt %p\n", pAdapt));
\r
1006 ASSERT (InformationBuffer != NULL);
\r
1008 *pNdisStatus = NDIS_STATUS_FAILURE;
\r
1013 // Check for invalid length
\r
1015 if (InformationBufferLength < sizeof(NDIS_DEVICE_POWER_STATE))
\r
1017 *pNdisStatus = NDIS_STATUS_INVALID_LENGTH;
\r
1021 NewDeviceState = (*(PNDIS_DEVICE_POWER_STATE)InformationBuffer);
\r
1024 // Check for invalid device state
\r
1026 if ((pAdapt->MPDeviceState > NdisDeviceStateD0) && (NewDeviceState != NdisDeviceStateD0))
\r
1029 // If the miniport is in a non-D0 state, the miniport can only receive a Set Power to D0
\r
1031 ASSERT (!(pAdapt->MPDeviceState > NdisDeviceStateD0) && (NewDeviceState != NdisDeviceStateD0));
\r
1033 *pNdisStatus = NDIS_STATUS_FAILURE;
\r
1038 // Is the miniport transitioning from an On (D0) state to an Low Power State (>D0)
\r
1039 // If so, then set the StandingBy Flag - (Block all incoming requests)
\r
1041 if (pAdapt->MPDeviceState == NdisDeviceStateD0 && NewDeviceState > NdisDeviceStateD0)
\r
1043 pAdapt->StandingBy = TRUE;
\r
1047 // If the miniport is transitioning from a low power state to ON (D0), then clear the StandingBy flag
\r
1048 // All incoming requests will be pended until the physical miniport turns ON.
\r
1050 if (pAdapt->MPDeviceState > NdisDeviceStateD0 && NewDeviceState == NdisDeviceStateD0)
\r
1052 pAdapt->StandingBy = FALSE;
\r
1056 // Now update the state in the pAdapt structure;
\r
1058 pAdapt->MPDeviceState = NewDeviceState;
\r
1060 *pNdisStatus = NDIS_STATUS_SUCCESS;
\r
1065 if (*pNdisStatus == NDIS_STATUS_SUCCESS)
\r
1068 // The miniport resume from low power state
\r
1070 if (pAdapt->StandingBy == FALSE)
\r
1073 // If we need to indicate the media connect state
\r
1075 if (pAdapt->LastIndicatedStatus != pAdapt->LatestUnIndicateStatus)
\r
1077 if (pAdapt->MiniportHandle != NULL)
\r
1079 NdisMIndicateStatus(pAdapt->MiniportHandle,
\r
1080 pAdapt->LatestUnIndicateStatus,
\r
1083 NdisMIndicateStatusComplete(pAdapt->MiniportHandle);
\r
1084 pAdapt->LastIndicatedStatus = pAdapt->LatestUnIndicateStatus;
\r
1091 // Initialize LatestUnIndicatedStatus
\r
1093 pAdapt->LatestUnIndicateStatus = pAdapt->LastIndicatedStatus;
\r
1095 *BytesRead = sizeof(NDIS_DEVICE_POWER_STATE);
\r
1101 *BytesNeeded = sizeof (NDIS_DEVICE_POWER_STATE);
\r
1104 DBGPRINT(("<==MPProcessSetPowerOid: Adapt %p\n", pAdapt));
\r
1110 IN NDIS_HANDLE MiniportAdapterContext,
\r
1111 IN PNDIS_PACKET Packet
\r
1115 Routine Description:
\r
1117 NDIS Miniport entry point called whenever protocols are done with
\r
1118 a packet that we had indicated up and they had queued up for returning
\r
1123 MiniportAdapterContext - pointer to ADAPT structure
\r
1124 Packet - packet being returned.
\r
1132 PADAPT pAdapt = (PADAPT)MiniportAdapterContext;
\r
1136 // Packet stacking: Check if this packet belongs to us.
\r
1138 if (NdisGetPoolFromPacket(Packet) != pAdapt->RecvPacketPoolHandle)
\r
1141 // We reused the original packet in a receive indication.
\r
1142 // Simply return it to the miniport below us.
\r
1144 NdisReturnPackets(&Packet, 1);
\r
1150 // This is a packet allocated from this IM's receive packet pool.
\r
1151 // Reclaim our packet, and return the original to the driver below.
\r
1154 PNDIS_PACKET MyPacket;
\r
1155 PRECV_RSVD RecvRsvd;
\r
1157 RecvRsvd = (PRECV_RSVD)(Packet->MiniportReserved);
\r
1158 MyPacket = RecvRsvd->OriginalPkt;
\r
1160 NdisFreePacket(Packet);
\r
1161 NdisReturnPackets(&MyPacket, 1);
\r
1168 OUT PNDIS_PACKET Packet,
\r
1169 OUT PUINT BytesTransferred,
\r
1170 IN NDIS_HANDLE MiniportAdapterContext,
\r
1171 IN NDIS_HANDLE MiniportReceiveContext,
\r
1172 IN UINT ByteOffset,
\r
1173 IN UINT BytesToTransfer
\r
1177 Routine Description:
\r
1179 Miniport's transfer data handler.
\r
1183 Packet Destination packet
\r
1184 BytesTransferred Place-holder for how much data was copied
\r
1185 MiniportAdapterContext Pointer to the adapter structure
\r
1186 MiniportReceiveContext Context
\r
1187 ByteOffset Offset into the packet for copying data
\r
1188 BytesToTransfer How much to copy.
\r
1192 Status of transfer
\r
1196 PADAPT pAdapt = (PADAPT)MiniportAdapterContext;
\r
1197 NDIS_STATUS Status;
\r
1200 // Return, if the device is OFF
\r
1203 if (IsIMDeviceStateOn(pAdapt) == FALSE)
\r
1205 return NDIS_STATUS_FAILURE;
\r
1208 NdisTransferData(&Status,
\r
1209 pAdapt->BindingHandle,
\r
1210 MiniportReceiveContext,
\r
1214 BytesTransferred);
\r
1221 IN NDIS_HANDLE MiniportAdapterContext
\r
1225 Routine Description:
\r
1227 Halt handler. All the hard-work for clean-up is done here.
\r
1231 MiniportAdapterContext Pointer to the Adapter
\r
1239 PADAPT pAdapt = (PADAPT)MiniportAdapterContext;
\r
1240 NDIS_STATUS Status;
\r
1243 DBGPRINT(("==>MiniportHalt: Adapt %p\n", pAdapt));
\r
1245 pAdapt->MiniportHandle = NULL;
\r
1246 pAdapt->MiniportIsHalted = TRUE;
\r
1249 // Remove this adapter from the global list
\r
1251 NdisAcquireSpinLock(&GlobalLock);
\r
1253 for (ppCursor = &pAdaptList; *ppCursor != NULL; ppCursor = &(*ppCursor)->Next)
\r
1255 if (*ppCursor == pAdapt)
\r
1257 *ppCursor = pAdapt->Next;
\r
1262 NdisReleaseSpinLock(&GlobalLock);
\r
1265 // Delete the ioctl interface that was created when the miniport
\r
1268 (VOID)PtDeregisterDevice();
\r
1271 // If we have a valid bind, close the miniport below the protocol
\r
1273 #pragma prefast(suppress: __WARNING_DEREF_NULL_PTR, "pAdapt cannot be NULL")
\r
1274 if (pAdapt->BindingHandle != NULL)
\r
1277 // Close the binding below. and wait for it to complete
\r
1279 NdisResetEvent(&pAdapt->Event);
\r
1281 NdisCloseAdapter(&Status, pAdapt->BindingHandle);
\r
1283 if (Status == NDIS_STATUS_PENDING)
\r
1285 NdisWaitEvent(&pAdapt->Event, 0);
\r
1286 Status = pAdapt->Status;
\r
1289 ASSERT (Status == NDIS_STATUS_SUCCESS);
\r
1291 pAdapt->BindingHandle = NULL;
\r
1293 PtDereferenceAdapt(pAdapt);
\r
1296 if (PtDereferenceAdapt(pAdapt))
\r
1302 DBGPRINT(("<== MiniportHalt: pAdapt %p\n", pAdapt));
\r
1306 #ifdef NDIS51_MINIPORT
\r
1309 MPCancelSendPackets(
\r
1310 IN NDIS_HANDLE MiniportAdapterContext,
\r
1315 Routine Description:
\r
1317 The miniport entry point to handle cancellation of all send packets
\r
1318 that match the given CancelId. If we have queued any packets that match
\r
1319 this, then we should dequeue them and call NdisMSendComplete for all
\r
1320 such packets, with a status of NDIS_STATUS_REQUEST_ABORTED.
\r
1322 We should also call NdisCancelSendPackets in turn, on each lower binding
\r
1323 that this adapter corresponds to. This is to let miniports below cancel
\r
1324 any matching packets.
\r
1328 MiniportAdapterContext - pointer to ADAPT structure
\r
1329 CancelId - ID of packets to be cancelled.
\r
1337 PADAPT pAdapt = (PADAPT)MiniportAdapterContext;
\r
1340 // If we queue packets on our adapter structure, this would be
\r
1341 // the place to acquire a spinlock to it, unlink any packets whose
\r
1342 // Id matches CancelId, release the spinlock and call NdisMSendComplete
\r
1343 // with NDIS_STATUS_REQUEST_ABORTED for all unlinked packets.
\r
1347 // Next, pass this down so that we let the miniport(s) below cancel
\r
1348 // any packets that they might have queued.
\r
1350 NdisCancelSendPackets(pAdapt->BindingHandle, CancelId);
\r
1357 IN NDIS_HANDLE MiniportAdapterContext,
\r
1358 IN NDIS_DEVICE_PNP_EVENT DevicePnPEvent,
\r
1359 IN PVOID InformationBuffer,
\r
1360 IN ULONG InformationBufferLength
\r
1364 Routine Description:
\r
1366 This handler is called to notify us of PnP events directed to
\r
1367 our miniport device object.
\r
1371 MiniportAdapterContext - pointer to ADAPT structure
\r
1372 DevicePnPEvent - the event
\r
1373 InformationBuffer - Points to additional event-specific information
\r
1374 InformationBufferLength - length of above
\r
1381 // TBD - add code/comments about processing this.
\r
1383 UNREFERENCED_PARAMETER(MiniportAdapterContext);
\r
1384 UNREFERENCED_PARAMETER(DevicePnPEvent);
\r
1385 UNREFERENCED_PARAMETER(InformationBuffer);
\r
1386 UNREFERENCED_PARAMETER(InformationBufferLength);
\r
1392 MPAdapterShutdown(
\r
1393 IN NDIS_HANDLE MiniportAdapterContext
\r
1397 Routine Description:
\r
1399 This handler is called to notify us of an impending system shutdown.
\r
1403 MiniportAdapterContext - pointer to ADAPT structure
\r
1410 UNREFERENCED_PARAMETER(MiniportAdapterContext);
\r
1419 MPFreeAllPacketPools(
\r
1424 Routine Description:
\r
1426 Free all packet pools on the specified adapter.
\r
1430 pAdapt - pointer to ADAPT structure
\r
1438 if (pAdapt->RecvPacketPoolHandle != NULL)
\r
1441 // Free the packet pool that is used to indicate receives
\r
1443 NdisFreePacketPool(pAdapt->RecvPacketPoolHandle);
\r
1445 pAdapt->RecvPacketPoolHandle = NULL;
\r
1448 if (pAdapt->SendPacketPoolHandle != NULL)
\r
1452 // Free the packet pool that is used to send packets below
\r
1455 NdisFreePacketPool(pAdapt->SendPacketPoolHandle);
\r
1457 pAdapt->SendPacketPoolHandle = NULL;
\r