/**********************************************************
Deregister driver
Clean up WPP
***********************************************************/
static VOID ParaNdis6_Unload(IN PDRIVER_OBJECT pDriverObject)
{
DEBUG_ENTRY(0);
if (DriverHandle) NdisMDeregisterMiniportDriver(DriverHandle);
DEBUG_EXIT_STATUS(2, 0);
ParaNdis_DebugCleanup(pDriverObject);
}
VOID
VenetUnload(PDRIVER_OBJECT obj)
{
UNREFERENCED_PARAMETER(obj);
vlog("unload called\n");
WdfDriverMiniportUnload(WdfGetDriver());
NdisMDeregisterMiniportDriver(mp_handle);
}
VOID
TapDriverUnload(
__in PDRIVER_OBJECT DriverObject
)
/*++
Routine Description:
The unload handler is called during driver unload to free up resources
acquired in DriverEntry. This handler is registered in DriverEntry through
NdisMRegisterMiniportDriver. Note that an unload handler differs from
a MiniportHalt function in that this unload handler releases resources that
are global to the driver, while the halt handler releases resource for a
particular adapter.
Runs at IRQL = PASSIVE_LEVEL.
Arguments:
DriverObject Not used
Return Value:
None.
--*/
{
PDEVICE_OBJECT deviceObject = DriverObject->DeviceObject;
UNICODE_STRING uniWin32NameString;
DEBUGP (("[TAP] --> TapDriverUnload; version [%d.%d] %s %s unloaded\n",
TAP_DRIVER_MAJOR_VERSION,
TAP_DRIVER_MINOR_VERSION,
__DATE__,
__TIME__
));
PAGED_CODE();
//
// Clean up all globals that were allocated in DriverEntry
//
ASSERT(IsListEmpty(&GlobalData.AdapterList));
if(GlobalData.NdisDriverHandle != NULL )
{
NdisMDeregisterMiniportDriver(GlobalData.NdisDriverHandle);
}
DEBUGP (("[TAP] <-- TapDriverUnload\n"));
}
VOID
DriverUnload(
PDRIVER_OBJECT DriverObject
)
{
UNREFERENCED_PARAMETER(DriverObject);
MpEntry;
//
// Deregister this miniport from NDIS
//
NdisMDeregisterMiniportDriver(GlobalDriverHandle);
MpExit;
MP_DUMP_LEAKING_BLOCKS();
#if DOT11_TRACE_ENABLED
WPP_CLEANUP(DriverObject);
#endif
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
First entry point to be called, when this driver is loaded.
Register with NDIS as an intermediate driver.
Arguments:
DriverObject - pointer to the system's driver object structure
for this driver
RegistryPath - system's registry path for this driver
Return Value:
STATUS_SUCCESS if all initialization is successful, STATUS_XXX
error code if not.
--*/
{
NDIS_STATUS Status;
NDIS_PROTOCOL_DRIVER_CHARACTERISTICS PChars;
NDIS_MINIPORT_DRIVER_CHARACTERISTICS MChars;
NDIS_HANDLE MiniportDriverContext;
NDIS_HANDLE ProtocolDriverContext;
NDIS_STRING Name;
NdisInitializeListHead(&AdapterList);
NdisInitializeListHead(&VElanList);
MiniportDriverContext=NULL;
ProtocolDriverContext=NULL;
MUX_INIT_MUTEX(&GlobalMutex);
MUX_INIT_MUTEX(&ControlDeviceMutex);
NdisAllocateSpinLock(&GlobalLock);
do
{
//
// Register the miniport with NDIS. Note that it is the
// miniport which was started as a driver and not the protocol.
// Also the miniport must be registered prior to the protocol
// since the protocol's BindAdapter handler can be initiated
// anytime and when it is, it must be ready to
// start driver instances.
//
NdisZeroMemory(&MChars, sizeof(NDIS_MINIPORT_DRIVER_CHARACTERISTICS));
MChars.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
MChars.Header.Size = sizeof(NDIS_MINIPORT_DRIVER_CHARACTERISTICS);
MChars.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_1;
MChars.MajorNdisVersion = MUX_MAJOR_NDIS_VERSION;
MChars.MinorNdisVersion = MUX_MINOR_NDIS_VERSION;
MChars.MajorDriverVersion = MUX_MAJOR_DRIVER_VERSION;
MChars.MinorDriverVersion = MUX_MINOR_DRIVER_VERSION;
MChars.SetOptionsHandler = MpSetOptions;
MChars.InitializeHandlerEx = MPInitialize;
MChars.UnloadHandler = MPUnload;
MChars.HaltHandlerEx = MPHalt;
MChars.OidRequestHandler = MPOidRequest;
MChars.CancelSendHandler = MPCancelSendNetBufferLists;
MChars.DevicePnPEventNotifyHandler = MPDevicePnPEvent;
MChars.ShutdownHandlerEx = MPAdapterShutdown;
MChars.CancelOidRequestHandler = MPCancelOidRequest;
//
// We will disable the check for hang timeout so we do not
// need a check for hang handler!
//
MChars.CheckForHangHandlerEx = NULL;
MChars.ReturnNetBufferListsHandler = MPReturnNetBufferLists;
MChars.SendNetBufferListsHandler = MPSendNetBufferLists;
MChars.PauseHandler = MPPause;
MChars.RestartHandler = MPRestart;
MChars.Flags = NDIS_INTERMEDIATE_DRIVER;
Status = NdisMRegisterMiniportDriver(DriverObject,
RegistryPath,
MiniportDriverContext,
&MChars,
&DriverHandle);
if (Status != NDIS_STATUS_SUCCESS)
{
break;
}
//
// Now register the protocol.
//
NdisZeroMemory(&PChars, sizeof(NDIS_PROTOCOL_DRIVER_CHARACTERISTICS));
PChars.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
PChars.Header.Size = sizeof(NDIS_PROTOCOL_DRIVER_CHARACTERISTICS);
PChars.Header.Revision = NDIS_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_1;
PChars.MajorNdisVersion = MUX_PROT_MAJOR_NDIS_VERSION;
PChars.MinorNdisVersion = MUX_PROT_MINOR_NDIS_VERSION;
PChars.MajorDriverVersion = MUX_MAJOR_DRIVER_VERSION;
PChars.MinorDriverVersion = MUX_MINOR_DRIVER_VERSION;
PChars.SetOptionsHandler = PtSetOptions;
//
// Make sure the protocol-name matches the service-name
// (from the INF) under which this protocol is installed.
// This is needed to ensure that NDIS can correctly determine
// the binding and call us to bind to miniports below.
//
NdisInitUnicodeString(&Name, L"MUXP"); // Protocol name
PChars.Name = Name;
PChars.OpenAdapterCompleteHandlerEx = PtOpenAdapterComplete;
PChars.CloseAdapterCompleteHandlerEx = PtCloseAdapterComplete;
PChars.ReceiveNetBufferListsHandler = PtReceiveNBL;
PChars.SendNetBufferListsCompleteHandler = PtSendNBLComplete;
PChars.OidRequestCompleteHandler = PtRequestComplete;
PChars.StatusHandlerEx = PtStatus;
PChars.BindAdapterHandlerEx = PtBindAdapter;
PChars.UnbindAdapterHandlerEx = PtUnbindAdapter;
PChars.NetPnPEventHandler= PtPNPHandler;
Status = NdisRegisterProtocolDriver(ProtocolDriverContext,
&PChars,
&ProtHandle);
if (Status != NDIS_STATUS_SUCCESS)
{
NdisMDeregisterMiniportDriver(DriverHandle);
break;
}
//
// Let NDIS know of the association between our protocol
// and miniport entities.
//
NdisIMAssociateMiniport(DriverHandle, ProtHandle);
}while (FALSE);
return(Status);
}
// Unload the driver
VOID NeoNdisDriverUnload(PDRIVER_OBJECT DriverObject)
{
NdisMDeregisterMiniportDriver(ndis_miniport_driver_handle);
}