#include "ndissys.h"
#include "efilter.h"
-#ifdef DBG
#include <buffer.h>
-#endif /* DBG */
-
-#undef NdisMSendComplete
-VOID
-EXPORT
-NdisMSendComplete(
- IN NDIS_HANDLE MiniportAdapterHandle,
- IN PNDIS_PACKET Packet,
- IN NDIS_STATUS Status);
-
-/* Root of the scm database */
-#define SERVICES_ROOT L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\"
/*
* Define to 1 to get a debugger breakpoint at the end of NdisInitializeWrapper
MiniDisplayPacket(
PNDIS_PACKET Packet)
{
-#ifdef DBG
+#if DBG
ULONG i, Length;
UCHAR Buffer[64];
if ((DebugTraceLevel & DEBUG_PACKET) > 0) {
PVOID LookaheadBuffer,
UINT LookaheadBufferSize)
{
-#ifdef DBG
+#if DBG
if ((DebugTraceLevel & DEBUG_PACKET) > 0) {
ULONG i, Length;
PUCHAR p;
#endif /* DBG */
}
+PNDIS_MINIPORT_WORK_ITEM
+MiniGetFirstWorkItem(
+ PLOGICAL_ADAPTER Adapter,
+ NDIS_WORK_ITEM_TYPE Type)
+{
+ PNDIS_MINIPORT_WORK_ITEM CurrentEntry = Adapter->WorkQueueHead;
+
+ while (CurrentEntry)
+ {
+ if (CurrentEntry->WorkItemType == Type)
+ return CurrentEntry;
+
+ CurrentEntry = (PNDIS_MINIPORT_WORK_ITEM)CurrentEntry->Link.Next;
+ }
+
+ return NULL;
+}
+
+BOOLEAN
+MiniIsBusy(
+ PLOGICAL_ADAPTER Adapter,
+ NDIS_WORK_ITEM_TYPE Type)
+{
+ BOOLEAN Busy = FALSE;
+ KIRQL OldIrql;
+
+ KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
+
+ if (Type == NdisWorkItemRequest &&
+ (Adapter->NdisMiniportBlock.PendingRequest || MiniGetFirstWorkItem(Adapter, NdisWorkItemRequest)))
+ {
+ Busy = TRUE;
+ }
+ else if (Type == NdisWorkItemSend &&
+ (Adapter->NdisMiniportBlock.FirstPendingPacket || MiniGetFirstWorkItem(Adapter, NdisWorkItemSend)))
+ {
+ Busy = TRUE;
+ }
+ else if (Type == NdisWorkItemResetRequested &&
+ (Adapter->NdisMiniportBlock.ResetStatus == NDIS_STATUS_PENDING || MiniGetFirstWorkItem(Adapter, NdisWorkItemResetRequested)))
+ {
+ Busy = TRUE;
+ }
+
+ KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+
+ return Busy;
+}
+
\f
VOID
MiniIndicateData(
if (CurrentEntry == &Adapter->ProtocolListHead)
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("WARNING: No upper protocol layer.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("WARNING: No upper protocol layer.\n"));
}
while (CurrentEntry != &Adapter->ProtocolListHead)
{
AdapterBinding = CONTAINING_RECORD(CurrentEntry, ADAPTER_BINDING, AdapterListEntry);
- if (AdapterBinding->ProtocolBinding->Chars.ReceivePacketHandler)
+ for (i = 0; i < NumberOfPackets; i++)
{
- for (i = 0; i < NumberOfPackets; i++)
- {
+ if (AdapterBinding->ProtocolBinding->Chars.ReceivePacketHandler &&
+ NDIS_GET_PACKET_STATUS(PacketArray[i]) != NDIS_STATUS_RESOURCES)
+ {
(*AdapterBinding->ProtocolBinding->Chars.ReceivePacketHandler)(
AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
PacketArray[i]);
+ }
+ else
+ {
+ UINT FirstBufferLength, TotalBufferLength, LookAheadSize, HeaderSize;
+ PNDIS_BUFFER NdisBuffer;
+ PVOID NdisBufferVA, LookAheadBuffer;
+ NDIS_STATUS NdisStatus;
+
+
+ NdisGetFirstBufferFromPacket(PacketArray[i],
+ &NdisBuffer,
+ &NdisBufferVA,
+ &FirstBufferLength,
+ &TotalBufferLength);
+
+ HeaderSize = NDIS_GET_PACKET_HEADER_SIZE(PacketArray[i]);
+
+ if (Adapter->NdisMiniportBlock.CurrentLookahead < (TotalBufferLength - HeaderSize))
+ {
+ LookAheadSize = Adapter->NdisMiniportBlock.CurrentLookahead;
+ }
+ else
+ {
+ LookAheadSize = TotalBufferLength - HeaderSize;
+ }
+
+
+ LookAheadBuffer = ExAllocatePool(NonPagedPool, LookAheadSize);
+ if (!LookAheadBuffer)
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("Failed to allocate lookahead buffer!\n"));
+ return;
+ }
+
+ CopyBufferChainToBuffer(LookAheadBuffer,
+ NdisBuffer,
+ HeaderSize,
+ LookAheadSize);
+
+ NdisStatus = (*AdapterBinding->ProtocolBinding->Chars.ReceiveHandler)(
+ AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
+ AdapterBinding->NdisOpenBlock.MacHandle,
+ NdisBufferVA,
+ HeaderSize,
+ LookAheadBuffer,
+ LookAheadSize,
+ TotalBufferLength - HeaderSize);
+
+ NDIS_SET_PACKET_STATUS(PacketArray[i], NdisStatus);
+
+ ExFreePool(LookAheadBuffer);
}
}
PADAPTER_BINDING AdapterBinding;
KIRQL OldIrql;
+ if (AddressingReset)
+ MiniDoAddressingReset(Adapter);
+
NdisMIndicateStatus(Adapter, NDIS_STATUS_RESET_END, NULL, 0);
+ NdisMIndicateStatusComplete(Adapter);
KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
+ if (Adapter->NdisMiniportBlock.ResetStatus != NDIS_STATUS_PENDING)
+ {
+ KeBugCheckEx(BUGCODE_ID_DRIVER,
+ (ULONG_PTR)MiniportAdapterHandle,
+ (ULONG_PTR)Status,
+ (ULONG_PTR)AddressingReset,
+ 0);
+ }
+
+ Adapter->NdisMiniportBlock.ResetStatus = Status;
+
CurrentEntry = Adapter->ProtocolListHead.Flink;
while (CurrentEntry != &Adapter->ProtocolListHead)
CurrentEntry = CurrentEntry->Flink;
}
- Adapter->MiniportBusy = FALSE;
-
KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
}
-
-\f
VOID NTAPI
MiniRequestComplete(
- IN PNDIS_HANDLE MiniportAdapterHandle,
- IN PNDIS_REQUEST Request,
+ IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_STATUS Status)
{
PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)MiniportAdapterHandle;
- PNDIS_REQUEST_MAC_BLOCK MacBlock = (PNDIS_REQUEST_MAC_BLOCK)Request->MacReserved;
+ PNDIS_REQUEST Request;
+ PNDIS_REQUEST_MAC_BLOCK MacBlock;
KIRQL OldIrql;
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+
+ KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+ Request = Adapter->NdisMiniportBlock.PendingRequest;
+ KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+
+ MacBlock = (PNDIS_REQUEST_MAC_BLOCK)Request->MacReserved;
+
if( MacBlock->Binding->RequestCompleteHandler ) {
(*MacBlock->Binding->RequestCompleteHandler)(
MacBlock->Binding->ProtocolBindingContext,
Request,
Status);
}
+
KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
- Adapter->MiniportBusy = FALSE;
+ Adapter->NdisMiniportBlock.PendingRequest = NULL;
KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+
KeLowerIrql(OldIrql);
}
PLOGICAL_ADAPTER Adapter = MiniportAdapterHandle;
PADAPTER_BINDING AdapterBinding;
KIRQL OldIrql;
+ PSCATTER_GATHER_LIST SGList;
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
- AdapterBinding = (PADAPTER_BINDING)Packet->Reserved[0];
+ AdapterBinding = (PADAPTER_BINDING)Packet->Reserved[1];
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+
+ if (Adapter->NdisMiniportBlock.ScatterGatherListSize != 0)
+ {
+ NDIS_DbgPrint(MAX_TRACE, ("Freeing Scatter/Gather list\n"));
+
+ SGList = NDIS_PER_PACKET_INFO_FROM_PACKET(Packet,
+ ScatterGatherListPacketInfo);
+
+ Adapter->NdisMiniportBlock.SystemAdapterObject->
+ DmaOperations->PutScatterGatherList(
+ Adapter->NdisMiniportBlock.SystemAdapterObject,
+ SGList,
+ TRUE);
+
+ NDIS_PER_PACKET_INFO_FROM_PACKET(Packet,
+ ScatterGatherListPacketInfo) = NULL;
+ }
+
(*AdapterBinding->ProtocolBinding->Chars.SendCompleteHandler)(
AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
Packet,
Status);
- KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
- Adapter->MiniportBusy = FALSE;
- KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+
KeLowerIrql(OldIrql);
}
IN NDIS_STATUS Status,
IN UINT BytesTransferred)
{
- PLOGICAL_ADAPTER Adapter = MiniportAdapterHandle;
PADAPTER_BINDING AdapterBinding;
KIRQL OldIrql;
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
- AdapterBinding = (PADAPTER_BINDING)Packet->Reserved[0];
+ AdapterBinding = (PADAPTER_BINDING)Packet->Reserved[1];
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
- (*AdapterBinding->ProtocolBinding->Chars.SendCompleteHandler)(
+ (*AdapterBinding->ProtocolBinding->Chars.TransferDataCompleteHandler)(
AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
Packet,
- Status);
- KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
- Adapter->MiniportBusy = FALSE;
- KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+ Status,
+ BytesTransferred);
KeLowerIrql(OldIrql);
}
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
-#ifdef DBG
+#if DBG
if(!Adapter)
{
- NDIS_DbgPrint(MID_TRACE, ("Adapter object was null\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Adapter object was null\n"));
return FALSE;
}
if(!Packet)
{
- NDIS_DbgPrint(MID_TRACE, ("Packet was null\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Packet was null\n"));
return FALSE;
}
#endif
if (!NdisBuffer)
{
- NDIS_DbgPrint(MID_TRACE, ("Packet contains no buffers.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Packet contains no buffers.\n"));
return FALSE;
}
if (BufferLength < Length)
{
- NDIS_DbgPrint(MID_TRACE, ("Buffer is too small.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Buffer is too small.\n"));
return FALSE;
}
if(IsListEmpty(&AdapterListHead))
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("No registered miniports for protocol to bind to\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("No registered miniports for protocol to bind to\n"));
return NULL;
}
}
else
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Leaving (adapter not found).\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Leaving (adapter not found for %wZ).\n", AdapterName));
}
return Adapter;
}
-\f
+NDIS_STATUS
+MiniSetInformation(
+ PLOGICAL_ADAPTER Adapter,
+ NDIS_OID Oid,
+ ULONG Size,
+ PVOID Buffer,
+ PULONG BytesRead)
+{
+ NDIS_STATUS NdisStatus;
+ PNDIS_REQUEST NdisRequest;
+
+ NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
+
+ NdisRequest = ExAllocatePool(NonPagedPool, sizeof(NDIS_REQUEST));
+ if (!NdisRequest) {
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
+ return NDIS_STATUS_RESOURCES;
+ }
+
+ RtlZeroMemory(NdisRequest, sizeof(NDIS_REQUEST));
+
+ NdisRequest->RequestType = NdisRequestSetInformation;
+ NdisRequest->DATA.SET_INFORMATION.Oid = Oid;
+ NdisRequest->DATA.SET_INFORMATION.InformationBuffer = Buffer;
+ NdisRequest->DATA.SET_INFORMATION.InformationBufferLength = Size;
+
+ NdisStatus = MiniDoRequest(Adapter, NdisRequest);
+
+ /* FIXME: Wait in pending case! */
+
+ ASSERT(NdisStatus != NDIS_STATUS_PENDING);
+
+ *BytesRead = NdisRequest->DATA.SET_INFORMATION.BytesRead;
+
+ ExFreePool(NdisRequest);
+
+ return NdisStatus;
+}
+
NDIS_STATUS
MiniQueryInformation(
PLOGICAL_ADAPTER Adapter,
* Size = Size of the passed buffer
* Buffer = Buffer for the output
* BytesWritten = Address of buffer to place number of bytes written
- * NOTES:
- * If the specified buffer is too small, a new buffer is allocated,
- * and the query is attempted again
* RETURNS:
* Status of operation
- * TODO:
- * Is there any way to use the buffer provided by the protocol?
*/
{
NDIS_STATUS NdisStatus;
- ULONG BytesNeeded;
- KIRQL OldIrql;
+ PNDIS_REQUEST NdisRequest;
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
- /* call the miniport's queryinfo handler */
- KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
- NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.QueryInformationHandler)(
- Adapter->NdisMiniportBlock.MiniportAdapterContext,
- Oid,
- Buffer,
- Size,
- BytesWritten,
- &BytesNeeded);
- KeLowerIrql(OldIrql);
+ NdisRequest = ExAllocatePool(NonPagedPool, sizeof(NDIS_REQUEST));
+ if (!NdisRequest) {
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
+ return NDIS_STATUS_RESOURCES;
+ }
+
+ RtlZeroMemory(NdisRequest, sizeof(NDIS_REQUEST));
+
+ NdisRequest->RequestType = NdisRequestQueryInformation;
+ NdisRequest->DATA.QUERY_INFORMATION.Oid = Oid;
+ NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer = Buffer;
+ NdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength = Size;
+
+ NdisStatus = MiniDoRequest(Adapter, NdisRequest);
/* FIXME: Wait in pending case! */
+ ASSERT(NdisStatus != NDIS_STATUS_PENDING);
+
+ *BytesWritten = NdisRequest->DATA.QUERY_INFORMATION.BytesWritten;
+
+ ExFreePool(NdisRequest);
+
return NdisStatus;
}
return Ret;
}
+VOID
+MiniDoAddressingReset(PLOGICAL_ADAPTER Adapter)
+{
+ ULONG BytesRead;
+
+ MiniSetInformation(Adapter,
+ OID_GEN_CURRENT_LOOKAHEAD,
+ sizeof(ULONG),
+ &Adapter->NdisMiniportBlock.CurrentLookahead,
+ &BytesRead);
+
+ /* FIXME: Set more stuff */
+}
+
NDIS_STATUS
MiniReset(
- PLOGICAL_ADAPTER Adapter,
- PBOOLEAN AddressingReset)
+ PLOGICAL_ADAPTER Adapter)
/*
* FUNCTION: Resets the miniport
* ARGUMENTS:
* Adapter = Pointer to the logical adapter object
- * AddressingReset = Set to TRUE if we need to call MiniportSetInformation later
* RETURNS:
* Status of the operation
*/
{
NDIS_STATUS Status;
KIRQL OldIrql;
+ BOOLEAN AddressingReset = TRUE;
- if (Adapter->MiniportBusy) {
- KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
- MiniQueueWorkItem(Adapter, NdisWorkItemResetRequested, NULL);
- KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+ if (MiniIsBusy(Adapter, NdisWorkItemResetRequested)) {
+ MiniQueueWorkItem(Adapter, NdisWorkItemResetRequested, NULL, FALSE);
return NDIS_STATUS_PENDING;
}
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
Status = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.ResetHandler)(
Adapter->NdisMiniportBlock.MiniportAdapterContext,
- AddressingReset);
+ &AddressingReset);
+
+ KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+ Adapter->NdisMiniportBlock.ResetStatus = Status;
+ KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+
KeLowerIrql(OldIrql);
if (Status != NDIS_STATUS_PENDING) {
+ if (AddressingReset)
+ MiniDoAddressingReset(Adapter);
+
NdisMIndicateStatus(Adapter, NDIS_STATUS_RESET_END, NULL, 0);
NdisMIndicateStatusComplete(Adapter);
- } else {
- KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
- Adapter->MiniportBusy = TRUE;
- KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
}
return Status;
}
-VOID STDCALL
+VOID NTAPI
MiniportHangDpc(
PKDPC Dpc,
PVOID DeferredContext,
PVOID SystemArgument2)
{
PLOGICAL_ADAPTER Adapter = DeferredContext;
- BOOLEAN AddressingReset = FALSE;
-
if (MiniCheckForHang(Adapter)) {
NDIS_DbgPrint(MIN_TRACE, ("Miniport detected adapter hang\n"));
- MiniReset(Adapter, &AddressingReset);
+ MiniReset(Adapter);
}
-
- /* FIXME: We should call MiniportSetInformation if AddressingReset is TRUE */
}
\f
-NDIS_STATUS
+VOID
FASTCALL
MiniQueueWorkItem(
PLOGICAL_ADAPTER Adapter,
NDIS_WORK_ITEM_TYPE WorkItemType,
- PVOID WorkItemContext)
+ PVOID WorkItemContext,
+ BOOLEAN Top)
/*
* FUNCTION: Queues a work item for execution at a later time
* ARGUMENTS:
* Adapter = Pointer to the logical adapter object to queue work item on
* WorkItemType = Type of work item to queue
* WorkItemContext = Pointer to context information for work item
- * NOTES:
- * Adapter lock must be held when called
* RETURNS:
* Status of operation
*/
{
PNDIS_MINIPORT_WORK_ITEM MiniportWorkItem;
- PNDIS_WORK_ITEM NdisWorkItem;
- PWORK_QUEUE_ITEM WorkQueueItem;
+ PIO_WORKITEM IoWorkItem;
+ KIRQL OldIrql;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
ASSERT(Adapter);
- ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
-
- MiniportWorkItem = ExAllocatePool(NonPagedPool, sizeof(NDIS_MINIPORT_WORK_ITEM));
- if (!MiniportWorkItem)
- {
- NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
- return NDIS_STATUS_RESOURCES;
- }
-
- NdisWorkItem = ExAllocatePool(NonPagedPool, sizeof(NDIS_WORK_ITEM));
- if (!NdisWorkItem)
- {
- ExFreePool(MiniportWorkItem);
- return NDIS_STATUS_RESOURCES;
- }
- MiniportWorkItem->WorkItemType = WorkItemType;
- MiniportWorkItem->WorkItemContext = WorkItemContext;
-
- /* safe due to adapter lock held */
- MiniportWorkItem->Link.Next = NULL;
- if (!Adapter->WorkQueueHead)
+ KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
+ if (Top)
{
- Adapter->WorkQueueHead = MiniportWorkItem;
- Adapter->WorkQueueTail = MiniportWorkItem;
+ if (WorkItemType == NdisWorkItemSend)
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("Requeuing failed packet (%x).\n", WorkItemContext));
+ Adapter->NdisMiniportBlock.FirstPendingPacket = WorkItemContext;
+ }
+ else
+ {
+ //This should never happen
+ ASSERT(FALSE);
+ }
}
else
{
- Adapter->WorkQueueTail->Link.Next = (PSINGLE_LIST_ENTRY)MiniportWorkItem;
- Adapter->WorkQueueTail = MiniportWorkItem;
- }
-
- WorkQueueItem = (PWORK_QUEUE_ITEM)NdisWorkItem->WrapperReserved;
+ MiniportWorkItem = ExAllocatePool(NonPagedPool, sizeof(NDIS_MINIPORT_WORK_ITEM));
+ if (!MiniportWorkItem)
+ {
+ KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
+ return;
+ }
- NdisWorkItem->Context = Adapter;
+ MiniportWorkItem->WorkItemType = WorkItemType;
+ MiniportWorkItem->WorkItemContext = WorkItemContext;
- ExInitializeWorkItem(WorkQueueItem, MiniportWorker, NdisWorkItem);
+ /* safe due to adapter lock held */
+ MiniportWorkItem->Link.Next = NULL;
+ if (!Adapter->WorkQueueHead)
+ {
+ Adapter->WorkQueueHead = MiniportWorkItem;
+ Adapter->WorkQueueTail = MiniportWorkItem;
+ }
+ else
+ {
+ Adapter->WorkQueueTail->Link.Next = (PSINGLE_LIST_ENTRY)MiniportWorkItem;
+ Adapter->WorkQueueTail = MiniportWorkItem;
+ }
+ }
- ExQueueWorkItem(WorkQueueItem, CriticalWorkQueue);
+ IoWorkItem = IoAllocateWorkItem(Adapter->NdisMiniportBlock.DeviceObject);
+ if (IoWorkItem)
+ IoQueueWorkItem(IoWorkItem, MiniportWorker, DelayedWorkQueue, IoWorkItem);
- return NDIS_STATUS_SUCCESS;
+ KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
}
\f
*/
{
PNDIS_MINIPORT_WORK_ITEM MiniportWorkItem;
- PNDIS_WORK_ITEM NdisWorkItem;
- PWORK_QUEUE_ITEM WorkQueueItem;
-
+ PNDIS_PACKET Packet;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- if (Adapter->MiniportBusy) {
- NDIS_DbgPrint(MID_TRACE, ("Waiting for miniport to become free.\n"));
- NdisWorkItem = ExAllocatePool(NonPagedPool, sizeof(NDIS_WORK_ITEM));
- if (!NdisWorkItem) return NDIS_STATUS_RESOURCES;
- WorkQueueItem = (PWORK_QUEUE_ITEM)NdisWorkItem->WrapperReserved;
- NdisWorkItem->Context = Adapter;
- ExInitializeWorkItem(WorkQueueItem, MiniportWorker, NdisWorkItem);
- ExQueueWorkItem(WorkQueueItem, CriticalWorkQueue);
- return NDIS_STATUS_FAILURE;
- }
-
MiniportWorkItem = Adapter->WorkQueueHead;
- if (MiniportWorkItem)
+ if ((Packet = Adapter->NdisMiniportBlock.FirstPendingPacket))
+ {
+ Adapter->NdisMiniportBlock.FirstPendingPacket = NULL;
+
+ *WorkItemType = NdisWorkItemSend;
+ *WorkItemContext = Packet;
+
+ return NDIS_STATUS_SUCCESS;
+ }
+ else if (MiniportWorkItem)
{
/* safe due to adapter lock held */
Adapter->WorkQueueHead = (PNDIS_MINIPORT_WORK_ITEM)MiniportWorkItem->Link.Next;
ExFreePool(MiniportWorkItem);
- Adapter->MiniportBusy = TRUE;
-
return NDIS_STATUS_SUCCESS;
}
+ else
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("No work item to dequeue\n"));
- return NDIS_STATUS_FAILURE;
+ return NDIS_STATUS_FAILURE;
+ }
}
\f
KIRQL OldIrql;
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
- Adapter->NdisMiniportBlock.MediaRequest = NdisRequest;
-
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
- switch (NdisRequest->RequestType)
+
+ KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+ Adapter->NdisMiniportBlock.PendingRequest = NdisRequest;
+ KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+
+ if (!Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.CoRequestHandler)
{
- case NdisRequestQueryInformation:
- Status = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.QueryInformationHandler)(
- Adapter->NdisMiniportBlock.MiniportAdapterContext,
- NdisRequest->DATA.QUERY_INFORMATION.Oid,
- NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer,
- NdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength,
- (PULONG)&NdisRequest->DATA.QUERY_INFORMATION.BytesWritten,
- (PULONG)&NdisRequest->DATA.QUERY_INFORMATION.BytesNeeded);
- break;
+ switch (NdisRequest->RequestType)
+ {
+ case NdisRequestQueryInformation:
+ Status = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.QueryInformationHandler)(
+ Adapter->NdisMiniportBlock.MiniportAdapterContext,
+ NdisRequest->DATA.QUERY_INFORMATION.Oid,
+ NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer,
+ NdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength,
+ (PULONG)&NdisRequest->DATA.QUERY_INFORMATION.BytesWritten,
+ (PULONG)&NdisRequest->DATA.QUERY_INFORMATION.BytesNeeded);
+ break;
- case NdisRequestSetInformation:
- Status = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SetInformationHandler)(
- Adapter->NdisMiniportBlock.MiniportAdapterContext,
- NdisRequest->DATA.SET_INFORMATION.Oid,
- NdisRequest->DATA.SET_INFORMATION.InformationBuffer,
- NdisRequest->DATA.SET_INFORMATION.InformationBufferLength,
- (PULONG)&NdisRequest->DATA.SET_INFORMATION.BytesRead,
- (PULONG)&NdisRequest->DATA.SET_INFORMATION.BytesNeeded);
- break;
+ case NdisRequestSetInformation:
+ Status = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SetInformationHandler)(
+ Adapter->NdisMiniportBlock.MiniportAdapterContext,
+ NdisRequest->DATA.SET_INFORMATION.Oid,
+ NdisRequest->DATA.SET_INFORMATION.InformationBuffer,
+ NdisRequest->DATA.SET_INFORMATION.InformationBufferLength,
+ (PULONG)&NdisRequest->DATA.SET_INFORMATION.BytesRead,
+ (PULONG)&NdisRequest->DATA.SET_INFORMATION.BytesNeeded);
+ break;
- default:
- Status = NDIS_STATUS_FAILURE;
+ default:
+ NDIS_DbgPrint(MIN_TRACE, ("Bad request type\n"));
+ Status = NDIS_STATUS_FAILURE;
+ }
+ }
+ else
+ {
+ Status = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.CoRequestHandler)(
+ Adapter->NdisMiniportBlock.MiniportAdapterContext,
+ NULL, /* FIXME */
+ NdisRequest);
}
- if (Status == NDIS_STATUS_PENDING) {
+ if (Status != NDIS_STATUS_PENDING) {
KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
- Adapter->MiniportBusy = TRUE;
+ Adapter->NdisMiniportBlock.PendingRequest = NULL;
KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
}
}
\f
+/*
+ * @implemented
+ */
+#undef NdisMSetInformationComplete
+VOID
+EXPORT
+NdisMSetInformationComplete(
+ IN NDIS_HANDLE MiniportAdapterHandle,
+ IN NDIS_STATUS Status)
+{
+ PLOGICAL_ADAPTER Adapter =
+ (PLOGICAL_ADAPTER)MiniportAdapterHandle;
+ KIRQL OldIrql;
+ ASSERT(Adapter);
+ KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+ if (Adapter->NdisMiniportBlock.SetCompleteHandler)
+ (Adapter->NdisMiniportBlock.SetCompleteHandler)(MiniportAdapterHandle, Status);
+ KeLowerIrql(OldIrql);
+}
+
+\f
/*
* @implemented
*/
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
if( Adapter->NdisMiniportBlock.QueryCompleteHandler )
(Adapter->NdisMiniportBlock.QueryCompleteHandler)(MiniportAdapterHandle, Status);
- KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
- Adapter->MiniportBusy = FALSE;
- KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
KeLowerIrql(OldIrql);
}
-VOID NTAPI MiniportWorker(IN PVOID WorkItem)
+VOID
+NTAPI
+MiniportWorker(IN PDEVICE_OBJECT DeviceObject, IN PVOID Context)
{
- PNDIS_WORK_ITEM NdisWorkItem = WorkItem;
- PLOGICAL_ADAPTER Adapter = GET_LOGICAL_ADAPTER(NdisWorkItem->Context);
+ PLOGICAL_ADAPTER Adapter = DeviceObject->DeviceExtension;
KIRQL OldIrql, RaiseOldIrql;
NDIS_STATUS NdisStatus;
PVOID WorkItemContext;
NDIS_WORK_ITEM_TYPE WorkItemType;
BOOLEAN AddressingReset;
+ IoFreeWorkItem((PIO_WORKITEM)Context);
+
KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
NdisStatus =
/*
* called by ProSend when protocols want to send packets to the miniport
*/
-#ifdef DBG
- MiniDisplayPacket((PNDIS_PACKET)WorkItemContext);
-#endif
+
if(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)
{
if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's SendPackets handler\n"));
(*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
Adapter->NdisMiniportBlock.MiniportAdapterContext, (PPNDIS_PACKET)&WorkItemContext, 1);
- NdisStatus = NDIS_GET_PACKET_STATUS((PNDIS_PACKET)WorkItemContext);
+ NdisStatus = NDIS_STATUS_PENDING;
}
else
{
NdisStatus = NDIS_GET_PACKET_STATUS((PNDIS_PACKET)WorkItemContext);
if( NdisStatus == NDIS_STATUS_RESOURCES ) {
- KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
- MiniQueueWorkItem(Adapter, WorkItemType, WorkItemContext);
- KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+ MiniQueueWorkItem(Adapter, WorkItemType, WorkItemContext, TRUE);
break;
}
}
{
NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's Send handler\n"));
NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
- Adapter->NdisMiniportBlock.MiniportAdapterContext, (PNDIS_PACKET)WorkItemContext, 0);
+ Adapter->NdisMiniportBlock.MiniportAdapterContext, (PNDIS_PACKET)WorkItemContext,
+ ((PNDIS_PACKET)WorkItemContext)->Private.Flags);
NDIS_DbgPrint(MAX_TRACE, ("back from miniport's send handler\n"));
}
else
KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's Send handler\n"));
NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
- Adapter->NdisMiniportBlock.MiniportAdapterContext, (PNDIS_PACKET)WorkItemContext, 0);
+ Adapter->NdisMiniportBlock.MiniportAdapterContext, (PNDIS_PACKET)WorkItemContext,
+ ((PNDIS_PACKET)WorkItemContext)->Private.Flags);
NDIS_DbgPrint(MAX_TRACE, ("back from miniport's send handler\n"));
KeLowerIrql(RaiseOldIrql);
if( NdisStatus == NDIS_STATUS_RESOURCES ) {
- KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
- MiniQueueWorkItem(Adapter, WorkItemType, WorkItemContext);
- KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+ MiniQueueWorkItem(Adapter, WorkItemType, WorkItemContext, TRUE);
break;
}
}
}
if( NdisStatus != NDIS_STATUS_PENDING ) {
- NdisMSendComplete
+ MiniSendComplete
( Adapter, (PNDIS_PACKET)WorkItemContext, NdisStatus );
}
break;
NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.ResetHandler)(
Adapter->NdisMiniportBlock.MiniportAdapterContext,
&AddressingReset);
- KeLowerIrql(OldIrql);
- if (NdisStatus == NDIS_STATUS_PENDING)
- break;
+ KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+ Adapter->NdisMiniportBlock.ResetStatus = NdisStatus;
+ KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+
+ KeLowerIrql(OldIrql);
- MiniResetComplete(Adapter, NdisStatus, AddressingReset);
+ if (NdisStatus != NDIS_STATUS_PENDING)
+ MiniResetComplete(Adapter, NdisStatus, AddressingReset);
break;
case NdisWorkItemResetInProgress:
{
case NdisRequestQueryInformation:
NdisMQueryInformationComplete((NDIS_HANDLE)Adapter, NdisStatus);
- MiniRequestComplete( (NDIS_HANDLE)Adapter, (PNDIS_REQUEST)WorkItemContext, NdisStatus );
break;
case NdisRequestSetInformation:
NdisMSetInformationComplete((NDIS_HANDLE)Adapter, NdisStatus);
- MiniRequestComplete( (NDIS_HANDLE)Adapter, (PNDIS_REQUEST)WorkItemContext, NdisStatus );
break;
default:
break;
}
}
-
- if( NdisStatus != NDIS_STATUS_PENDING ) {
- KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
- Adapter->MiniportBusy = FALSE;
- KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
- }
-
- ExFreePool(WorkItem);
}
\f
/*
- * @unimplemented
+ * @implemented
*/
VOID
EXPORT
NdisMCloseLog(
IN NDIS_HANDLE LogHandle)
{
- UNIMPLEMENTED
+ PNDIS_LOG Log = (PNDIS_LOG)LogHandle;
+ PNDIS_MINIPORT_BLOCK Miniport = Log->Miniport;
+ KIRQL OldIrql;
+
+ NDIS_DbgPrint(MAX_TRACE, ("called: LogHandle 0x%x\n", LogHandle));
+
+ KeAcquireSpinLock(&(Miniport)->Lock, &OldIrql);
+ Miniport->Log = NULL;
+ KeReleaseSpinLock(&(Miniport)->Lock, OldIrql);
+
+ ExFreePool(Log);
}
-\f
/*
- * @unimplemented
+ * @implemented
*/
NDIS_STATUS
EXPORT
IN UINT Size,
OUT PNDIS_HANDLE LogHandle)
{
- UNIMPLEMENTED
+ PLOGICAL_ADAPTER Adapter = MiniportAdapterHandle;
+ PNDIS_LOG Log;
+ KIRQL OldIrql;
- return NDIS_STATUS_FAILURE;
-}
+ NDIS_DbgPrint(MAX_TRACE, ("called: MiniportAdapterHandle 0x%x, Size %ld\n", MiniportAdapterHandle, Size));
-\f
-/*
- * @implemented
- */
-VOID
-EXPORT
-NdisMDeregisterAdapterShutdownHandler(
+ KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
+
+ if (Adapter->NdisMiniportBlock.Log)
+ {
+ *LogHandle = NULL;
+ return NDIS_STATUS_FAILURE;
+ }
+
+ Log = ExAllocatePool(NonPagedPool, Size + sizeof(NDIS_LOG));
+ if (!Log)
+ {
+ *LogHandle = NULL;
+ return NDIS_STATUS_RESOURCES;
+ }
+
+ Adapter->NdisMiniportBlock.Log = Log;
+
+ KeInitializeSpinLock(&Log->LogLock);
+
+ Log->Miniport = &Adapter->NdisMiniportBlock;
+ Log->TotalSize = Size;
+ Log->CurrentSize = 0;
+ Log->OutPtr = 0;
+ Log->InPtr = 0;
+ Log->Irp = NULL;
+
+ *LogHandle = Log;
+
+ KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+/*
+ * @implemented
+ */
+VOID
+EXPORT
+NdisMDeregisterAdapterShutdownHandler(
IN NDIS_HANDLE MiniportHandle)
/*
* FUNCTION: de-registers a shutdown handler
}
}
-\f
/*
- * @unimplemented
+ * @implemented
*/
VOID
EXPORT
NdisMFlushLog(
IN NDIS_HANDLE LogHandle)
{
- UNIMPLEMENTED
+ PNDIS_LOG Log = (PNDIS_LOG) LogHandle;
+ KIRQL OldIrql;
+
+ NDIS_DbgPrint(MAX_TRACE, ("called: LogHandle 0x%x\n", LogHandle));
+
+ /* Lock object */
+ KeAcquireSpinLock(&Log->LogLock, &OldIrql);
+
+ /* Set buffers size */
+ Log->CurrentSize = 0;
+ Log->OutPtr = 0;
+ Log->InPtr = 0;
+
+ /* Unlock object */
+ KeReleaseSpinLock(&Log->LogLock, OldIrql);
}
/*
*NdisWrapperHandle = NULL;
#if BREAK_ON_MINIPORT_INIT
- __asm__ ("int $3\n");
+ DbgBreakPoint();
#endif
Miniport = ExAllocatePool(NonPagedPool, sizeof(NDIS_M_DRIVER_BLOCK));
return NdisStatus;
}
-#ifdef DBG
+#if DBG
{
/* 802.3 only */
NDIS_DbgPrint(DEBUG_MINIPORT, ("CurLookaheadLength (0x%X).\n", Adapter->NdisMiniportBlock.CurrentLookahead));
- if (Adapter->NdisMiniportBlock.MaximumLookahead != 0)
- {
- Adapter->LookaheadLength = Adapter->NdisMiniportBlock.MaximumLookahead + Adapter->MediumHeaderSize;
- Adapter->LookaheadBuffer = ExAllocatePool(NonPagedPool, Adapter->LookaheadLength);
-
- if (!Adapter->LookaheadBuffer)
- return NDIS_STATUS_RESOURCES;
- }
-
return STATUS_SUCCESS;
}
return Status;
}
+NTSTATUS
+NTAPI
+NdisICreateClose(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+ Irp->IoStatus.Information = 0;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
+ return STATUS_SUCCESS;
+}
+
\f
NTSTATUS
NTAPI
NDIS_HANDLE ConfigHandle;
ULONG Size;
LARGE_INTEGER Timeout;
- /* FIXME - KIRQL OldIrql; */
+ UINT MaxMulticastAddresses;
+ ULONG BytesWritten;
+ PLIST_ENTRY CurrentEntry;
+ PPROTOCOL_BINDING ProtocolBinding;
/*
* Prepare wrapper context used by HW and configuration routines.
ExAllocatePool(PagedPool, ResourceListSize);
if (Adapter->NdisMiniportBlock.AllocatedResources == NULL)
{
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
ExInterlockedRemoveEntryList( &Adapter->ListEntry, &AdapterListLock );
return STATUS_INSUFFICIENT_RESOURCES;
}
+ Adapter->NdisMiniportBlock.Resources =
+ ExAllocatePool(PagedPool, ResourceListSize);
+ if (!Adapter->NdisMiniportBlock.Resources)
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
+ ExFreePool(Adapter->NdisMiniportBlock.AllocatedResources);
+ ExInterlockedRemoveEntryList(&Adapter->ListEntry, &AdapterListLock);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ RtlCopyMemory(Adapter->NdisMiniportBlock.Resources,
+ Stack->Parameters.StartDevice.AllocatedResources,
+ ResourceListSize);
+
RtlCopyMemory(Adapter->NdisMiniportBlock.AllocatedResources,
Stack->Parameters.StartDevice.AllocatedResources,
ResourceListSize);
ExAllocatePool(PagedPool, ResourceListSize);
if (Adapter->NdisMiniportBlock.AllocatedResourcesTranslated == NULL)
{
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
ExInterlockedRemoveEntryList( &Adapter->ListEntry, &AdapterListLock );
return STATUS_INSUFFICIENT_RESOURCES;
}
*/
NdisOpenConfiguration(&NdisStatus, &ConfigHandle, (NDIS_HANDLE)&WrapperContext);
+ if (NdisStatus != NDIS_STATUS_SUCCESS)
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("Failed to open configuration key\n"));
+ ExInterlockedRemoveEntryList( &Adapter->ListEntry, &AdapterListLock );
+ return NdisStatus;
+ }
Size = sizeof(ULONG);
Status = IoGetDeviceProperty(Adapter->NdisMiniportBlock.PhysicalDeviceObject,
Adapter->NdisMiniportBlock.SlotNumber = SlotNumber.u.AsULONG;
}
+ WrapperContext.SlotNumber = Adapter->NdisMiniportBlock.SlotNumber;
+
NdisCloseConfiguration(ConfigHandle);
/* Set handlers (some NDIS macros require these) */
Adapter->NdisMiniportBlock.PacketIndicateHandler= MiniIndicateReceivePacket;
Adapter->NdisMiniportBlock.StatusHandler = MiniStatus;
Adapter->NdisMiniportBlock.StatusCompleteHandler= MiniStatusComplete;
+ Adapter->NdisMiniportBlock.SendPacketsHandler = ProSendPackets;
+ Adapter->NdisMiniportBlock.QueryCompleteHandler = MiniRequestComplete;
+ Adapter->NdisMiniportBlock.SetCompleteHandler = MiniRequestComplete;
/*
* Call MiniportInitialize.
{
NDIS_DbgPrint(MIN_TRACE, ("MiniportInitialize() failed for an adapter.\n"));
ExInterlockedRemoveEntryList( &Adapter->ListEntry, &AdapterListLock );
+ if (Adapter->NdisMiniportBlock.Interrupt)
+ {
+ KeBugCheckEx(BUGCODE_ID_DRIVER,
+ (ULONG_PTR)Adapter,
+ (ULONG_PTR)Adapter->NdisMiniportBlock.Interrupt,
+ (ULONG_PTR)Adapter->NdisMiniportBlock.TimerQueue,
+ 1);
+ }
+ if (Adapter->NdisMiniportBlock.TimerQueue)
+ {
+ KeBugCheckEx(BUGCODE_ID_DRIVER,
+ (ULONG_PTR)Adapter,
+ (ULONG_PTR)Adapter->NdisMiniportBlock.Interrupt,
+ (ULONG_PTR)Adapter->NdisMiniportBlock.TimerQueue,
+ 1);
+ }
return NdisStatus;
}
if (SelectedMediumIndex >= MEDIA_ARRAY_SIZE)
{
- NDIS_DbgPrint(MIN_TRACE, ("MiniportInitialize() failed for an adapter\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("MiniportInitialize() selected a bad index\n"));
ExInterlockedRemoveEntryList( &Adapter->ListEntry, &AdapterListLock );
return NDIS_STATUS_UNSUPPORTED_MEDIA;
}
NdisStatus = DoQueries(Adapter, AddressOID);
if (NdisStatus == NDIS_STATUS_SUCCESS)
{
- Success = EthCreateFilter(32, /* FIXME: Query this from miniport. */
+ NdisStatus = MiniQueryInformation(Adapter, OID_802_3_MAXIMUM_LIST_SIZE, sizeof(UINT),
+ &MaxMulticastAddresses, &BytesWritten);
+
+ if (NdisStatus != NDIS_STATUS_SUCCESS)
+ {
+ ExInterlockedRemoveEntryList( &Adapter->ListEntry, &AdapterListLock );
+ NDIS_DbgPrint(MIN_TRACE, ("MiniQueryInformation failed (%x)\n", NdisStatus));
+ return NdisStatus;
+ }
+
+ Success = EthCreateFilter(MaxMulticastAddresses,
Adapter->Address.Type.Medium802_3,
&Adapter->NdisMiniportBlock.EthDB);
if (Success)
/* FIXME: Support other types of media */
NDIS_DbgPrint(MIN_TRACE, ("error: unsupported media\n"));
ASSERT(FALSE);
-/* FIXME - KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql); */
ExInterlockedRemoveEntryList( &Adapter->ListEntry, &AdapterListLock );
return STATUS_UNSUCCESSFUL;
}
if (NdisStatus != NDIS_STATUS_SUCCESS)
{
- NDIS_DbgPrint(MAX_TRACE, ("couldn't create filter (%x)\n", NdisStatus));
- if (Adapter->LookaheadBuffer)
- {
- ExFreePool(Adapter->LookaheadBuffer);
- Adapter->LookaheadBuffer = NULL;
- }
- ExInterlockedRemoveEntryList( &Adapter->ListEntry, &AdapterListLock );
+ NDIS_DbgPrint(MIN_TRACE, ("couldn't create filter (%x)\n", NdisStatus));
return NdisStatus;
}
Adapter->NdisMiniportBlock.OldPnPDeviceState = Adapter->NdisMiniportBlock.PnPDeviceState;
Adapter->NdisMiniportBlock.PnPDeviceState = NdisPnPDeviceStarted;
- Timeout.QuadPart = (LONGLONG)Adapter->NdisMiniportBlock.CheckForHangSeconds * -1000000;
+ IoSetDeviceInterfaceState(&Adapter->NdisMiniportBlock.SymbolicLinkName, TRUE);
+
+ Timeout.QuadPart = Int32x32To64(Adapter->NdisMiniportBlock.CheckForHangSeconds, -1000000);
KeSetTimerEx(&Adapter->NdisMiniportBlock.WakeUpDpcTimer.Timer, Timeout,
Adapter->NdisMiniportBlock.CheckForHangSeconds * 1000,
&Adapter->NdisMiniportBlock.WakeUpDpcTimer.Dpc);
/* Put adapter in adapter list for this miniport */
ExInterlockedInsertTailList(&Adapter->NdisMiniportBlock.DriverHandle->DeviceList, &Adapter->MiniportListEntry, &Adapter->NdisMiniportBlock.DriverHandle->Lock);
+ /* Refresh bindings for all protocols */
+ CurrentEntry = ProtocolListHead.Flink;
+ while (CurrentEntry != &ProtocolListHead)
+ {
+ ProtocolBinding = CONTAINING_RECORD(CurrentEntry, PROTOCOL_BINDING, ListEntry);
+
+ ndisBindMiniportsToProtocol(&NdisStatus, ProtocolBinding);
+
+ CurrentEntry = CurrentEntry->Flink;
+ }
+
return STATUS_SUCCESS;
}
*/
{
PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
- KIRQL OldIrql;
/* Remove adapter from adapter list for this miniport */
- KeAcquireSpinLock(&Adapter->NdisMiniportBlock.DriverHandle->Lock, &OldIrql);
- RemoveEntryList(&Adapter->MiniportListEntry);
- KeReleaseSpinLock(&Adapter->NdisMiniportBlock.DriverHandle->Lock, OldIrql);
+ ExInterlockedRemoveEntryList(&Adapter->MiniportListEntry, &Adapter->NdisMiniportBlock.DriverHandle->Lock);
/* Remove adapter from global adapter list */
- KeAcquireSpinLock(&AdapterListLock, &OldIrql);
- RemoveEntryList(&Adapter->ListEntry);
- KeReleaseSpinLock(&AdapterListLock, OldIrql);
+ ExInterlockedRemoveEntryList(&Adapter->ListEntry, &AdapterListLock);
KeCancelTimer(&Adapter->NdisMiniportBlock.WakeUpDpcTimer.Timer);
(*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.HaltHandler)(Adapter);
- if (Adapter->LookaheadBuffer)
- {
- ExFreePool(Adapter->LookaheadBuffer);
- Adapter->LookaheadBuffer = NULL;
- }
+ IoSetDeviceInterfaceState(&Adapter->NdisMiniportBlock.SymbolicLinkName, FALSE);
+
if (Adapter->NdisMiniportBlock.AllocatedResources)
{
ExFreePool(Adapter->NdisMiniportBlock.AllocatedResources);
Adapter->NdisMiniportBlock.AllocatedResourcesTranslated = NULL;
}
+ if (Adapter->NdisMiniportBlock.Resources)
+ {
+ ExFreePool(Adapter->NdisMiniportBlock.Resources);
+ Adapter->NdisMiniportBlock.Resources = NULL;
+ }
+
+ if (Adapter->NdisMiniportBlock.EthDB)
+ {
+ EthDeleteFilter(Adapter->NdisMiniportBlock.EthDB);
+ Adapter->NdisMiniportBlock.EthDB = NULL;
+ }
+
Adapter->NdisMiniportBlock.OldPnPDeviceState = Adapter->NdisMiniportBlock.PnPDeviceState;
Adapter->NdisMiniportBlock.PnPDeviceState = NdisPnPDeviceStopped;
return STATUS_SUCCESS;
}
+NTSTATUS
+NTAPI
+NdisIDeviceIoControl(
+ IN PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
+{
+ PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
+ PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
+ NDIS_STATUS Status = STATUS_NOT_SUPPORTED;
+ ULONG Written;
+
+ Irp->IoStatus.Information = 0;
+
+ ASSERT(Adapter);
+
+ switch (Stack->Parameters.DeviceIoControl.IoControlCode)
+ {
+ case IOCTL_NDIS_QUERY_GLOBAL_STATS:
+ Status = MiniQueryInformation(Adapter,
+ *(PNDIS_OID)Irp->AssociatedIrp.SystemBuffer,
+ Stack->Parameters.DeviceIoControl.OutputBufferLength,
+ MmGetSystemAddressForMdl(Irp->MdlAddress),
+ &Written);
+ Irp->IoStatus.Information = Written;
+ break;
+
+ default:
+ ASSERT(FALSE);
+ break;
+ }
+
+ if (Status != NDIS_STATUS_PENDING)
+ {
+ Irp->IoStatus.Status = Status;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ }
+ else
+ IoMarkIrpPending(Irp);
+
+ return Status;
+}
+
\f
NTSTATUS
NTAPI
{
Status = NdisIPnPStartDevice(DeviceObject, Irp);
}
+ else
+ NDIS_DbgPrint(MIN_TRACE, ("Lower driver failed device start\n"));
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
{
Status = NdisIPnPStopDevice(DeviceObject, Irp);
}
+ else
+ NDIS_DbgPrint(MIN_TRACE, ("Lower driver failed device stop\n"));
+ Irp->IoStatus.Status = Status;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ break;
+
+ case IRP_MN_QUERY_REMOVE_DEVICE:
+ case IRP_MN_QUERY_STOP_DEVICE:
+ Status = NdisIPnPQueryStopDevice(DeviceObject, Irp);
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
- case IRP_MN_QUERY_DEVICE_RELATIONS:
- Status = STATUS_NOT_SUPPORTED;
+ case IRP_MN_CANCEL_REMOVE_DEVICE:
+ case IRP_MN_CANCEL_STOP_DEVICE:
+ Status = NdisIPnPCancelStopDevice(DeviceObject, Irp);
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
+ case IRP_MN_QUERY_PNP_DEVICE_STATE:
+ Status = NDIS_STATUS_SUCCESS;
+ Irp->IoStatus.Status = Status;
+ Irp->IoStatus.Information |= Adapter->NdisMiniportBlock.PnPFlags;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ break;
+
default:
IoSkipCurrentIrpStackLocation(Irp);
Status = IoCallDriver(Adapter->NdisMiniportBlock.NextDeviceObject, Irp);
* Gain the access to the miniport data structure first.
*/
- MiniportPtr = IoGetDriverObjectExtension(DriverObject, (PVOID)TAG('D','I','M','N'));
+ MiniportPtr = IoGetDriverObjectExtension(DriverObject, (PVOID)'NMID');
if (MiniportPtr == NULL)
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Can't get driver object extension.\n"));
- return STATUS_UNSUCCESSFUL;
+ NDIS_DbgPrint(MIN_TRACE, ("Can't get driver object extension.\n"));
+ return NDIS_STATUS_FAILURE;
}
Miniport = *MiniportPtr;
0, NULL, &DriverKeyLength);
if (Status != STATUS_BUFFER_TOO_SMALL && Status != STATUS_BUFFER_OVERFLOW && Status != STATUS_SUCCESS)
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Can't get miniport driver key length.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Can't get miniport driver key length.\n"));
return Status;
}
sizeof(ClassKeyName) + sizeof(LinkageKeyName));
if (LinkageKeyBuffer == NULL)
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Can't allocate memory for driver key name.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Can't allocate memory for driver key name.\n"));
return STATUS_INSUFFICIENT_RESOURCES;
}
&DriverKeyLength);
if (!NT_SUCCESS(Status))
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Can't get miniport driver key.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Can't get miniport driver key.\n"));
ExFreePool(LinkageKeyBuffer);
return Status;
}
ExFreePool(LinkageKeyBuffer);
if (!NT_SUCCESS(Status))
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Can't get miniport device name. (%x)\n", Status));
+ NDIS_DbgPrint(MIN_TRACE, ("Can't get miniport device name. (%x)\n", Status));
return Status;
}
Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
KeInitializeSpinLock(&Adapter->NdisMiniportBlock.Lock);
InitializeListHead(&Adapter->ProtocolListHead);
- Adapter->NdisMiniportBlock.DriverHandle = Miniport;
- Adapter->NdisMiniportBlock.MiniportName = ExportName;
+ Status = IoRegisterDeviceInterface(PhysicalDeviceObject,
+ &GUID_DEVINTERFACE_NET,
+ NULL,
+ &Adapter->NdisMiniportBlock.SymbolicLinkName);
+
+ if (!NT_SUCCESS(Status))
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("Could not create device interface.\n"));
+ IoDeleteDevice(DeviceObject);
+ RtlFreeUnicodeString(&ExportName);
+ return Status;
+ }
+ Adapter->NdisMiniportBlock.DriverHandle = Miniport;
+ Adapter->NdisMiniportBlock.MiniportName = ExportName;
Adapter->NdisMiniportBlock.DeviceObject = DeviceObject;
Adapter->NdisMiniportBlock.PhysicalDeviceObject = PhysicalDeviceObject;
Adapter->NdisMiniportBlock.NextDeviceObject =
break;
default:
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Bad miniport characteristics version.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Bad miniport characteristics version.\n"));
return NDIS_STATUS_BAD_VERSION;
}
+ NDIS_DbgPrint(MIN_TRACE, ("Initializing an NDIS %u.%u miniport\n",
+ MiniportCharacteristics->MajorNdisVersion,
+ MiniportCharacteristics->MinorNdisVersion));
+
if (CharacteristicsLength < MinSize)
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Bad miniport characteristics.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Bad miniport characteristics length.\n"));
return NDIS_STATUS_BAD_CHARACTERISTICS;
}
/* Check if mandatory MiniportXxx functions are specified */
if ((!MiniportCharacteristics->HaltHandler) ||
- (!MiniportCharacteristics->InitializeHandler)||
- (!MiniportCharacteristics->QueryInformationHandler) ||
- (!MiniportCharacteristics->ResetHandler) ||
- (!MiniportCharacteristics->SetInformationHandler))
+ (!MiniportCharacteristics->InitializeHandler)||
+ (!MiniportCharacteristics->ResetHandler))
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Bad miniport characteristics.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Bad miniport characteristics.\n"));
return NDIS_STATUS_BAD_CHARACTERISTICS;
}
+ if (MiniportCharacteristics->MajorNdisVersion < 0x05)
+ {
+ if ((!MiniportCharacteristics->QueryInformationHandler) ||
+ (!MiniportCharacteristics->SetInformationHandler))
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("Bad miniport characteristics. (Set/Query)\n"));
+ return NDIS_STATUS_BAD_CHARACTERISTICS;
+ }
+ }
+ else
+ {
+ if (((!MiniportCharacteristics->QueryInformationHandler) ||
+ (!MiniportCharacteristics->SetInformationHandler)) &&
+ (!MiniportCharacteristics->CoRequestHandler))
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("Bad miniport characteristics. (Set/Query)\n"));
+ return NDIS_STATUS_BAD_CHARACTERISTICS;
+ }
+ }
+
if (MiniportCharacteristics->MajorNdisVersion == 0x03)
{
if (!MiniportCharacteristics->SendHandler)
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Bad miniport characteristics.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Bad miniport characteristics. (NDIS 3.0)\n"));
return NDIS_STATUS_BAD_CHARACTERISTICS;
}
}
- else if (MiniportCharacteristics->MajorNdisVersion >= 0x04)
+ else if (MiniportCharacteristics->MajorNdisVersion == 0x04)
{
- /* NDIS 4.0+ */
+ /* NDIS 4.0 */
if ((!MiniportCharacteristics->SendHandler) &&
(!MiniportCharacteristics->SendPacketsHandler))
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Bad miniport characteristics.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Bad miniport characteristics. (NDIS 4.0)\n"));
+ return NDIS_STATUS_BAD_CHARACTERISTICS;
+ }
+ }
+ else if (MiniportCharacteristics->MajorNdisVersion == 0x05)
+ {
+ /* TODO: Add more checks here */
+
+ if ((!MiniportCharacteristics->SendHandler) &&
+ (!MiniportCharacteristics->SendPacketsHandler) &&
+ (!MiniportCharacteristics->CoSendPacketsHandler))
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("Bad miniport characteristics. (NDIS 5.0)\n"));
return NDIS_STATUS_BAD_CHARACTERISTICS;
}
}
* structure in the driver extension or what?
*/
- Status = IoAllocateDriverObjectExtension(Miniport->DriverObject, (PVOID)TAG('D','I','M','N'),
+ Status = IoAllocateDriverObjectExtension(Miniport->DriverObject, (PVOID)'NMID',
sizeof(PNDIS_M_DRIVER_BLOCK), (PVOID*)&MiniportPtr);
if (!NT_SUCCESS(Status))
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Can't allocate driver object extension.\n"));
+ NDIS_DbgPrint(MIN_TRACE, ("Can't allocate driver object extension.\n"));
return NDIS_STATUS_RESOURCES;
}
*MiniportPtr = Miniport;
+ Miniport->DriverObject->MajorFunction[IRP_MJ_CREATE] = NdisICreateClose;
+ Miniport->DriverObject->MajorFunction[IRP_MJ_CLOSE] = NdisICreateClose;
Miniport->DriverObject->MajorFunction[IRP_MJ_PNP] = NdisIDispatchPnp;
Miniport->DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = NdisIShutdown;
+ Miniport->DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = NdisIDeviceIoControl;
Miniport->DriverObject->DriverExtension->AddDevice = NdisIAddDevice;
return NDIS_STATUS_SUCCESS;
}
\f
-/*
- * @implemented
- */
-#undef NdisMSetInformationComplete
-VOID
-EXPORT
-NdisMSetInformationComplete(
- IN NDIS_HANDLE MiniportAdapterHandle,
- IN NDIS_STATUS Status)
-{
- PLOGICAL_ADAPTER Adapter =
- (PLOGICAL_ADAPTER)MiniportAdapterHandle;
- KIRQL OldIrql;
- ASSERT(Adapter);
- KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
- (Adapter->NdisMiniportBlock.SetCompleteHandler)(MiniportAdapterHandle, Status);
- KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
- Adapter->MiniportBusy = FALSE;
- KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
- KeLowerIrql(OldIrql);
-}
-
-\f
/*
* @implemented
*/
Adapter->NdisMiniportBlock.CheckForHangSeconds = CheckForHangTimeInSeconds;
if (AttributeFlags & NDIS_ATTRIBUTE_INTERMEDIATE_DRIVER)
NDIS_DbgPrint(MAX_TRACE, ("Intermediate drivers not supported yet.\n"));
+
+
+ if (Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.AdapterShutdownHandler)
+ {
+ NDIS_DbgPrint(MAX_TRACE, ("Miniport set AdapterShutdownHandler in MiniportCharacteristics\n"));
+ NdisMRegisterAdapterShutdownHandler(Adapter,
+ Adapter->NdisMiniportBlock.MiniportAdapterContext,
+ Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.AdapterShutdownHandler);
+ }
}
\f
ExFreePool(Miniport->RegistryPath->Buffer);
ExFreePool(Miniport->RegistryPath);
+ ExInterlockedRemoveEntryList(&Miniport->ListEntry, &MiniportListLock);
ExFreePool(Miniport);
}
+
+/*
+ * @implemented
+ */
+NDIS_STATUS
+EXPORT
+NdisMQueryAdapterInstanceName(
+ OUT PNDIS_STRING AdapterInstanceName,
+ IN NDIS_HANDLE MiniportAdapterHandle)
+/*
+ * FUNCTION:
+ * ARGUMENTS:
+ * NOTES:
+ * NDIS 5.0
+ */
+{
+ PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)MiniportAdapterHandle;
+ UNICODE_STRING AdapterName;
+
+ NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+ AdapterName.Length = 0;
+ AdapterName.MaximumLength = Adapter->NdisMiniportBlock.MiniportName.MaximumLength;
+ AdapterName.Buffer = ExAllocatePool(PagedPool, AdapterName.MaximumLength);
+ if (!AdapterName.Buffer) {
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
+ return NDIS_STATUS_RESOURCES;
+ }
+
+ RtlCopyUnicodeString(&AdapterName, &Adapter->NdisMiniportBlock.MiniportName);
+
+ *AdapterInstanceName = AdapterName;
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+/*
+ * @implemented
+ */
+VOID
+EXPORT
+NdisDeregisterAdapterShutdownHandler(
+ IN NDIS_HANDLE NdisAdapterHandle)
+/*
+ * FUNCTION:
+ * ARGUMENTS:
+ * NOTES:
+ * NDIS 4.0
+ */
+{
+ NdisMDeregisterAdapterShutdownHandler(NdisAdapterHandle);
+}
+
+
+/*
+ * @implemented
+ */
+VOID
+EXPORT
+NdisRegisterAdapterShutdownHandler(
+ IN NDIS_HANDLE NdisAdapterHandle,
+ IN PVOID ShutdownContext,
+ IN ADAPTER_SHUTDOWN_HANDLER ShutdownHandler)
+/*
+ * FUNCTION:
+ * ARGUMENTS:
+ * NOTES:
+ * NDIS 4.0
+ */
+{
+ NdisMRegisterAdapterShutdownHandler(NdisAdapterHandle,
+ ShutdownContext,
+ ShutdownHandler);
+}
+
+/*
+ * @implemented
+ */
+VOID
+EXPORT
+NdisMGetDeviceProperty(
+ IN NDIS_HANDLE MiniportAdapterHandle,
+ IN OUT PDEVICE_OBJECT *PhysicalDeviceObject OPTIONAL,
+ IN OUT PDEVICE_OBJECT *FunctionalDeviceObject OPTIONAL,
+ IN OUT PDEVICE_OBJECT *NextDeviceObject OPTIONAL,
+ IN OUT PCM_RESOURCE_LIST *AllocatedResources OPTIONAL,
+ IN OUT PCM_RESOURCE_LIST *AllocatedResourcesTranslated OPTIONAL)
+/*
+ * FUNCTION:
+ * ARGUMENTS:
+ * NOTES:
+ * NDIS 5.0
+ */
+{
+ PLOGICAL_ADAPTER Adapter = MiniportAdapterHandle;
+
+ NDIS_DbgPrint(MAX_TRACE, ("Called\n"));
+
+ if (PhysicalDeviceObject != NULL)
+ *PhysicalDeviceObject = Adapter->NdisMiniportBlock.PhysicalDeviceObject;
+
+ if (FunctionalDeviceObject != NULL)
+ *FunctionalDeviceObject = Adapter->NdisMiniportBlock.DeviceObject;
+
+ if (NextDeviceObject != NULL)
+ *NextDeviceObject = Adapter->NdisMiniportBlock.NextDeviceObject;
+
+ if (AllocatedResources != NULL)
+ *AllocatedResources = Adapter->NdisMiniportBlock.AllocatedResources;
+
+ if (AllocatedResourcesTranslated != NULL)
+ *AllocatedResourcesTranslated = Adapter->NdisMiniportBlock.AllocatedResourcesTranslated;
+}
+
+/*
+ * @implemented
+ */
+VOID
+EXPORT
+NdisMRegisterUnloadHandler(
+ IN NDIS_HANDLE NdisWrapperHandle,
+ IN PDRIVER_UNLOAD UnloadHandler)
+/*
+ * FUNCTION:
+ * ARGUMENTS:
+ * NOTES:
+ * NDIS 5.0
+ */
+{
+ PNDIS_M_DRIVER_BLOCK DriverBlock = NdisWrapperHandle;
+
+ NDIS_DbgPrint(MAX_TRACE, ("Miniport registered unload handler\n"));
+
+ DriverBlock->DriverObject->DriverUnload = UnloadHandler;
+}
+
+/*
+ * @implemented
+ */
+NDIS_STATUS
+EXPORT
+NdisMRegisterDevice(
+ IN NDIS_HANDLE NdisWrapperHandle,
+ IN PNDIS_STRING DeviceName,
+ IN PNDIS_STRING SymbolicName,
+ IN PDRIVER_DISPATCH MajorFunctions[],
+ OUT PDEVICE_OBJECT *pDeviceObject,
+ OUT NDIS_HANDLE *NdisDeviceHandle)
+/*
+ * FUNCTION:
+ * ARGUMENTS:
+ * NOTES:
+ * NDIS 5.0
+ */
+{
+ PNDIS_M_DRIVER_BLOCK DriverBlock = NdisWrapperHandle;
+ PNDIS_M_DEVICE_BLOCK DeviceBlock;
+ PDEVICE_OBJECT DeviceObject;
+ NDIS_STATUS Status;
+ UINT i;
+
+ NDIS_DbgPrint(MAX_TRACE, ("Called\n"));
+
+ Status = IoCreateDevice(DriverBlock->DriverObject,
+ 0, /* This space is reserved for us. Should we use it? */
+ DeviceName,
+ FILE_DEVICE_NETWORK,
+ 0,
+ FALSE,
+ &DeviceObject);
+
+ if (!NT_SUCCESS(Status))
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("IoCreateDevice failed (%x)\n", Status));
+ return Status;
+ }
+
+ Status = IoCreateSymbolicLink(SymbolicName, DeviceName);
+
+ if (!NT_SUCCESS(Status))
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("IoCreateSymbolicLink failed (%x)\n", Status));
+ IoDeleteDevice(DeviceObject);
+ return Status;
+ }
+
+ DeviceBlock = ExAllocatePool(NonPagedPool, sizeof(NDIS_M_DEVICE_BLOCK));
+
+ if (!DeviceBlock)
+ {
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
+ IoDeleteDevice(DeviceObject);
+ IoDeleteSymbolicLink(SymbolicName);
+ return NDIS_STATUS_RESOURCES;
+ }
+
+ for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
+ DriverBlock->DriverObject->MajorFunction[i] = MajorFunctions[i];
+
+ DriverBlock->DriverObject->MajorFunction[IRP_MJ_PNP] = NdisIDispatchPnp;
+
+ if (!DriverBlock->DriverObject->MajorFunction[IRP_MJ_CREATE])
+ DriverBlock->DriverObject->MajorFunction[IRP_MJ_CREATE] = NdisICreateClose;
+
+ if (!DriverBlock->DriverObject->MajorFunction[IRP_MJ_CLOSE])
+ DriverBlock->DriverObject->MajorFunction[IRP_MJ_CLOSE] = NdisICreateClose;
+
+ DeviceBlock->DeviceObject = DeviceObject;
+ DeviceBlock->SymbolicName = SymbolicName;
+
+ *pDeviceObject = DeviceObject;
+ *NdisDeviceHandle = DeviceBlock;
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+/*
+ * @implemented
+ */
+NDIS_STATUS
+EXPORT
+NdisMDeregisterDevice(
+ IN NDIS_HANDLE NdisDeviceHandle)
+/*
+ * FUNCTION:
+ * ARGUMENTS:
+ * NOTES:
+ * NDIS 5.0
+ */
+{
+ PNDIS_M_DEVICE_BLOCK DeviceBlock = NdisDeviceHandle;
+
+ IoDeleteDevice(DeviceBlock->DeviceObject);
+
+ IoDeleteSymbolicLink(DeviceBlock->SymbolicName);
+
+ ExFreePool(DeviceBlock);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+/*
+ * @implemented
+ */
+NDIS_STATUS
+EXPORT
+NdisQueryAdapterInstanceName(
+ OUT PNDIS_STRING AdapterInstanceName,
+ IN NDIS_HANDLE NdisBindingHandle)
+/*
+ * FUNCTION:
+ * ARGUMENTS:
+ * NOTES:
+ * NDIS 5.0
+ */
+{
+ PADAPTER_BINDING AdapterBinding = NdisBindingHandle;
+ PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
+
+ return NdisMQueryAdapterInstanceName(AdapterInstanceName,
+ Adapter);
+}
+
+/*
+ * @implemented
+ */
+VOID
+EXPORT
+NdisCompletePnPEvent(
+ IN NDIS_STATUS Status,
+ IN NDIS_HANDLE NdisBindingHandle,
+ IN PNET_PNP_EVENT NetPnPEvent)
+/*
+ * FUNCTION:
+ * ARGUMENTS:
+ * NOTES:
+ * NDIS 5.0
+ */
+{
+ PIRP Irp = (PIRP)NetPnPEvent->NdisReserved[0];
+ PLIST_ENTRY CurrentEntry = (PLIST_ENTRY)NetPnPEvent->NdisReserved[1];
+ PADAPTER_BINDING AdapterBinding = NdisBindingHandle;
+ PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
+ NDIS_STATUS NdisStatus;
+
+ if (Status != NDIS_STATUS_SUCCESS)
+ {
+ if (NetPnPEvent->Buffer) ExFreePool(NetPnPEvent->Buffer);
+ ExFreePool(NetPnPEvent);
+ Irp->IoStatus.Status = Status;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return;
+ }
+
+ while (CurrentEntry != &Adapter->ProtocolListHead)
+ {
+ AdapterBinding = CONTAINING_RECORD(CurrentEntry, ADAPTER_BINDING, AdapterListEntry);
+
+ NdisStatus = (*AdapterBinding->ProtocolBinding->Chars.PnPEventHandler)(
+ AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
+ NetPnPEvent);
+
+ if (NdisStatus == NDIS_STATUS_PENDING)
+ {
+ NetPnPEvent->NdisReserved[1] = (ULONG_PTR)CurrentEntry->Flink;
+ return;
+ }
+ else if (NdisStatus != NDIS_STATUS_SUCCESS)
+ {
+ if (NetPnPEvent->Buffer) ExFreePool(NetPnPEvent->Buffer);
+ ExFreePool(NetPnPEvent);
+ Irp->IoStatus.Status = NdisStatus;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return;
+ }
+
+ CurrentEntry = CurrentEntry->Flink;
+ }
+
+ if (NetPnPEvent->Buffer) ExFreePool(NetPnPEvent->Buffer);
+ ExFreePool(NetPnPEvent);
+
+ Irp->IoStatus.Status = NDIS_STATUS_SUCCESS;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+}
+
+/*
+ * @implemented
+ */
+VOID
+EXPORT
+NdisCancelSendPackets(
+ IN NDIS_HANDLE NdisBindingHandle,
+ IN PVOID CancelId)
+{
+ PADAPTER_BINDING AdapterBinding = NdisBindingHandle;
+ PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
+
+ NDIS_DbgPrint(MAX_TRACE, ("Called for ID %x.\n", CancelId));
+
+ if (Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.CancelSendPacketsHandler)
+ {
+ (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.CancelSendPacketsHandler)(
+ Adapter->NdisMiniportBlock.MiniportAdapterContext,
+ CancelId);
+ }
+}
+
+
+/*
+ * @implemented
+ */
+NDIS_HANDLE
+EXPORT
+NdisIMGetBindingContext(
+ IN NDIS_HANDLE NdisBindingHandle)
+/*
+ * FUNCTION:
+ * ARGUMENTS:
+ * NOTES:
+ * NDIS 5.0
+ */
+{
+ PADAPTER_BINDING AdapterBinding = NdisBindingHandle;
+ PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
+
+ NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+ return Adapter->NdisMiniportBlock.DeviceContext;
+}
+
+
+/*
+ * @implemented
+ */
+NDIS_HANDLE
+EXPORT
+NdisIMGetDeviceContext(
+ IN NDIS_HANDLE MiniportAdapterHandle)
+/*
+ * FUNCTION:
+ * ARGUMENTS:
+ * NOTES:
+ * NDIS 5.0
+ */
+{
+ PLOGICAL_ADAPTER Adapter = MiniportAdapterHandle;
+
+ NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+ return Adapter->NdisMiniportBlock.DeviceContext;
+}
+
/* EOF */