* 20 Aug 2003 vizzini - DMA support
* 3 Oct 2003 vizzini - SendPackets support
*/
-#include <roscfg.h>
+
#include "ndissys.h"
#include "efilter.h"
UCHAR Buffer[64];
if ((DebugTraceLevel & DEBUG_PACKET) > 0) {
Length = CopyPacketToBuffer(
- (PUCHAR)&Buffer,
+ Buffer,
Packet,
0,
64);
(MID_TRACE,
("XXX (%x) %x %x %x %x %x %x %x XXX\n",
*AdapterBinding->ProtocolBinding->Chars.ReceiveHandler,
- AdapterBinding->NdisOpenBlock.NdisCommonOpenBlock.ProtocolBindingContext,
+ AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
MacReceiveContext,
HeaderBuffer,
HeaderBufferSize,
/* call the receive handler */
(*AdapterBinding->ProtocolBinding->Chars.ReceiveHandler)(
- AdapterBinding->NdisOpenBlock.NdisCommonOpenBlock.ProtocolBindingContext,
+ AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
MacReceiveContext,
HeaderBuffer,
HeaderBufferSize,
}
\f
-VOID STDCALL
+VOID NTAPI
MiniIndicateReceivePacket(
IN NDIS_HANDLE Miniport,
IN PPNDIS_PACKET PacketArray,
}
\f
-VOID STDCALL
+VOID NTAPI
MiniResetComplete(
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_STATUS Status,
}
-VOID STDCALL
+\f
+VOID NTAPI
+MiniRequestComplete(
+ IN PNDIS_MINIPORT_BLOCK Adapter,
+ IN PNDIS_REQUEST Request,
+ IN NDIS_STATUS Status)
+{
+ PNDIS_REQUEST_MAC_BLOCK MacBlock = (PNDIS_REQUEST_MAC_BLOCK)Request->MacReserved;
+
+ NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
+
+ if( MacBlock->Binding->RequestCompleteHandler ) {
+ (*MacBlock->Binding->RequestCompleteHandler)(
+ MacBlock->Binding->ProtocolBindingContext,
+ Request,
+ Status);
+ }
+}
+
+VOID NTAPI
MiniSendComplete(
IN NDIS_HANDLE MiniportAdapterHandle,
IN PNDIS_PACKET Packet,
AdapterBinding = (PADAPTER_BINDING)Packet->Reserved[0];
(*AdapterBinding->ProtocolBinding->Chars.SendCompleteHandler)(
- AdapterBinding->NdisOpenBlock.NdisCommonOpenBlock.ProtocolBindingContext,
+ AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
Packet,
Status);
}
-VOID STDCALL
+VOID NTAPI
MiniSendResourcesAvailable(
IN NDIS_HANDLE MiniportAdapterHandle)
{
}
-VOID STDCALL
+VOID NTAPI
MiniTransferDataComplete(
IN NDIS_HANDLE MiniportAdapterHandle,
IN PNDIS_PACKET Packet,
AdapterBinding = (PADAPTER_BINDING)Packet->Reserved[0];
(*AdapterBinding->ProtocolBinding->Chars.SendCompleteHandler)(
- AdapterBinding->NdisOpenBlock.NdisCommonOpenBlock.ProtocolBindingContext,
+ AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
Packet,
Status);
}
if (RtlCompareUnicodeString(AdapterName, &Adapter->NdisMiniportBlock.MiniportName, TRUE) == 0)
{
- ReferenceObject(Adapter);
break;
}
PLOGICAL_ADAPTER Adapter,
NDIS_OID Oid,
ULONG Size,
+ PVOID Buffer,
PULONG BytesWritten)
/*
* FUNCTION: Queries a logical adapter for properties
* ARGUMENTS:
* Adapter = Pointer to the logical adapter object to query
* Oid = Specifies the Object ID to query for
- * Size = If non-zero overrides the length in the adapter object
+ * 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,
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
- if (Adapter->QueryBufferLength == 0)
- {
- /* XXX is 32 the right number? */
- Adapter->QueryBuffer = ExAllocatePool(NonPagedPool, (Size == 0)? 32 : Size);
-
- if (!Adapter->QueryBuffer)
- {
- NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
- return NDIS_STATUS_RESOURCES;
- }
-
- /* ditto */
- Adapter->QueryBufferLength = (Size == 0)? 32 : Size;
- }
-
- /* this is the third time i've seen this conditional */
- BytesNeeded = (Size == 0)? Adapter->QueryBufferLength : Size;
-
/* call the miniport's queryinfo handler */
- NdisStatus = (*Adapter->Miniport->Chars.QueryInformationHandler)(
+ NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.QueryInformationHandler)(
Adapter->NdisMiniportBlock.MiniportAdapterContext,
Oid,
- Adapter->QueryBuffer,
- BytesNeeded,
+ Buffer,
+ Size,
BytesWritten,
&BytesNeeded);
+ /* FIXME: Wait in pending case! */
+
/* XXX is status_pending part of success macro? */
if ((NT_SUCCESS(NdisStatus)) || (NdisStatus == NDIS_STATUS_PENDING))
{
return NdisStatus;
}
- if (NdisStatus == NDIS_STATUS_INVALID_LENGTH)
- {
- ExFreePool(Adapter->QueryBuffer);
-
- Adapter->QueryBufferLength += BytesNeeded;
- Adapter->QueryBuffer = ExAllocatePool(NonPagedPool, Adapter->QueryBufferLength);
-
- if (!Adapter->QueryBuffer)
- {
- NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
- return NDIS_STATUS_RESOURCES;
- }
-
- NdisStatus = (*Adapter->Miniport->Chars.QueryInformationHandler)(
- Adapter->NdisMiniportBlock.MiniportAdapterContext,
- Oid,
- Adapter->QueryBuffer,
- Adapter->QueryBufferLength,
- BytesWritten,
- &BytesNeeded);
- }
-
return NdisStatus;
}
NDIS_STATUS
FASTCALL
MiniQueueWorkItem(
- PLOGICAL_ADAPTER Adapter,
- NDIS_WORK_ITEM_TYPE WorkItemType,
- PVOID WorkItemContext)
+ PLOGICAL_ADAPTER Adapter,
+ NDIS_WORK_ITEM_TYPE WorkItemType,
+ PVOID WorkItemContext)
/*
* FUNCTION: Queues a work item for execution at a later time
* ARGUMENTS:
* Status of operation
*/
{
- PNDIS_MINIPORT_WORK_ITEM Item;
-
- NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
-
- ASSERT(Adapter);
- ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
-
-#if 0
- if (Adapter->WorkQueueLevel < NDIS_MINIPORT_WORK_QUEUE_SIZE - 1)
- {
- Item = &Adapter->WorkQueue[Adapter->WorkQueueLevel];
- Adapter->WorkQueueLevel++;
- }
- else
-#endif
+ PNDIS_MINIPORT_WORK_ITEM Item;
+
+ NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+ ASSERT(Adapter);
+ ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
+
+ Item = ExAllocatePool(NonPagedPool, sizeof(NDIS_MINIPORT_WORK_ITEM));
+ if (Item == NULL)
{
- Item = ExAllocatePool(NonPagedPool, sizeof(NDIS_MINIPORT_WORK_ITEM));
- if (Item == NULL)
- {
- NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
- return NDIS_STATUS_RESOURCES;
- }
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
+ return NDIS_STATUS_RESOURCES;
}
-
- Item->WorkItemType = WorkItemType;
- Item->WorkItemContext = WorkItemContext;
-
- /* safe due to adapter lock held */
- Item->Link.Next = NULL;
- if (!Adapter->WorkQueueHead)
+
+ Item->WorkItemType = WorkItemType;
+ Item->WorkItemContext = WorkItemContext;
+
+ /* safe due to adapter lock held */
+ Item->Link.Next = NULL;
+ if (!Adapter->WorkQueueHead)
{
- Adapter->WorkQueueHead = Item;
- Adapter->WorkQueueTail = Item;
+ Adapter->WorkQueueHead = Item;
+ Adapter->WorkQueueTail = Item;
}
- else
+ else
{
- Adapter->WorkQueueTail->Link.Next = (PSINGLE_LIST_ENTRY)Item;
- Adapter->WorkQueueTail = Item;
+ Adapter->WorkQueueTail->Link.Next = (PSINGLE_LIST_ENTRY)Item;
+ Adapter->WorkQueueTail = Item;
}
-
- KeInsertQueueDpc(&Adapter->MiniportDpc, NULL, NULL);
-
- return NDIS_STATUS_SUCCESS;
+
+ KeInsertQueueDpc(&Adapter->NdisMiniportBlock.DeferredDpc, NULL, NULL);
+
+ return NDIS_STATUS_SUCCESS;
}
\f
* FUNCTION: Dequeues a work item from the work queue of a logical adapter
* ARGUMENTS:
* Adapter = Pointer to the logical adapter object to dequeue work item from
+ * AdapterBinding = Address of buffer for adapter binding for this request
* WorkItemType = Address of buffer for work item type
* WorkItemContext = Address of buffer for pointer to context information
* NOTES:
* Status of operation
*/
{
- PNDIS_MINIPORT_WORK_ITEM Item;
-
- NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
-
- Item = Adapter->WorkQueueHead;
-
- if (Item)
+ PNDIS_MINIPORT_WORK_ITEM Item;
+
+ NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+ Item = Adapter->WorkQueueHead;
+
+ if (Item)
{
- /* safe due to adapter lock held */
- Adapter->WorkQueueHead = (PNDIS_MINIPORT_WORK_ITEM)Item->Link.Next;
-
- if (Item == Adapter->WorkQueueTail)
- Adapter->WorkQueueTail = NULL;
-
- *WorkItemType = Item->WorkItemType;
- *WorkItemContext = Item->WorkItemContext;
-
- ExFreePool(Item);
-
- return NDIS_STATUS_SUCCESS;
+ /* safe due to adapter lock held */
+ Adapter->WorkQueueHead = (PNDIS_MINIPORT_WORK_ITEM)Item->Link.Next;
+
+ if (Item == Adapter->WorkQueueTail)
+ Adapter->WorkQueueTail = NULL;
+
+ *WorkItemType = Item->WorkItemType;
+ *WorkItemContext = Item->WorkItemContext;
+
+ ExFreePool(Item);
+
+ return NDIS_STATUS_SUCCESS;
}
-
- return NDIS_STATUS_FAILURE;
+
+ return NDIS_STATUS_FAILURE;
}
\f
NDIS_STATUS
MiniDoRequest(
- PLOGICAL_ADAPTER Adapter,
+ PNDIS_MINIPORT_BLOCK Adapter,
PNDIS_REQUEST NdisRequest)
/*
* FUNCTION: Sends a request to a miniport
* ARGUMENTS:
- * Adapter = Pointer to logical adapter object
- * NdisRequest = Pointer to NDIS request structure describing request
+ * AdapterBinding = Pointer to binding used in the request
+ * NdisRequest = Pointer to NDIS request structure describing request
* RETURNS:
* Status of operation
*/
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
-
- Adapter->NdisMiniportBlock.MediaRequest = NdisRequest;
-
- switch (NdisRequest->RequestType)
+ NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
+
+ Adapter->MediaRequest = NdisRequest;
+
+ switch (NdisRequest->RequestType)
{
- case NdisRequestQueryInformation:
- return (*Adapter->Miniport->Chars.QueryInformationHandler)(
- Adapter->NdisMiniportBlock.MiniportAdapterContext,
+ case NdisRequestQueryInformation:
+ return (*Adapter->DriverHandle->MiniportCharacteristics.QueryInformationHandler)(
+ Adapter->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:
- return (*Adapter->Miniport->Chars.SetInformationHandler)(
- Adapter->NdisMiniportBlock.MiniportAdapterContext,
+
+ case NdisRequestSetInformation:
+ return (*Adapter->DriverHandle->MiniportCharacteristics.SetInformationHandler)(
+ Adapter->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:
+
+ default:
return NDIS_STATUS_FAILURE;
}
}
\f
-#undef NdisMQueryInformationComplete
/*
* @implemented
*/
+#undef NdisMQueryInformationComplete
VOID
EXPORT
NdisMQueryInformationComplete(
}
\f
-VOID STDCALL MiniportDpc(
+VOID NTAPI MiniportDpc(
IN PKDPC Dpc,
IN PVOID DeferredContext,
IN PVOID SystemArgument1,
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
- NdisStatus = MiniDequeueWorkItem(Adapter, &WorkItemType, &WorkItemContext);
+ NdisStatus =
+ MiniDequeueWorkItem
+ (Adapter, &WorkItemType, &WorkItemContext);
if (NdisStatus == NDIS_STATUS_SUCCESS)
{
#ifdef DBG
MiniDisplayPacket((PNDIS_PACKET)WorkItemContext);
#endif
- if(Adapter->Miniport->Chars.SendPacketsHandler)
+ if(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)
{
NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's SendPackets handler\n"));
* XXX assumes single-packet - prolly OK since we'll call something
* different on multi-packet sends
*/
- (*Adapter->Miniport->Chars.SendPacketsHandler)(
+ (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
Adapter->NdisMiniportBlock.MiniportAdapterContext, (PPNDIS_PACKET)&WorkItemContext, 1);
NdisStatus =
NDIS_GET_PACKET_STATUS((PNDIS_PACKET)WorkItemContext);
{
NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's Send handler\n"));
- NdisStatus = (*Adapter->Miniport->Chars.SendHandler)(
+ NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
Adapter->NdisMiniportBlock.MiniportAdapterContext, (PNDIS_PACKET)WorkItemContext, 0);
NDIS_DbgPrint(MAX_TRACE, ("back from miniport's Send handler\n"));
case NdisWorkItemResetInProgress:
break;
- case NdisWorkItemHalt:
- break;
-
case NdisWorkItemMiniportCallback:
break;
case NdisWorkItemRequest:
- NdisStatus = MiniDoRequest(Adapter, (PNDIS_REQUEST)WorkItemContext);
+ NdisStatus = MiniDoRequest(&Adapter->NdisMiniportBlock, (PNDIS_REQUEST)WorkItemContext);
if (NdisStatus == NDIS_STATUS_PENDING)
break;
{
case NdisRequestQueryInformation:
NdisMQueryInformationComplete((NDIS_HANDLE)Adapter, NdisStatus);
+ MiniRequestComplete( &Adapter->NdisMiniportBlock, (PNDIS_REQUEST)WorkItemContext, NdisStatus );
break;
case NdisRequestSetInformation:
NdisMSetInformationComplete((NDIS_HANDLE)Adapter, NdisStatus);
+ MiniRequestComplete( &Adapter->NdisMiniportBlock, (PNDIS_REQUEST)WorkItemContext, NdisStatus );
break;
default:
* ARGUMENTS: MiniportHandle: Handle passed into MiniportInitialize
*/
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)MiniportHandle;
+ NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
+
if(Adapter->BugcheckContext->ShutdownHandler)
KeDeregisterBugCheckCallback(Adapter->BugcheckContext->CallbackRecord);
}
UNIMPLEMENTED
}
-#undef NdisMIndicateStatus
-
/*
* @unimplemented
*/
+#undef NdisMIndicateStatus
VOID
EXPORT
NdisMIndicateStatus(
UNIMPLEMENTED
}
-#undef NdisMIndicateStatusComplete
-
/*
* @unimplemented
*/
+#undef NdisMIndicateStatusComplete
VOID
EXPORT
NdisMIndicateStatusComplete(
* - SystemSpecific2 goes invalid so we copy it
*/
{
- PMINIPORT_DRIVER Miniport;
+ PNDIS_M_DRIVER_BLOCK Miniport;
PUNICODE_STRING RegistryPath;
WCHAR *RegistryBuffer;
__asm__ ("int $3\n");
#endif
- Miniport = ExAllocatePool(NonPagedPool, sizeof(MINIPORT_DRIVER));
+ Miniport = ExAllocatePool(NonPagedPool, sizeof(NDIS_M_DRIVER_BLOCK));
if (!Miniport)
{
return;
}
- RtlZeroMemory(Miniport, sizeof(MINIPORT_DRIVER));
+ RtlZeroMemory(Miniport, sizeof(NDIS_M_DRIVER_BLOCK));
KeInitializeSpinLock(&Miniport->Lock);
- Miniport->RefCount = 1;
-
Miniport->DriverObject = (PDRIVER_OBJECT)SystemSpecific1;
/* set the miniport's driver registry path */
RegistryPath->Buffer = RegistryBuffer;
Miniport->RegistryPath = RegistryPath;
- InitializeListHead(&Miniport->AdapterListHead);
+ InitializeListHead(&Miniport->DeviceList);
/* Put miniport in global miniport list */
ExInterlockedInsertTailList(&MiniportListHead, &Miniport->ListEntry, &MiniportListLock);
}
\f
-VOID STDCALL NdisIBugcheckCallback(
+VOID NTAPI NdisIBugcheckCallback(
IN PVOID Buffer,
IN ULONG Length)
/*
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
/* Get MAC options for adapter */
- NdisStatus = MiniQueryInformation(Adapter, OID_GEN_MAC_OPTIONS, 0, &BytesWritten);
+ NdisStatus = MiniQueryInformation(Adapter, OID_GEN_MAC_OPTIONS, sizeof(UINT),
+ &Adapter->NdisMiniportBlock.MacOptions,
+ &BytesWritten);
if (NdisStatus != NDIS_STATUS_SUCCESS)
{
return NdisStatus;
}
- RtlCopyMemory(&Adapter->NdisMiniportBlock.MacOptions, Adapter->QueryBuffer, sizeof(UINT));
-
NDIS_DbgPrint(DEBUG_MINIPORT, ("MacOptions (0x%X).\n", Adapter->NdisMiniportBlock.MacOptions));
/* Get current hardware address of adapter */
- NdisStatus = MiniQueryInformation(Adapter, AddressOID, 0, &BytesWritten);
+ NdisStatus = MiniQueryInformation(Adapter, AddressOID, Adapter->AddressLength,
+ &Adapter->Address, &BytesWritten);
if (NdisStatus != NDIS_STATUS_SUCCESS)
{
return NdisStatus;
}
- RtlCopyMemory(&Adapter->Address, Adapter->QueryBuffer, Adapter->AddressLength);
#ifdef DBG
{
/* 802.3 only */
#endif /* DBG */
/* Get maximum lookahead buffer size of adapter */
- NdisStatus = MiniQueryInformation(Adapter, OID_GEN_MAXIMUM_LOOKAHEAD, 0, &BytesWritten);
+ NdisStatus = MiniQueryInformation(Adapter, OID_GEN_MAXIMUM_LOOKAHEAD, sizeof(ULONG),
+ &Adapter->NdisMiniportBlock.MaximumLookahead, &BytesWritten);
if (NdisStatus != NDIS_STATUS_SUCCESS)
{
return NdisStatus;
}
- Adapter->NdisMiniportBlock.MaximumLookahead = *((PULONG)Adapter->QueryBuffer);
-
NDIS_DbgPrint(DEBUG_MINIPORT, ("MaxLookaheadLength (0x%X).\n", Adapter->NdisMiniportBlock.MaximumLookahead));
/* Get current lookahead buffer size of adapter */
- NdisStatus = MiniQueryInformation(Adapter, OID_GEN_CURRENT_LOOKAHEAD, 0, &BytesWritten);
+ NdisStatus = MiniQueryInformation(Adapter, OID_GEN_CURRENT_LOOKAHEAD, sizeof(ULONG),
+ &Adapter->NdisMiniportBlock.CurrentLookahead, &BytesWritten);
if (NdisStatus != NDIS_STATUS_SUCCESS)
{
return NdisStatus;
}
- Adapter->NdisMiniportBlock.CurrentLookahead = *((PULONG)Adapter->QueryBuffer);
-
NDIS_DbgPrint(DEBUG_MINIPORT, ("CurLookaheadLength (0x%X).\n", Adapter->NdisMiniportBlock.CurrentLookahead));
if (Adapter->NdisMiniportBlock.MaximumLookahead != 0)
\f
NTSTATUS
-STDCALL
+NTAPI
NdisIForwardIrpAndWaitCompletionRoutine(
PDEVICE_OBJECT Fdo,
PIRP Irp,
\f
NTSTATUS
-STDCALL
+NTAPI
NdisIForwardIrpAndWait(PLOGICAL_ADAPTER Adapter, PIRP Irp)
{
KEVENT Event;
\f
NTSTATUS
-STDCALL
+NTAPI
NdisIPnPStartDevice(
IN PDEVICE_OBJECT DeviceObject,
PIRP Irp)
Status = IoGetDeviceProperty(Adapter->NdisMiniportBlock.PhysicalDeviceObject,
DevicePropertyLegacyBusType, Size,
&Adapter->NdisMiniportBlock.BusType, &Size);
- if (!NT_SUCCESS(Status) || Adapter->NdisMiniportBlock.BusType == -1)
+ if (!NT_SUCCESS(Status) || (INTERFACE_TYPE)Adapter->NdisMiniportBlock.BusType == InterfaceTypeUndefined)
{
NdisInitUnicodeString(&ParamName, L"BusType");
NdisReadConfiguration(&NdisStatus, &ConfigParam, ConfigHandle,
Status = IoGetDeviceProperty(Adapter->NdisMiniportBlock.PhysicalDeviceObject,
DevicePropertyBusNumber, Size,
&Adapter->NdisMiniportBlock.BusNumber, &Size);
- if (!NT_SUCCESS(Status) || Adapter->NdisMiniportBlock.BusNumber == -1)
+ if (!NT_SUCCESS(Status) || Adapter->NdisMiniportBlock.BusNumber == 0xFFFFFFF0)
{
NdisInitUnicodeString(&ParamName, L"BusNumber");
NdisReadConfiguration(&NdisStatus, &ConfigParam, ConfigHandle,
Status = IoGetDeviceProperty(Adapter->NdisMiniportBlock.PhysicalDeviceObject,
DevicePropertyAddress, Size,
&Adapter->NdisMiniportBlock.SlotNumber, &Size);
- if (!NT_SUCCESS(Status) || Adapter->NdisMiniportBlock.SlotNumber == -1)
+ if (!NT_SUCCESS(Status) || Adapter->NdisMiniportBlock.SlotNumber == (NDIS_INTERFACE_TYPE)-1)
{
NdisInitUnicodeString(&ParamName, L"SlotNumber");
NdisReadConfiguration(&NdisStatus, &ConfigParam, ConfigHandle,
*/
NDIS_DbgPrint(MID_TRACE, ("calling MiniportInitialize\n"));
- NdisStatus = (*Adapter->Miniport->Chars.InitializeHandler)(
+ NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.InitializeHandler)(
&OpenErrorStatus, &SelectedMediumIndex, &MediaArray[0],
MEDIA_ARRAY_SIZE, Adapter, (NDIS_HANDLE)&WrapperContext);
{
Success = EthCreateFilter(32, /* FIXME: Query this from miniport. */
Adapter->Address.Type.Medium802_3,
- &Adapter->NdisMiniportBlock.FilterDbs.EthDB);
+ &Adapter->NdisMiniportBlock.EthDB);
if (Success)
- Adapter->NdisMiniportBlock.FilterDbs.EthDB->Miniport = (PNDIS_MINIPORT_BLOCK)Adapter;
+ ((PETHI_FILTER)Adapter->NdisMiniportBlock.EthDB)->Miniport = (PNDIS_MINIPORT_BLOCK)Adapter;
else
NdisStatus = NDIS_STATUS_RESOURCES;
}
Adapter->NdisMiniportBlock.PnPDeviceState = NdisPnPDeviceStarted;
/* Put adapter in adapter list for this miniport */
- ExInterlockedInsertTailList(&Adapter->Miniport->AdapterListHead, &Adapter->MiniportListEntry, &Adapter->Miniport->Lock);
+ ExInterlockedInsertTailList(&Adapter->NdisMiniportBlock.DriverHandle->DeviceList, &Adapter->MiniportListEntry, &Adapter->NdisMiniportBlock.DriverHandle->Lock);
/* Put adapter in global adapter list */
ExInterlockedInsertTailList(&AdapterListHead, &Adapter->ListEntry, &AdapterListLock);
\f
NTSTATUS
-STDCALL
+NTAPI
NdisIPnPStopDevice(
IN PDEVICE_OBJECT DeviceObject,
PIRP Irp)
KIRQL OldIrql;
/* Remove adapter from adapter list for this miniport */
- KeAcquireSpinLock(&Adapter->Miniport->Lock, &OldIrql);
+ KeAcquireSpinLock(&Adapter->NdisMiniportBlock.DriverHandle->Lock, &OldIrql);
RemoveEntryList(&Adapter->MiniportListEntry);
- KeReleaseSpinLock(&Adapter->Miniport->Lock, OldIrql);
+ KeReleaseSpinLock(&Adapter->NdisMiniportBlock.DriverHandle->Lock, OldIrql);
/* Remove adapter from global adapter list */
KeAcquireSpinLock(&AdapterListLock, &OldIrql);
RemoveEntryList(&Adapter->ListEntry);
KeReleaseSpinLock(&AdapterListLock, OldIrql);
- (*Adapter->Miniport->Chars.HaltHandler)(Adapter);
+ (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.HaltHandler)(Adapter);
if (Adapter->LookaheadBuffer)
{
\f
NTSTATUS
-STDCALL
+NTAPI
NdisIDispatchPnp(
IN PDEVICE_OBJECT DeviceObject,
PIRP Irp)
break;
case IRP_MN_STOP_DEVICE:
- /* FIXME */
- Status = STATUS_UNSUCCESSFUL;
- break;
Status = NdisIForwardIrpAndWait(Adapter, Irp);
if (NT_SUCCESS(Status) && NT_SUCCESS(Irp->IoStatus.Status))
{
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
+ case IRP_MN_QUERY_DEVICE_RELATIONS:
+ Status = STATUS_NOT_SUPPORTED;
+ Irp->IoStatus.Status = Status;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ break;
+
default:
IoSkipCurrentIrpStackLocation(Irp);
Status = IoCallDriver(Adapter->NdisMiniportBlock.NextDeviceObject, Irp);
\f
NTSTATUS
-STDCALL
+NTAPI
NdisIAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject)
{
static const WCHAR ClassKeyName[] = {'C','l','a','s','s','\\'};
static const WCHAR LinkageKeyName[] = {'\\','L','i','n','k','a','g','e',0};
- PMINIPORT_DRIVER Miniport;
- PMINIPORT_DRIVER *MiniportPtr;
+ PNDIS_M_DRIVER_BLOCK Miniport;
+ PNDIS_M_DRIVER_BLOCK *MiniportPtr;
WCHAR *LinkageKeyBuffer;
ULONG DriverKeyLength;
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
KeInitializeSpinLock(&Adapter->NdisMiniportBlock.Lock);
InitializeListHead(&Adapter->ProtocolListHead);
- Adapter->RefCount = 1;
- Adapter->Miniport = Miniport;
+ Adapter->NdisMiniportBlock.DriverHandle = Miniport;
Adapter->NdisMiniportBlock.MiniportName = ExportName;
Adapter->NdisMiniportBlock.OldPnPDeviceState = 0;
Adapter->NdisMiniportBlock.PnPDeviceState = NdisPnPDeviceAdded;
- KeInitializeDpc(&Adapter->MiniportDpc, MiniportDpc, (PVOID)Adapter);
+ KeInitializeDpc(&Adapter->NdisMiniportBlock.DeferredDpc, MiniportDpc, (PVOID)Adapter);
DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
*/
{
UINT MinSize;
- PMINIPORT_DRIVER Miniport = GET_MINIPORT_DRIVER(NdisWrapperHandle);
- PMINIPORT_DRIVER *MiniportPtr;
+ PNDIS_M_DRIVER_BLOCK Miniport = GET_MINIPORT_DRIVER(NdisWrapperHandle);
+ PNDIS_M_DRIVER_BLOCK *MiniportPtr;
NTSTATUS Status;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
/* TODO: verify NDIS5 and NDIS5.1 */
- RtlCopyMemory(&Miniport->Chars, MiniportCharacteristics, MinSize);
+ RtlCopyMemory(&Miniport->MiniportCharacteristics, MiniportCharacteristics, MinSize);
/*
- * NOTE: This is VERY unoptimal! Should we store the MINIPORT_DRIVER
- * struture in the driver extension or what?
+ * NOTE: This is VERY unoptimal! Should we store the NDIS_M_DRIVER_BLOCK
+ * structure in the driver extension or what?
*/
Status = IoAllocateDriverObjectExtension(Miniport->DriverObject, (PVOID)TAG('D','I','M','N'),
- sizeof(PMINIPORT_DRIVER), (PVOID*)&MiniportPtr);
+ sizeof(PNDIS_M_DRIVER_BLOCK), (PVOID*)&MiniportPtr);
if (!NT_SUCCESS(Status))
{
NDIS_DbgPrint(DEBUG_MINIPORT, ("Can't allocate driver object extension.\n"));
/*
* @implemented
*/
+#undef NdisMResetComplete
VOID
EXPORT
NdisMResetComplete(
/*
* @implemented
*/
+#undef NdisMSendComplete
VOID
EXPORT
NdisMSendComplete(
/*
* @implemented
*/
+#undef NdisMSendResourcesAvailable
VOID
EXPORT
NdisMSendResourcesAvailable(
/*
* @implemented
*/
+#undef NdisMTransferDataComplete
VOID
EXPORT
NdisMTransferDataComplete(
MiniTransferDataComplete(MiniportAdapterHandle, Packet, Status, BytesTransferred);
}
-#undef NdisMSetInformationComplete
-
\f
/*
* @implemented
*/
+#undef NdisMSetInformationComplete
VOID
EXPORT
NdisMSetInformationComplete(
(*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->SetCompleteHandler)(MiniportAdapterHandle, Status);
}
-#undef NdisMSetAttributes
-
\f
/*
* @implemented
*/
+#undef NdisMSetAttributes
VOID
EXPORT
NdisMSetAttributes(
Adapter->NdisMiniportBlock.MiniportAdapterContext = MiniportAdapterContext;
Adapter->NdisMiniportBlock.Flags = AttributeFlags;
Adapter->NdisMiniportBlock.AdapterType = AdapterType;
- Adapter->AttributesSet = TRUE;
if (AttributeFlags & NDIS_ATTRIBUTE_INTERMEDIATE_DRIVER)
NDIS_DbgPrint(MAX_TRACE, ("Intermediate drivers not supported yet.\n"));
}
/*
* FUNCTION: Releases resources allocated by a call to NdisInitializeWrapper
* ARGUMENTS:
- * NdisWrapperHandle = Handle returned by NdisInitializeWrapper (MINIPORT_DRIVER)
+ * NdisWrapperHandle = Handle returned by NdisInitializeWrapper (NDIS_M_DRIVER_BLOCK)
* SystemSpecific = Always NULL
*/
{
- PMINIPORT_DRIVER Miniport = GET_MINIPORT_DRIVER(NdisWrapperHandle);
+ PNDIS_M_DRIVER_BLOCK Miniport = GET_MINIPORT_DRIVER(NdisWrapperHandle);
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));