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)
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;
#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;
NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
NdisRequest = ExAllocatePool(NonPagedPool, sizeof(NDIS_REQUEST));
- if (!NdisRequest) return NDIS_STATUS_RESOURCES;
+ if (!NdisRequest) {
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
+ return NDIS_STATUS_RESOURCES;
+ }
RtlZeroMemory(NdisRequest, sizeof(NDIS_REQUEST));
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 (MiniIsBusy(Adapter, NdisWorkItemResetRequested)) {
MiniQueueWorkItem(Adapter, NdisWorkItemResetRequested, NULL, FALSE);
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
Status = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.ResetHandler)(
Adapter->NdisMiniportBlock.MiniportAdapterContext,
- AddressingReset);
+ &AddressingReset);
KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
Adapter->NdisMiniportBlock.ResetStatus = Status;
KeLowerIrql(OldIrql);
if (Status != NDIS_STATUS_PENDING) {
+ if (AddressingReset)
+ MiniDoAddressingReset(Adapter);
+
NdisMIndicateStatus(Adapter, NDIS_STATUS_RESET_END, NULL, 0);
NdisMIndicateStatusComplete(Adapter);
}
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
}
else
{
+ NDIS_DbgPrint(MIN_TRACE, ("No work item to dequeue\n"));
+
return NDIS_STATUS_FAILURE;
}
}
break;
default:
+ NDIS_DbgPrint(MIN_TRACE, ("Bad request type\n"));
Status = NDIS_STATUS_FAILURE;
}
}
Adapter->NdisMiniportBlock.MiniportAdapterContext,
&AddressingReset);
- if (NdisStatus == NDIS_STATUS_PENDING)
- {
- KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
- Adapter->NdisMiniportBlock.ResetStatus = NDIS_STATUS_PENDING;
- KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
- }
+ KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+ Adapter->NdisMiniportBlock.ResetStatus = NdisStatus;
+ KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
KeLowerIrql(OldIrql);
*NdisWrapperHandle = NULL;
#if BREAK_ON_MINIPORT_INIT
- __asm__ ("int $3\n");
+ DbgBreakPoint();
#endif
Miniport = ExAllocatePool(NonPagedPool, sizeof(NDIS_M_DRIVER_BLOCK));
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
LARGE_INTEGER Timeout;
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;
}
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;
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,
{
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;
}
if (NdisStatus != NDIS_STATUS_SUCCESS)
{
ExInterlockedRemoveEntryList( &Adapter->ListEntry, &AdapterListLock );
- NDIS_DbgPrint(MAX_TRACE, ("MiniQueryInformation failed (%x)\n", NdisStatus));
+ NDIS_DbgPrint(MIN_TRACE, ("MiniQueryInformation failed (%x)\n", NdisStatus));
return NdisStatus;
}
/* 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));
+ NDIS_DbgPrint(MIN_TRACE, ("couldn't create filter (%x)\n", NdisStatus));
return NdisStatus;
}
/* 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;
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
NDIS_STATUS Status = STATUS_NOT_SUPPORTED;
+ ULONG Written;
Irp->IoStatus.Information = 0;
*(PNDIS_OID)Irp->AssociatedIrp.SystemBuffer,
Stack->Parameters.DeviceIoControl.OutputBufferLength,
MmGetSystemAddressForMdl(Irp->MdlAddress),
- &Irp->IoStatus.Information);
+ &Written);
+ Irp->IoStatus.Information = Written;
break;
default:
{
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;
* 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;
}
* 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;
AdapterName.Length = 0;
AdapterName.MaximumLength = Adapter->NdisMiniportBlock.MiniportName.MaximumLength;
AdapterName.Buffer = ExAllocatePool(PagedPool, AdapterName.MaximumLength);
- if (!AdapterName.Buffer)
+ if (!AdapterName.Buffer) {
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
return NDIS_STATUS_RESOURCES;
+ }
RtlCopyUnicodeString(&AdapterName, &Adapter->NdisMiniportBlock.MiniportName);
if (!NT_SUCCESS(Status))
{
+ NDIS_DbgPrint(MIN_TRACE, ("IoCreateDevice failed (%x)\n", Status));
return Status;
}
if (!NT_SUCCESS(Status))
{
+ NDIS_DbgPrint(MIN_TRACE, ("IoCreateSymbolicLink failed (%x)\n", Status));
IoDeleteDevice(DeviceObject);
return Status;
}
if (!DeviceBlock)
{
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
IoDeleteDevice(DeviceObject);
IoDeleteSymbolicLink(SymbolicName);
return NDIS_STATUS_RESOURCES;
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;