NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
NDIS_MINIPORT_DRIVER_CHARACTERISTICS MChars;
ULONG ndisVersion;
if (FailDriverEntry)
{
DbgPrint("FAILING DRIVER ENTRY\n");
return NDIS_STATUS_FAILURE;
}
#if DOT11_TRACE_ENABLED
WPP_INIT_TRACING(DriverObject, RegistryPath);
#endif
MpTrace(COMP_INIT_PNP, DBG_SERIOUS, (__DATE__ " " __TIME__ " DriverEntry called!\n"));
do
{
//
// Identify the appropriate read/write lock API
//
Status = MpDetermineRWLockType();
if (Status != NDIS_STATUS_SUCCESS)
{
MpTrace(COMP_INIT_PNP, DBG_SERIOUS, ("Failed to determine type of read/write lock to use. Status = 0x%x\n", Status));
break;
}
NdisZeroMemory(&MChars, sizeof(NDIS_MINIPORT_DRIVER_CHARACTERISTICS));
//
// Set the type and version of this structure. We select the appropriate version &
// driver functionality based on NDIS version.
//
ndisVersion = NdisGetVersion();
if (ndisVersion <= MP_NDIS_VERSION_NEEDS_COMPATIBILITY)
{
// NDIS Version 6.0
MChars.Header.Type = NDIS_OBJECT_TYPE_MINIPORT_DRIVER_CHARACTERISTICS;
MChars.Header.Size = NDIS_SIZEOF_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_1;
MChars.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_1;
MChars.MajorNdisVersion = MP_MAJOR_NDIS_VERSION;
MChars.MinorNdisVersion = 0;
}
else
{
// NDIS Version 6.2
MChars.Header.Type = NDIS_OBJECT_TYPE_MINIPORT_DRIVER_CHARACTERISTICS;
MChars.Header.Size = NDIS_SIZEOF_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2;
MChars.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2;
MChars.MajorNdisVersion = MP_MAJOR_NDIS_VERSION;
MChars.MinorNdisVersion = MP_MINOR_NDIS_VERSION;
}
MChars.MajorDriverVersion = HW11_MAJOR_DRIVER_VERSION;
MChars.MinorDriverVersion = HW11_MINOR_DRIVER_VERSION;
//
// Init/PnP handlers
//
MChars.InitializeHandlerEx = MPInitialize;
MChars.RestartHandler = MPRestart;
MChars.PauseHandler = MPPause;
MChars.ShutdownHandlerEx = MPAdapterShutdown;
MChars.DevicePnPEventNotifyHandler = MPDevicePnPEvent;
MChars.HaltHandlerEx = MPHalt;
MChars.UnloadHandler = DriverUnload;
//
// Query/Set/Method requests handlers
//
MChars.OidRequestHandler = MPOidRequest;
MChars.CancelOidRequestHandler = MPCancelOidRequest;
//
// Set optional miniport services handler
//
MChars.SetOptionsHandler = MPSetOptions;
//
// Send/Receive handlers
//
MChars.SendNetBufferListsHandler = MPSendNetBufferLists;
MChars.CancelSendHandler = MPCancelSendNetBufferLists;
MChars.ReturnNetBufferListsHandler = MPReturnNetBufferLists;
//
// Fault handling handlers
//
MChars.CheckForHangHandlerEx = MPCheckForHang;
MChars.ResetHandlerEx = MPReset;
//
// Direct OID request handlers
//
MChars.DirectOidRequestHandler = MPDirectOidRequest;
MChars.CancelDirectOidRequestHandler = MPCancelDirectOidRequest;
//
// Register the miniport driver with NDIS
//
Status = NdisMRegisterMiniportDriver(
DriverObject,
RegistryPath,
GlobalDriverContext,
&MChars,
&GlobalDriverHandle
);
if (Status != NDIS_STATUS_SUCCESS)
{
MpTrace(COMP_INIT_PNP, DBG_SERIOUS, ("Failed to register miniport with NDIS. Status = 0x%x\n", Status));
break;
}
#if DBG
#if !DOT11_TRACE_ENABLED
//
// Read debug mask from registry
//
MpReadGlobalDebugMask(GlobalDriverHandle);
#endif
#endif
}
while (FALSE);
if (Status != NDIS_STATUS_SUCCESS)
{
#if DOT11_TRACE_ENABLED
WPP_CLEANUP(DriverObject);
#endif
}
return(Status);
}
NTSTATUS
DriverEntry(
__in PDRIVER_OBJECT DriverObject,
__in PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
In the context of its DriverEntry function, a miniport driver associates
itself with NDIS, specifies the NDIS version that it is using, and
registers its entry points.
Arguments:
PVOID DriverObject - pointer to the driver object.
PVOID RegistryPath - pointer to the driver registry path.
Return Value:
NTSTATUS code
--*/
{
NTSTATUS status;
UNREFERENCED_PARAMETER(RegistryPath);
DEBUGP (("[TAP] --> DriverEntry; version [%d.%d] %s %s\n",
TAP_DRIVER_MAJOR_VERSION,
TAP_DRIVER_MINOR_VERSION,
__DATE__,
__TIME__));
DEBUGP (("[TAP] Registry Path: '%wZ'\n", RegistryPath));
//
// Initialize any driver-global variables here.
//
NdisZeroMemory(&GlobalData, sizeof(GlobalData));
//
// The ApaterList in the GlobalData structure is used to track multiple
// adapters controlled by this miniport.
//
NdisInitializeListHead(&GlobalData.AdapterList);
//
// This lock protects the AdapterList.
//
NdisInitializeReadWriteLock(&GlobalData.Lock);
do
{
NDIS_MINIPORT_DRIVER_CHARACTERISTICS miniportCharacteristics;
NdisZeroMemory(&miniportCharacteristics, sizeof(miniportCharacteristics));
{C_ASSERT(sizeof(miniportCharacteristics) >= NDIS_SIZEOF_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2);}
miniportCharacteristics.Header.Type = NDIS_OBJECT_TYPE_MINIPORT_DRIVER_CHARACTERISTICS;
miniportCharacteristics.Header.Size = NDIS_SIZEOF_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2;
miniportCharacteristics.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2;
miniportCharacteristics.MajorNdisVersion = TAP_NDIS_MAJOR_VERSION;
miniportCharacteristics.MinorNdisVersion = TAP_NDIS_MINOR_VERSION;
miniportCharacteristics.MajorDriverVersion = TAP_DRIVER_MAJOR_VERSION;
miniportCharacteristics.MinorDriverVersion = TAP_DRIVER_MINOR_VERSION;
miniportCharacteristics.Flags = 0;
//miniportCharacteristics.SetOptionsHandler = MPSetOptions; // Optional
miniportCharacteristics.InitializeHandlerEx = AdapterCreate;
miniportCharacteristics.HaltHandlerEx = AdapterHalt;
miniportCharacteristics.UnloadHandler = TapDriverUnload;
miniportCharacteristics.PauseHandler = AdapterPause;
miniportCharacteristics.RestartHandler = AdapterRestart;
miniportCharacteristics.OidRequestHandler = AdapterOidRequest;
miniportCharacteristics.SendNetBufferListsHandler = AdapterSendNetBufferLists;
miniportCharacteristics.ReturnNetBufferListsHandler = AdapterReturnNetBufferLists;
miniportCharacteristics.CancelSendHandler = AdapterCancelSend;
miniportCharacteristics.CheckForHangHandlerEx = AdapterCheckForHangEx;
miniportCharacteristics.ResetHandlerEx = AdapterReset;
miniportCharacteristics.DevicePnPEventNotifyHandler = AdapterDevicePnpEventNotify;
miniportCharacteristics.ShutdownHandlerEx = AdapterShutdownEx;
miniportCharacteristics.CancelOidRequestHandler = AdapterCancelOidRequest;
//
// Associate the miniport driver with NDIS by calling the
// NdisMRegisterMiniportDriver. This function returns an NdisDriverHandle.
// The miniport driver must retain this handle but it should never attempt
// to access or interpret this handle.
//
// By calling NdisMRegisterMiniportDriver, the driver indicates that it
// is ready for NDIS to call the driver's MiniportSetOptions and
// MiniportInitializeEx handlers.
//
DEBUGP (("[TAP] Calling NdisMRegisterMiniportDriver...\n"));
//NDIS_DECLARE_MINIPORT_DRIVER_CONTEXT(TAP_GLOBAL);
status = NdisMRegisterMiniportDriver(
DriverObject,
RegistryPath,
&GlobalData,
&miniportCharacteristics,
&GlobalData.NdisDriverHandle
);
if (NDIS_STATUS_SUCCESS == status)
{
DEBUGP (("[TAP] Registered miniport successfully\n"));
}
else
{
DEBUGP(("[TAP] NdisMRegisterMiniportDriver failed: %8.8X\n", status));
TapDriverUnload(DriverObject);
status = NDIS_STATUS_FAILURE;
break;
}
} while(FALSE);
DEBUGP (("[TAP] <-- DriverEntry; status = %8.8X\n",status));
return status;
}
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject, PUNICODE_STRING pRegistryPath)
{
NDIS_STATUS status = NDIS_STATUS_FAILURE;
NDIS_MINIPORT_DRIVER_CHARACTERISTICS chars;
#ifdef DEBUG_TIMING
LARGE_INTEGER TickCount;
LARGE_INTEGER SysTime;
#endif DEBUG_TIMING
ParaNdis_DebugInitialize();
DEBUG_ENTRY(0);
DPrintf(0, (__DATE__ " " __TIME__ "built %d.%d\n", NDIS_MINIPORT_MAJOR_VERSION, NDIS_MINIPORT_MINOR_VERSION));
#ifdef DEBUG_TIMING
KeQueryTickCount(&TickCount);
NdisGetCurrentSystemTime(&SysTime);
DPrintf(0, ("\n%s>> CPU #%d, perf-counter %I64d, tick count %I64d, NDIS_sys_time %I64d\n", __FUNCTION__, KeGetCurrentProcessorNumber(), KeQueryPerformanceCounter(NULL).QuadPart,TickCount.QuadPart, SysTime.QuadPart));
#endif
NdisZeroMemory(&chars, sizeof(chars));
chars.Header.Type = NDIS_OBJECT_TYPE_MINIPORT_DRIVER_CHARACTERISTICS;
chars.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_1;
chars.Header.Size = NDIS_SIZEOF_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_1;
chars.MajorNdisVersion = NDIS_MINIPORT_MAJOR_VERSION;
chars.MinorNdisVersion = NDIS_MINIPORT_MINOR_VERSION;
/* stupid thing, they are at least short */
chars.MajorDriverVersion = (UCHAR)(PARANDIS_MAJOR_DRIVER_VERSION & 0xFF);
chars.MinorDriverVersion = (UCHAR)(PARANDIS_MINOR_DRIVER_VERSION & 0xFF);
// possible value for regular miniport NDIS_WDM_DRIVER - for USB or 1394
// chars.Flags = 0;
chars.InitializeHandlerEx = ParaNdis6_Initialize;
chars.HaltHandlerEx = ParaNdis6_Halt;
chars.UnloadHandler = ParaNdis6_Unload;
chars.PauseHandler = ParaNdis6_Pause;
chars.RestartHandler = ParaNdis6_Restart;
chars.OidRequestHandler = ParaNdis6_OidRequest;
chars.CancelOidRequestHandler = ParaNdis6_OidCancelRequest;
chars.SendNetBufferListsHandler = ParaNdis6_SendNetBufferLists;
chars.CancelSendHandler = ParaNdis6_CancelSendNetBufferLists;
chars.ReturnNetBufferListsHandler = ParaNdis6_ReturnNetBufferLists;
chars.CheckForHangHandlerEx = ParaNdis6_CheckForHang;
chars.ResetHandlerEx = ParaNdis6_Reset;
chars.ShutdownHandlerEx = ParaNdis6_AdapterShutdown;
chars.DevicePnPEventNotifyHandler = ParaNdis6_DevicePnPEvent;
chars.SetOptionsHandler = ParaNdis6_SetOptions;
#if NDIS_SUPPORT_NDIS61
chars.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2;
chars.Header.Size = NDIS_SIZEOF_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2;
chars.DirectOidRequestHandler = ParaNdis6x_DirectOidRequest;
chars.CancelDirectOidRequestHandler = ParaNdis6x_CancelDirectOidRequest;
#endif
status = NdisMRegisterMiniportDriver(
pDriverObject,
pRegistryPath,
NULL,
&chars,
&DriverHandle);
if (status == NDIS_STATUS_SUCCESS)
{
RetrieveDriverConfiguration();
}
DEBUG_EXIT_STATUS(status ? 0 : 4, status);
return status;
}
// Win32 driver entry point
NDIS_STATUS DriverEntry(DRIVER_OBJECT *DriverObject, UNICODE_STRING *RegistryPath)
{
NDIS_MINIPORT_DRIVER_CHARACTERISTICS miniport;
ULONG os_major_ver = 0, os_minor_ver = 0;
NDIS_STATUS ret;
// Initialize the Neo library
if (NeoInit() == FALSE)
{
// Initialization Failed
return STATUS_UNSUCCESSFUL;
}
g_is_win8 = false;
// Get the OS version
PsGetVersion(&os_major_ver, &os_minor_ver, NULL, NULL);
if (os_major_ver >= 7 || (os_major_ver == 6 && os_minor_ver >= 2))
{
// Windows 8
g_is_win8 = true;
}
// Register a NDIS miniport driver
NeoZero(&miniport, sizeof(NDIS_MINIPORT_DRIVER_CHARACTERISTICS));
miniport.Header.Type = NDIS_OBJECT_TYPE_MINIPORT_DRIVER_CHARACTERISTICS;
miniport.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2;
miniport.Header.Size = NDIS_SIZEOF_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2;
miniport.MajorNdisVersion = NEO_NDIS_MAJOR_VERSION;
miniport.MinorNdisVersion = NEO_NDIS_MINOR_VERSION;
// Register the handler
miniport.InitializeHandlerEx = NeoNdisInitEx;
miniport.HaltHandlerEx = NeoNdisHaltEx;
miniport.OidRequestHandler = NeoNdisOidRequest;
miniport.ResetHandlerEx = NeoNdisResetEx;
miniport.CheckForHangHandlerEx = NeoNdisCheckForHangEx;
miniport.UnloadHandler = NeoNdisDriverUnload;
miniport.SendNetBufferListsHandler = NeoNdisSendNetBufferLists;
miniport.SetOptionsHandler = NeoNdisSetOptions;
miniport.PauseHandler = NeoNdisPause;
miniport.RestartHandler = NeoNdisRestart;
miniport.ReturnNetBufferListsHandler = NeoNdisReturnNetBufferLists;
miniport.CancelSendHandler = NeoNdisCancelSend;
miniport.DevicePnPEventNotifyHandler = NeoNdisDevicePnPEventNotify;
miniport.ShutdownHandlerEx = NeoNdisShutdownEx;
miniport.CancelOidRequestHandler = NeoNdisCancelOidRequest;
ret = NdisMRegisterMiniportDriver(DriverObject, RegistryPath,
NULL, &miniport, &ndis_miniport_driver_handle);
if (NG(ret))
{
// Registration failure
return STATUS_UNSUCCESSFUL;
}
// Initialization success
return STATUS_SUCCESS;
}
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);
}
NDIS_STATUS
DriverEntry(PVOID obj,PVOID path)
{
NDIS_STATUS rc;
NDIS_MINIPORT_DRIVER_CHARACTERISTICS c;
WDF_DRIVER_CONFIG dc;
NTSTATUS nrc;
WDFDRIVER fw_handle;
vlog("DriverEntry started");
if(NdisGetVersion() <
((VENET_NDIS_MAJOR_VERSION << 16) | VENET_NDIS_MINOR_VERSION)) {
vlog("Invalid version!");
return NDIS_STATUS_FAILURE;
}
WDF_DRIVER_CONFIG_INIT(&dc, WDF_NO_EVENT_CALLBACK);
dc.DriverInitFlags |= WdfDriverInitNoDispatchOverride;
nrc = WdfDriverCreate(obj, path, WDF_NO_OBJECT_ATTRIBUTES,
&dc, &fw_handle);
if(!NT_SUCCESS(nrc)) {
vlog("DriverEntry WdfDriverCreate: %d", nrc);
return NDIS_STATUS_FAILURE;
}
/* For multiple instances */
NdisInitializeListHead(&adapterList);
NdisAllocateSpinLock(&adapterListLock);
NdisZeroMemory(&c, sizeof(c));
c.Header.Type = NDIS_OBJECT_TYPE_MINIPORT_DRIVER_CHARACTERISTICS;
c.Header.Size = sizeof(NDIS_MINIPORT_DRIVER_CHARACTERISTICS);
c.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_1;
c.Flags = NDIS_WDM_DRIVER;
c.MajorNdisVersion = VENET_NDIS_MAJOR_VERSION;
c.MinorNdisVersion = VENET_NDIS_MINOR_VERSION;
c.MajorDriverVersion = VENET_MAJOR_VERSION;
c.MinorDriverVersion = VENET_MINOR_VERSION;
c.InitializeHandlerEx = VenetInitialize;
c.PauseHandler = VenetPause;
c.RestartHandler = VenetRestart;
c.ShutdownHandlerEx = VenetShutdown;
c.DevicePnPEventNotifyHandler = VenetDevicePnPEvent;
c.HaltHandlerEx = VenetHalt;
c.UnloadHandler = VenetUnload;
c.OidRequestHandler = VenetOidRequest;
c.CancelOidRequestHandler = VenetCancelOidRequest;
c.SetOptionsHandler = VenetSetOptions;
c.SendNetBufferListsHandler = VenetSendNetBufs;
c.CancelSendHandler = VenetCancelSend;
c.ReturnNetBufferListsHandler = VenetReturnNetBufs;
c.CheckForHangHandlerEx = VenetCheckHang;
c.ResetHandlerEx = VenetReset;
rc = NdisMRegisterMiniportDriver(obj, path, (PNDIS_HANDLE)
driver_context, &c, &mp_handle);
vlog("DriverEntry return rc = %d", rc);
return rc;
}
