* 20 Aug 2003 vizzini - DMA support
* 3 Oct 2003 vizzini - SendPackets support
*/
-#include <roscfg.h>
+
#include "ndissys.h"
#include "efilter.h"
*/
#define BREAK_ON_MINIPORT_INIT 0
-/*
+/*
* This has to be big enough to hold the results of querying the Route value
* from the Linkage key. Please re-code me to determine this dynamically.
*/
/* Number of media we know */
#define MEDIA_ARRAY_SIZE 15
-static NDIS_MEDIUM MediaArray[MEDIA_ARRAY_SIZE] =
+static NDIS_MEDIUM MediaArray[MEDIA_ARRAY_SIZE] =
{
NdisMedium802_3,
NdisMedium802_5,
/* KIRQL OldIrql; */
PLIST_ENTRY CurrentEntry;
PADAPTER_BINDING AdapterBinding;
-
+
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called. Adapter (0x%X) HeaderBuffer (0x%X) "
"HeaderBufferSize (0x%X) LookaheadBuffer (0x%X) LookaheadBufferSize (0x%X).\n",
Adapter, HeaderBuffer, HeaderBufferSize, LookaheadBuffer, LookaheadBufferSize));
CurrentEntry = Adapter->ProtocolListHead.Flink;
NDIS_DbgPrint(DEBUG_MINIPORT, ("CurrentEntry = %x\n", CurrentEntry));
- if (CurrentEntry == &Adapter->ProtocolListHead)
+ if (CurrentEntry == &Adapter->ProtocolListHead)
{
NDIS_DbgPrint(DEBUG_MINIPORT, ("WARNING: No upper protocol layer.\n"));
}
- while (CurrentEntry != &Adapter->ProtocolListHead)
+ while (CurrentEntry != &Adapter->ProtocolListHead)
{
AdapterBinding = CONTAINING_RECORD(CurrentEntry, ADAPTER_BINDING, AdapterListEntry);
NDIS_DbgPrint(DEBUG_MINIPORT, ("AdapterBinding = %x\n", AdapterBinding));
#endif
NDIS_DbgPrint
- (MID_TRACE,
+ (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 PADAPTER_BINDING AdapterBinding,
+ IN PNDIS_REQUEST Request,
+ IN NDIS_STATUS Status)
+{
+ NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
+
+ if( AdapterBinding->ProtocolBinding->Chars.RequestCompleteHandler ) {
+ (*AdapterBinding->ProtocolBinding->Chars.RequestCompleteHandler)(
+ AdapterBinding->NdisOpenBlock.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);
}
NdisQueryPacket(Packet, NULL, NULL, &NdisBuffer, NULL);
- if (!NdisBuffer)
+ if (!NdisBuffer)
{
NDIS_DbgPrint(MID_TRACE, ("Packet contains no buffers.\n"));
return FALSE;
/* FIXME: Should handle fragmented packets */
- switch (Adapter->NdisMiniportBlock.MediaType)
+ switch (Adapter->NdisMiniportBlock.MediaType)
{
case NdisMedium802_3:
Length = ETH_LENGTH_OF_ADDRESS;
return FALSE;
}
- if (BufferLength < Length)
+ if (BufferLength < Length)
{
NDIS_DbgPrint(MID_TRACE, ("Buffer is too small.\n"));
return FALSE;
{
CurrentEntry = AdapterListHead.Flink;
- while (CurrentEntry != &AdapterListHead)
+ while (CurrentEntry != &AdapterListHead)
{
Adapter = CONTAINING_RECORD(CurrentEntry, LOGICAL_ADAPTER, ListEntry);
NDIS_DbgPrint(DEBUG_MINIPORT, ("AdapterName = %wZ\n", AdapterName));
NDIS_DbgPrint(DEBUG_MINIPORT, ("DeviceName = %wZ\n", &Adapter->NdisMiniportBlock.MiniportName));
- if (RtlCompareUnicodeString(AdapterName, &Adapter->NdisMiniportBlock.MiniportName, TRUE) == 0)
+ if (RtlCompareUnicodeString(AdapterName, &Adapter->NdisMiniportBlock.MiniportName, TRUE) == 0)
{
ReferenceObject(Adapter);
break;
if(Adapter)
{
- NDIS_DbgPrint(DEBUG_MINIPORT, ("Leaving. Adapter found at 0x%x\n", Adapter));
+ NDIS_DbgPrint(DEBUG_MINIPORT, ("Leaving. Adapter found at 0x%x\n", Adapter));
}
else
{
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
- if (Adapter->QueryBufferLength == 0)
+ if (Adapter->QueryBufferLength == 0)
{
/* XXX is 32 the right number? */
Adapter->QueryBuffer = ExAllocatePool(NonPagedPool, (Size == 0)? 32 : Size);
- if (!Adapter->QueryBuffer)
+ if (!Adapter->QueryBuffer)
{
NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return NDIS_STATUS_RESOURCES;
&BytesNeeded);
/* XXX is status_pending part of success macro? */
- if ((NT_SUCCESS(NdisStatus)) || (NdisStatus == NDIS_STATUS_PENDING))
+ if ((NT_SUCCESS(NdisStatus)) || (NdisStatus == NDIS_STATUS_PENDING))
{
NDIS_DbgPrint(DEBUG_MINIPORT, ("Miniport returned status (0x%X).\n", NdisStatus));
return NdisStatus;
}
- if (NdisStatus == NDIS_STATUS_INVALID_LENGTH)
+ if (NdisStatus == NDIS_STATUS_INVALID_LENGTH)
{
ExFreePool(Adapter->QueryBuffer);
Adapter->QueryBufferLength += BytesNeeded;
Adapter->QueryBuffer = ExAllocatePool(NonPagedPool, Adapter->QueryBufferLength);
- if (!Adapter->QueryBuffer)
+ if (!Adapter->QueryBuffer)
{
NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return NDIS_STATUS_RESOURCES;
Adapter->NdisMiniportBlock.MiniportAdapterContext,
Oid,
Adapter->QueryBuffer,
- Size,
+ Adapter->QueryBufferLength,
BytesWritten,
&BytesNeeded);
}
NDIS_STATUS
FASTCALL
MiniQueueWorkItem(
- PLOGICAL_ADAPTER Adapter,
+ PADAPTER_BINDING AdapterBinding,
NDIS_WORK_ITEM_TYPE WorkItemType,
PVOID WorkItemContext)
/*
* Status of operation
*/
{
- PNDIS_MINIPORT_WORK_ITEM Item;
-
- NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
-
- ASSERT(Adapter);
- ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
+ PINTERNAL_NDIS_MINIPORT_WORK_ITEM Item;
+ PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
+ NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+ ASSERT(Adapter);
+ ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
+
#if 0
- if (Adapter->WorkQueueLevel < NDIS_MINIPORT_WORK_QUEUE_SIZE - 1)
+ if (Adapter->WorkQueueLevel < NDIS_MINIPORT_WORK_QUEUE_SIZE - 1)
{
- Item = &Adapter->WorkQueue[Adapter->WorkQueueLevel];
- Adapter->WorkQueueLevel++;
- }
- else
+ Item = &Adapter->WorkQueue[Adapter->WorkQueueLevel];
+ Adapter->WorkQueueLevel++;
+ }
+ else
#endif
{
- Item = ExAllocatePool(NonPagedPool, sizeof(NDIS_MINIPORT_WORK_ITEM));
- if (Item == NULL)
+ Item = ExAllocatePool(NonPagedPool, sizeof(INTERNAL_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->AdapterBinding = AdapterBinding;
+ Item->RealWorkItem.WorkItemType = WorkItemType;
+ Item->RealWorkItem.WorkItemContext = WorkItemContext;
+
+ /* safe due to adapter lock held */
+ Item->Link.Next = NULL;
+ if (!Adapter->WorkQueueHead)
{
- Adapter->WorkQueueHead = Item;
- Adapter->WorkQueueTail = Item;
- }
- else
+ Adapter->WorkQueueHead = Item;
+ Adapter->WorkQueueTail = Item;
+ }
+ 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->MiniportDpc, NULL, NULL);
+
+ return NDIS_STATUS_SUCCESS;
}
\f
FASTCALL
MiniDequeueWorkItem(
PLOGICAL_ADAPTER Adapter,
+ PADAPTER_BINDING *AdapterBinding,
NDIS_WORK_ITEM_TYPE *WorkItemType,
PVOID *WorkItemContext)
/*
* 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)
+ PINTERNAL_NDIS_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 = (PINTERNAL_NDIS_MINIPORT_WORK_ITEM)Item->Link.Next;
+
+ if (Item == Adapter->WorkQueueTail)
+ Adapter->WorkQueueTail = NULL;
+
+ *AdapterBinding = Item->AdapterBinding;
+ *WorkItemType = Item->RealWorkItem.WorkItemType;
+ *WorkItemContext = Item->RealWorkItem.WorkItemContext;
+
+ ExFreePool(Item);
+
+ return NDIS_STATUS_SUCCESS;
}
-
- return NDIS_STATUS_FAILURE;
+
+ return NDIS_STATUS_FAILURE;
}
\f
NDIS_STATUS
MiniDoRequest(
- PLOGICAL_ADAPTER Adapter,
+ PADAPTER_BINDING AdapterBinding,
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;
+ PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
- switch (NdisRequest->RequestType)
+ NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
+
+ Adapter->NdisMiniportBlock.MediaRequest = NdisRequest;
+
+ switch (NdisRequest->RequestType)
{
- case NdisRequestQueryInformation:
+ case NdisRequestQueryInformation:
return (*Adapter->Miniport->Chars.QueryInformationHandler)(
Adapter->NdisMiniportBlock.MiniportAdapterContext,
NdisRequest->DATA.QUERY_INFORMATION.Oid,
(PULONG)&NdisRequest->DATA.QUERY_INFORMATION.BytesWritten,
(PULONG)&NdisRequest->DATA.QUERY_INFORMATION.BytesNeeded);
break;
-
- case NdisRequestSetInformation:
+
+ case NdisRequestSetInformation:
return (*Adapter->Miniport->Chars.SetInformationHandler)(
Adapter->NdisMiniportBlock.MiniportAdapterContext,
NdisRequest->DATA.SET_INFORMATION.Oid,
(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(
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_STATUS Status)
{
- PNDIS_MINIPORT_BLOCK MiniportBlock =
+ PNDIS_MINIPORT_BLOCK MiniportBlock =
(PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle;
ASSERT(MiniportBlock);
if( MiniportBlock->QueryCompleteHandler )
}
\f
-VOID STDCALL MiniportDpc(
+VOID NTAPI MiniportDpc(
IN PKDPC Dpc,
IN PVOID DeferredContext,
IN PVOID SystemArgument1,
NDIS_STATUS NdisStatus;
PVOID WorkItemContext;
NDIS_WORK_ITEM_TYPE WorkItemType;
+ PADAPTER_BINDING AdapterBinding;
PLOGICAL_ADAPTER Adapter = GET_LOGICAL_ADAPTER(DeferredContext);
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
- NdisStatus = MiniDequeueWorkItem(Adapter, &WorkItemType, &WorkItemContext);
+ NdisStatus =
+ MiniDequeueWorkItem
+ (Adapter, &AdapterBinding, &WorkItemType, &WorkItemContext);
- if (NdisStatus == NDIS_STATUS_SUCCESS)
+ if (NdisStatus == NDIS_STATUS_SUCCESS)
{
- switch (WorkItemType)
+ switch (WorkItemType)
{
case NdisWorkItemSend:
/*
*/
(*Adapter->Miniport->Chars.SendPacketsHandler)(
Adapter->NdisMiniportBlock.MiniportAdapterContext, (PPNDIS_PACKET)&WorkItemContext, 1);
- NdisStatus =
+ NdisStatus =
NDIS_GET_PACKET_STATUS((PNDIS_PACKET)WorkItemContext);
NDIS_DbgPrint(MAX_TRACE, ("back from miniport's SendPackets handler\n"));
case NdisWorkItemResetInProgress:
break;
- case NdisWorkItemHalt:
- break;
-
case NdisWorkItemMiniportCallback:
break;
case NdisWorkItemRequest:
- NdisStatus = MiniDoRequest(Adapter, (PNDIS_REQUEST)WorkItemContext);
+ NdisStatus = MiniDoRequest(AdapterBinding, (PNDIS_REQUEST)WorkItemContext);
if (NdisStatus == NDIS_STATUS_PENDING)
break;
- switch (((PNDIS_REQUEST)WorkItemContext)->RequestType)
+ switch (((PNDIS_REQUEST)WorkItemContext)->RequestType)
{
case NdisRequestQueryInformation:
NdisMQueryInformationComplete((NDIS_HANDLE)Adapter, NdisStatus);
+ MiniRequestComplete( AdapterBinding, (PNDIS_REQUEST)WorkItemContext, NdisStatus );
break;
case NdisRequestSetInformation:
NdisMSetInformationComplete((NDIS_HANDLE)Adapter, NdisStatus);
+ MiniRequestComplete( AdapterBinding, (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(
Miniport = ExAllocatePool(NonPagedPool, sizeof(MINIPORT_DRIVER));
- if (!Miniport)
+ if (!Miniport)
{
NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return;
}
\f
-VOID STDCALL NdisIBugcheckCallback(
+VOID NTAPI NdisIBugcheckCallback(
IN PVOID Buffer,
IN ULONG Length)
/*
if(sh)
sh(Context->DriverContext);
-}
+}
\f
/*
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
- if(BugcheckContext)
+ if(BugcheckContext)
return;
BugcheckContext = ExAllocatePool(NonPagedPool, sizeof(MINIPORT_BUGCHECK_CONTEXT));
/* not sure if this needs to be initialized or not... oh well, it's a leak. */
BugcheckContext->CallbackRecord = ExAllocatePool(NonPagedPool, sizeof(KBUGCHECK_CALLBACK_RECORD));
- KeRegisterBugCheckCallback(BugcheckContext->CallbackRecord, NdisIBugcheckCallback,
+ KeRegisterBugCheckCallback(BugcheckContext->CallbackRecord, NdisIBugcheckCallback,
BugcheckContext, sizeof(BugcheckContext), (PUCHAR)"Ndis Miniport");
}
/* Get MAC options for adapter */
NdisStatus = MiniQueryInformation(Adapter, OID_GEN_MAC_OPTIONS, 0, &BytesWritten);
- if (NdisStatus != NDIS_STATUS_SUCCESS)
+ if (NdisStatus != NDIS_STATUS_SUCCESS)
{
NDIS_DbgPrint(MIN_TRACE, ("OID_GEN_MAC_OPTIONS failed. NdisStatus (0x%X).\n", NdisStatus));
return NdisStatus;
/* Get current hardware address of adapter */
NdisStatus = MiniQueryInformation(Adapter, AddressOID, 0, &BytesWritten);
- if (NdisStatus != NDIS_STATUS_SUCCESS)
+ if (NdisStatus != NDIS_STATUS_SUCCESS)
{
NDIS_DbgPrint(MIN_TRACE, ("Address OID (0x%X) failed. NdisStatus (0x%X).\n", AddressOID, NdisStatus));
return NdisStatus;
/* Get maximum lookahead buffer size of adapter */
NdisStatus = MiniQueryInformation(Adapter, OID_GEN_MAXIMUM_LOOKAHEAD, 0, &BytesWritten);
- if (NdisStatus != NDIS_STATUS_SUCCESS)
+ if (NdisStatus != NDIS_STATUS_SUCCESS)
{
NDIS_DbgPrint(MIN_TRACE, ("OID_GEN_MAXIMUM_LOOKAHEAD failed. NdisStatus (0x%X).\n", NdisStatus));
return NdisStatus;
/* Get current lookahead buffer size of adapter */
NdisStatus = MiniQueryInformation(Adapter, OID_GEN_CURRENT_LOOKAHEAD, 0, &BytesWritten);
- if (NdisStatus != NDIS_STATUS_SUCCESS)
+ if (NdisStatus != NDIS_STATUS_SUCCESS)
{
NDIS_DbgPrint(MIN_TRACE, ("OID_GEN_CURRENT_LOOKAHEAD failed. NdisStatus (0x%X).\n", NdisStatus));
return NdisStatus;
NDIS_DbgPrint(DEBUG_MINIPORT, ("CurLookaheadLength (0x%X).\n", Adapter->NdisMiniportBlock.CurrentLookahead));
- if (Adapter->NdisMiniportBlock.MaximumLookahead != 0)
+ if (Adapter->NdisMiniportBlock.MaximumLookahead != 0)
{
Adapter->LookaheadLength = Adapter->NdisMiniportBlock.MaximumLookahead + Adapter->MediumHeaderSize;
Adapter->LookaheadBuffer = ExAllocatePool(NonPagedPool, Adapter->LookaheadLength);
\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)
NTSTATUS Status;
UINT SelectedMediumIndex = 0;
NDIS_OID AddressOID;
- BOOLEAN Success;
+ BOOLEAN Success = FALSE;
ULONG ResourceCount;
ULONG ResourceListSize;
UNICODE_STRING ParamName;
PNDIS_CONFIGURATION_PARAMETER ConfigParam;
NDIS_HANDLE ConfigHandle;
ULONG Size;
- KIRQL OldIrql;
+/* FIXME - KIRQL OldIrql; */
/*
* Prepare wrapper context used by HW and configuration routines.
*/
-
+
Status = IoOpenDeviceRegistryKey(
Adapter->NdisMiniportBlock.PhysicalDeviceObject, PLUGPLAY_REGKEY_DRIVER,
KEY_ALL_ACCESS, &WrapperContext.RegistryHandle);
{
ResourceCount = Stack->Parameters.StartDevice.AllocatedResources->List[0].
PartialResourceList.Count;
- ResourceListSize =
+ ResourceListSize =
FIELD_OFFSET(CM_RESOURCE_LIST, List[0].PartialResourceList.
PartialDescriptors[ResourceCount]);
RtlCopyMemory(Adapter->NdisMiniportBlock.AllocatedResources,
Stack->Parameters.StartDevice.AllocatedResources,
ResourceListSize);
-
+
RtlCopyMemory(Adapter->NdisMiniportBlock.AllocatedResourcesTranslated,
Stack->Parameters.StartDevice.AllocatedResourcesTranslated,
ResourceListSize);
* Store the Bus Type, Bus Number and Slot information. It's used by
* the hardware routines then.
*/
-
+
NdisOpenConfiguration(&NdisStatus, &ConfigHandle, (NDIS_HANDLE)&WrapperContext);
Size = sizeof(ULONG);
Status = IoGetDeviceProperty(Adapter->NdisMiniportBlock.PhysicalDeviceObject,
DevicePropertyLegacyBusType, Size,
&Adapter->NdisMiniportBlock.BusType, &Size);
- if (!NT_SUCCESS(Status) || Adapter->NdisMiniportBlock.BusType == -1)
+ if (!NT_SUCCESS(Status) || Adapter->NdisMiniportBlock.BusType == (NDIS_INTERFACE_TYPE)-1)
{
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 == (NDIS_INTERFACE_TYPE)-1)
{
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,
ZwClose(WrapperContext.RegistryHandle);
if (NdisStatus != NDIS_STATUS_SUCCESS ||
- SelectedMediumIndex >= MEDIA_ARRAY_SIZE)
+ SelectedMediumIndex >= MEDIA_ARRAY_SIZE)
{
NDIS_DbgPrint(MIN_TRACE, ("MiniportInitialize() failed for an adapter.\n"));
return (NTSTATUS)NdisStatus;
Adapter->NdisMiniportBlock.MediaType = MediaArray[SelectedMediumIndex];
- switch (Adapter->NdisMiniportBlock.MediaType)
+ switch (Adapter->NdisMiniportBlock.MediaType)
{
case NdisMedium802_3:
Adapter->MediumHeaderSize = 14; /* XXX figure out what to do about LLC */
{
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;
}
/* FIXME: Support other types of media */
NDIS_DbgPrint(MIN_TRACE, ("error: unsupported media\n"));
ASSERT(FALSE);
- KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+/* FIXME - KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql); */
return STATUS_UNSUCCESSFUL;
}
- if (!Success || NdisStatus != NDIS_STATUS_SUCCESS)
+ if (!Success || NdisStatus != NDIS_STATUS_SUCCESS)
{
NDIS_DbgPrint(MAX_TRACE, ("couldn't create filter (%x)\n", NdisStatus));
if (Adapter->LookaheadBuffer)
\f
NTSTATUS
-STDCALL
+NTAPI
NdisIPnPStopDevice(
IN PDEVICE_OBJECT DeviceObject,
PIRP Irp)
\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))
default:
IoSkipCurrentIrpStackLocation(Irp);
- return IoCallDriver(Adapter->NdisMiniportBlock.NextDeviceObject, Irp);
+ Status = IoCallDriver(Adapter->NdisMiniportBlock.NextDeviceObject, Irp);
+ break;
}
return Status;
\f
NTSTATUS
-STDCALL
+NTAPI
NdisIAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject)
* gathered by IoGetDeviceProperty. I choosed the second because
* IoOpenDriverRegistryKey wasn't implemented at the time of writing.
*/
-
+
Status = IoGetDeviceProperty(PhysicalDeviceObject, DevicePropertyDriverKeyName,
0, NULL, &DriverKeyLength);
if (Status != STATUS_BUFFER_TOO_SMALL)
/*
* Create the device object.
*/
-
+
NDIS_DbgPrint(MAX_TRACE, ("creating device %wZ\n", &ExportName));
Status = IoCreateDevice(Miniport->DriverObject, sizeof(LOGICAL_ADAPTER),
&ExportName, FILE_DEVICE_PHYSICAL_NETCARD,
0, FALSE, &DeviceObject);
- if (!NT_SUCCESS(Status))
+ if (!NT_SUCCESS(Status))
{
NDIS_DbgPrint(MIN_TRACE, ("Could not create device object.\n"));
RtlFreeUnicodeString(&ExportName);
Adapter->NdisMiniportBlock.OldPnPDeviceState = 0;
Adapter->NdisMiniportBlock.PnPDeviceState = NdisPnPDeviceAdded;
-
+
KeInitializeDpc(&Adapter->MiniportDpc, MiniportDpc, (PVOID)Adapter);
DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
-
+
return STATUS_SUCCESS;
}
* MiniportCharacteristics = Pointer to a buffer with miniport characteristics
* CharacteristicsLength = Number of bytes in characteristics buffer
* RETURNS:
- * Status of operation
+ * Status of operation
*/
{
UINT MinSize;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- switch (MiniportCharacteristics->MajorNdisVersion)
+ switch (MiniportCharacteristics->MajorNdisVersion)
{
case 0x03:
MinSize = sizeof(NDIS30_MINIPORT_CHARACTERISTICS);
return NDIS_STATUS_BAD_VERSION;
}
- if (CharacteristicsLength < MinSize)
+ if (CharacteristicsLength < MinSize)
{
NDIS_DbgPrint(DEBUG_MINIPORT, ("Bad miniport characteristics.\n"));
return NDIS_STATUS_BAD_CHARACTERISTICS;
(!MiniportCharacteristics->InitializeHandler)||
(!MiniportCharacteristics->QueryInformationHandler) ||
(!MiniportCharacteristics->ResetHandler) ||
- (!MiniportCharacteristics->SetInformationHandler))
+ (!MiniportCharacteristics->SetInformationHandler))
{
NDIS_DbgPrint(DEBUG_MINIPORT, ("Bad miniport characteristics.\n"));
return NDIS_STATUS_BAD_CHARACTERISTICS;
}
- if (MiniportCharacteristics->MajorNdisVersion == 0x03)
+ if (MiniportCharacteristics->MajorNdisVersion == 0x03)
{
- if (!MiniportCharacteristics->SendHandler)
+ if (!MiniportCharacteristics->SendHandler)
{
NDIS_DbgPrint(DEBUG_MINIPORT, ("Bad miniport characteristics.\n"));
return NDIS_STATUS_BAD_CHARACTERISTICS;
}
- }
- else if (MiniportCharacteristics->MajorNdisVersion >= 0x04)
+ }
+ else if (MiniportCharacteristics->MajorNdisVersion >= 0x04)
{
/* NDIS 4.0+ */
if ((!MiniportCharacteristics->SendHandler) &&
- (!MiniportCharacteristics->SendPacketsHandler))
+ (!MiniportCharacteristics->SendPacketsHandler))
{
NDIS_DbgPrint(DEBUG_MINIPORT, ("Bad miniport characteristics.\n"));
return NDIS_STATUS_BAD_CHARACTERISTICS;
/*
* @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(
projects / reactos.git / blobdiff