NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
DriverEntry initializes the driver and is the first routine called by the
system after the driver is loaded. DriverEntry specifies the other entry
points in the function driver, such as FmAddDevice and FmUnload.
Parameters Description:
DriverObject - represents the instance of the function driver that is loaded
into memory. DriverEntry must initialize members of DriverObject before it
returns to the caller. DriverObject is allocated by the system before the
driver is loaded, and it is released by the system after the system unloads
the function driver from memory.
RegistryPath - represents the driver specific path in the Registry.
The function driver can use the path to store driver related data between
reboots. The path does not store hardware instance specific data.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
KdPrint(("Fakemode Function Driver Sample - Driver Framework Edition.\n"));
KdPrint(("Built %s %s\n", __DATE__, __TIME__));
WDF_DRIVER_CONFIG_INIT( &config, FmEvtDeviceAdd );
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(
DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config, // Driver Config Info
WDF_NO_HANDLE
);
if (!NT_SUCCESS(status)) {
KdPrint( ("WdfDriverCreate failed with status 0x%x\n", status));
}
return status;
}
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
WDF_OBJECT_ATTRIBUTES attributes;
WDFDRIVER Driver;
PDRIVER_CONTEXT Context;
#if (NTDDI_VERSION > NTDDI_WIN7)
ExInitializeDriverRuntime(DrvRtPoolNxOptIn);
#endif
WPP_INIT_TRACING(DriverObject, RegistryPath);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT,
"Virtio-Serial driver started...built on %s %s\n", __DATE__, __TIME__);
WDF_DRIVER_CONFIG_INIT(&config,VIOSerialEvtDeviceAdd);
config.DriverPoolTag = VIOSERIAL_DRIVER_MEMORY_TAG;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, DRIVER_CONTEXT);
attributes.EvtCleanupCallback = VIOSerialEvtDriverContextCleanup;
status = WdfDriverCreate(DriverObject,
RegistryPath,
&attributes,
&config,
&Driver);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfDriverCreate failed - 0x%x\n", status);
WPP_CLEANUP(DriverObject);
return status;
}
Context = GetDriverContext(Driver);
// create a lookaside list used for allocating WRITE_BUFFER_ENTRY
// structures by all devices
status = WdfLookasideListCreate(WDF_NO_OBJECT_ATTRIBUTES,
sizeof(WRITE_BUFFER_ENTRY),
NonPagedPool,
WDF_NO_OBJECT_ATTRIBUTES,
VIOSERIAL_DRIVER_MEMORY_TAG,
&Context->WriteBufferLookaside);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfLookasideListCreate failed - 0x%x\n", status);
return status;
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- %s\n", __FUNCTION__);
return status;
}
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
DriverEntry initializes the driver and is the first routine called by the
system after the driver is loaded. DriverEntry specifies the other entry
points in the function driver, such as EvtDevice and DriverUnload.
Parameters Description:
DriverObject - represents the instance of the function driver that is loaded
into memory. DriverEntry must initialize members of DriverObject before it
returns to the caller. DriverObject is allocated by the system before the
driver is loaded, and it is released by the system after the system unloads
the function driver from memory.
RegistryPath - represents the driver specific path in the Registry.
The function driver can use the path to store driver related data between
reboots. The path does not store hardware instance specific data.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES attributes;
//
// Register a cleanup callback so that we can call WPP_CLEANUP when
// the framework driver object is deleted during driver unload.
//
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = CVWindowsInternalsEvtDriverContextCleanup;
WDF_DRIVER_CONFIG_INIT(&config,
CVWindowsInternalsEvtDeviceAdd
);
status = WdfDriverCreate(DriverObject,
RegistryPath,
&attributes,
&config,
WDF_NO_HANDLE
);
return status;
}
NTSTATUS
#pragma prefast(suppress:__WARNING_DRIVER_FUNCTION_TYPE, "thanks, i know this already")
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
{
/*WDF_DRIVER_CONFIG_INIT(&driverConfig, OnDeviceAdd);*/
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG driverConfig;
WDF_OBJECT_ATTRIBUTES driverAttributes;
WDFDRIVER fxDriver;
WPP_INIT_TRACING(DriverObject, RegistryPath);
FuncEntry(TRACE_FLAG_WDFLOADING);
WDF_DRIVER_CONFIG_INIT(&driverConfig, OnDeviceAdd);
driverConfig.DriverPoolTag = SPBT_POOL_TAG;
WDF_OBJECT_ATTRIBUTES_INIT(&driverAttributes);
driverAttributes.EvtCleanupCallback = OnDriverCleanup;
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(DriverObject,
RegistryPath,
&driverAttributes,
&driverConfig,
&fxDriver
);
if (!NT_SUCCESS(status))
{
Trace(
TRACE_LEVEL_ERROR,
TRACE_FLAG_WDFLOADING,
"Error creating WDF driver object - %!STATUS!",
status);
goto exit;
}
Trace(
TRACE_LEVEL_VERBOSE,
TRACE_FLAG_WDFLOADING,
"Created WDF driver object");
exit:
FuncExit(TRACE_FLAG_WDFLOADING);
return status;
}
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
DriverEntry initializes the driver and is the first routine called by the
system after the driver is loaded. DriverEntry specifies the other entry
points in the function driver, such as EvtDevice and DriverUnload.
Parameters Description:
DriverObject - represents the instance of the function driver that is loaded
into memory. DriverEntry must initialize members of DriverObject before it
returns to the caller. DriverObject is allocated by the system before the
driver is loaded, and it is released by the system after the system unloads
the function driver from memory.
RegistryPath - represents the driver specific path in the Registry.
The function driver can use the path to store driver related data between
reboots. The path does not store hardware instance specific data.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = RoboDeviceEvtDriverContextCleanup;
WDF_DRIVER_CONFIG_INIT( &config, RoboDeviceEvtDeviceAdd );
status = WdfDriverCreate(DriverObject,
RegistryPath,
&attributes,
&config,
WDF_NO_HANDLE
);
if (!NT_SUCCESS(status)) {
return status;
}
DbgPrintEx( DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "DriverEntry Exit %x", status );
return status;
}
NTSTATUS
DriverEntry (
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
/*++
Routine Description:
Installable driver initialization entry point.
This entry point is called directly by the I/O system.
Arguments:
DriverObject - pointer to the driver object
RegistryPath - pointer to a unicode string representing the path,
to driver-specific key in the registry.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
NTSTATUS ntStatus = STATUS_SUCCESS;
WDF_DRIVER_CONFIG Config;
ENTER ("DriverEntry");
TRACE (TL_TRACE, ("1394VDev Hybrid Sample\n"));
TRACE (TL_TRACE, ("Built %s %s\n", __DATE__, __TIME__));
//
// Initialize the Driver Config structure..
//
WDF_DRIVER_CONFIG_INIT (&Config, kmdf1394_EvtDeviceAdd);
//
// Create a WDFDRIVER object.
//
ntStatus = WdfDriverCreate (
DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&Config,
WDF_NO_HANDLE);
if (!NT_SUCCESS (ntStatus))
{
TRACE(TL_ERROR, ("WdfDriverCreate failed with status %x\n", ntStatus));
}
EXIT("DriverEntry", ntStatus);
return ntStatus;
} // DriverEntry
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
DriverEntry initializes the driver and is the first routine called by the
system after the driver is loaded. DriverEntry specifies the other entry
points in the function driver, such as EvtDevice and DriverUnload.
Parameters Description:
DriverObject - represents the instance of the function driver that is loaded
into memory. DriverEntry must initialize members of DriverObject before it
returns to the caller. DriverObject is allocated by the system before the
driver is loaded, and it is released by the system after the system unloads
the function driver from memory.
RegistryPath - represents the driver specific path in the Registry.
The function driver can use the path to store driver related data between
reboots. The path does not store hardware instance specific data.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDF_DRIVER_CONFIG_INIT(&config,
EchoEvtDeviceAdd
);
status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
WDF_NO_HANDLE);
if (!NT_SUCCESS(status)) {
KdPrint(("Error: WdfDriverCreate failed 0x%x\n", status));
return status;
}
#if DBG
EchoPrintDriverVersion();
#endif
return status;
}
NTSTATUS
StreamEditInitDriverObjects(
_Inout_ DRIVER_OBJECT* driverObject,
const UNICODE_STRING* registryPath,
_Out_ WDFDRIVER* pDriver,
_Out_ WDFDEVICE* pDevice
)
{
NTSTATUS status;
WDF_DRIVER_CONFIG config;
PWDFDEVICE_INIT pInit = NULL;
WDF_DRIVER_CONFIG_INIT(&config, WDF_NO_EVENT_CALLBACK);
config.DriverInitFlags |= WdfDriverInitNonPnpDriver;
config.EvtDriverUnload = StreamEditEvtDriverUnload;
status = WdfDriverCreate(
driverObject,
registryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
pDriver
);
if (!NT_SUCCESS(status))
{
goto Exit;
}
pInit = WdfControlDeviceInitAllocate(*pDriver, &SDDL_DEVOBJ_KERNEL_ONLY);
if (!pInit)
{
status = STATUS_INSUFFICIENT_RESOURCES;
goto Exit;
}
WdfDeviceInitSetCharacteristics(pInit, FILE_AUTOGENERATED_DEVICE_NAME, TRUE);
WdfDeviceInitSetDeviceType(pInit, FILE_DEVICE_NETWORK);
WdfDeviceInitSetCharacteristics(pInit, FILE_DEVICE_SECURE_OPEN, TRUE);
status = WdfDeviceCreate(&pInit, WDF_NO_OBJECT_ATTRIBUTES, pDevice);
if (!NT_SUCCESS(status))
{
WdfDeviceInitFree(pInit);
goto Exit;
}
WdfControlFinishInitializing(*pDevice);
Exit:
return status;
}
NTSTATUS DriverEntry(DRIVER_OBJECT* driverObject, UNICODE_STRING* registryPath) {
WDF_DRIVER_CONFIG config;
WDF_DRIVER_CONFIG_INIT(&config, MouseTrapEvtDeviceAdd);
NTSTATUS status = WdfDriverCreate(driverObject, registryPath, WDF_NO_OBJECT_ATTRIBUTES, &config, WDF_NO_HANDLE);
if(!NT_SUCCESS(status)) {
DebugPrint(("[MouseTrap] WdfDriverCreate failed with status 0x%x\n", status));
}
return status;
}
NTSTATUS
DriverEntry (
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This routine is the driver initialization entry point.
Arguments:
DriverObject - Pointer to the driver object created by the I/O manager.
RegistryPath - Pointer to the driver specific registry key.
Return Value:
NTSTATUS code.
--*/
{
WDFDRIVER Driver;
WDF_DRIVER_CONFIG DriverConfig;
NTSTATUS Status;
//
// Initialize the driver configuration structure.
//
WDF_DRIVER_CONFIG_INIT(&DriverConfig, SampleDrvEvtDeviceAdd);
//
// Create a framework driver object to represent our driver.
//
Status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&DriverConfig,
&Driver);
if (!NT_SUCCESS(Status)) {
goto DriverEntryEnd;
}
DriverEntryEnd:
return Status;
}
NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
WDF_DRIVER_CONFIG_INIT(&config, IVSHMEMEvtDeviceAdd);
status = WdfDriverCreate(DriverObject, RegistryPath, &attributes, &config, WDF_NO_HANDLE);
return status;
}
NTSTATUS DriverEntry( IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath )
{
NTSTATUS status;
WDF_DRIVER_CONFIG config;
// 注册EvtDriverDeviceAdd回调函数
WDF_DRIVER_CONFIG_INIT(&config, EvtDriverDeviceAdd);
// 创建驱动对象
status = WdfDriverCreate(DriverObject, RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES, &config, WDF_NO_HANDLE );
return status;
}
_Use_decl_annotations_
NTSTATUS DriverEntry (
DRIVER_OBJECT* DriverObjectPtr,
UNICODE_STRING* RegistryPathPtr
)
{
PAGED_CODE();
//
// Initialize logging
//
{
WPP_INIT_TRACING(DriverObjectPtr, RegistryPathPtr);
RECORDER_CONFIGURE_PARAMS recorderConfigureParams;
RECORDER_CONFIGURE_PARAMS_INIT(&recorderConfigureParams);
WppRecorderConfigure(&recorderConfigureParams);
#if DBG
WPP_RECORDER_LEVEL_FILTER(BSC_TRACING_VERBOSE) = TRUE;
#endif // DBG
}
NTSTATUS status;
WDFDRIVER wdfDriver;
{
WDF_DRIVER_CONFIG wdfDriverConfig;
WDF_DRIVER_CONFIG_INIT(&wdfDriverConfig, OnDeviceAdd);
wdfDriverConfig.DriverPoolTag = BCM_I2C_POOL_TAG;
wdfDriverConfig.EvtDriverUnload = OnDriverUnload;
status = WdfDriverCreate(
DriverObjectPtr,
RegistryPathPtr,
WDF_NO_OBJECT_ATTRIBUTES,
&wdfDriverConfig,
&wdfDriver);
if (!NT_SUCCESS(status)) {
BSC_LOG_ERROR(
"Failed to create WDF driver object. (DriverObjectPtr = %p, RegistryPathPtr = %p)",
DriverObjectPtr,
RegistryPathPtr);
return status;
}
}
NT_ASSERT(NT_SUCCESS(status));
return STATUS_SUCCESS;
}
NTSTATUS
DriverEntry (
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
Installable driver initialization entry point.
This entry point is called directly by the I/O system.
--*/
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
DebugPrint(("Mouse Filter Driver Sample - Driver Framework Edition.\n"));
DebugPrint(("Built %s %s\n", __DATE__, __TIME__));
// Initiialize driver config to control the attributes that
// are global to the driver. Note that framework by default
// provides a driver unload routine. If you create any resources
// in the DriverEntry and want to be cleaned in driver unload,
// you can override that by manually setting the EvtDriverUnload in the
// config structure. In general xxx_CONFIG_INIT macros are provided to
// initialize most commonly used members.
WDF_DRIVER_CONFIG_INIT(
&config,
MouFilter_EvtDeviceAdd
);
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
WDF_NO_HANDLE); // hDriver optional
if (!NT_SUCCESS(status)) {
DebugPrint( ("WdfDriverCreate failed with status 0x%x\n", status));
}
return status;
}
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{
NTSTATUS Status;
WDF_DRIVER_CONFIG Config;
WPP_INIT_TRACING(DriverObject, RegistryPath);
UsbChief_DbgPrint(DEBUG_CONFIG, ("starting\n"));
WDF_DRIVER_CONFIG_INIT(&Config, UsbChief_EvtDeviceAdd);
Status = WdfDriverCreate(DriverObject, RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES, &Config, WDF_NO_HANDLE);
if (!NT_SUCCESS(Status)) {
UsbChief_DbgPrint(0, ("WdfDriverCreate failed: 0x%08x\n", Status));
return Status;
}
return STATUS_SUCCESS;
}
NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)
{
NTSTATUS status;
WDF_DRIVER_CONFIG config;
KdPrintEx((DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "Driver Loaded\n"));
// Initialize the driver config structure
WDF_DRIVER_CONFIG_INIT(&config, NULL);
// Indicate that this is a non-PNP driver
config.DriverInitFlags = WdfDriverInitNonPnpDriver;
// Specify the callout driver's Unload function
config.EvtDriverUnload = EvtDriverUnload;
status = WdfDriverCreate(DriverObject, RegistryPath, WDF_NO_OBJECT_ATTRIBUTES, &config, WDF_NO_HANDLE);
ExploreEPROCESS();
return status;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES attributes;
WPP_INIT_TRACING( DriverObject, RegistryPath );
KdPrint(("DriverEntry of Step5\n"));
WDF_DRIVER_CONFIG_INIT(&config, EvtDeviceAdd);
//
// Register a cleanup callback so that we can call WPP_CLEANUP when
// the framework driver object is deleted during driver unload.
//
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = EvtDriverContextCleanup;
status = WdfDriverCreate(DriverObject,
RegistryPath,
&attributes,
&config,
WDF_NO_HANDLE
);
if (!NT_SUCCESS(status)) {
KdPrint(("WdfDriverCreate failed %!STATUS!\n", status));
//
// Cleanup tracing here because DriverContextCleanup will not be called
// as we have failed to create WDFDRIVER object itself.
// Please note that if your return failure from DriverEntry after the
// WDFDRIVER object is created successfully, you don't have to
// call WPP cleanup because in those cases DriverContextCleanup
// will be executed when the framework deletes the DriverObject.
//
WPP_CLEANUP(DriverObject);
}
return status;
}
FxDriver::FxDriver(
__in MdDriverObject ArgDriverObject,
__in PWDF_DRIVER_CONFIG DriverConfig,
__in PFX_DRIVER_GLOBALS FxDriverGlobals
) :
FxNonPagedObject(FX_TYPE_DRIVER, sizeof(FxDriver), FxDriverGlobals),
m_DriverObject(ArgDriverObject),
m_CallbackMutexLock(FxDriverGlobals)
{
RtlInitUnicodeString(&m_RegistryPath, NULL);
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
m_ExecutionLevel = WdfExecutionLevelDispatch;
#else
m_ExecutionLevel = WdfExecutionLevelPassive;
#endif
m_SynchronizationScope = WdfSynchronizationScopeNone;
m_CallbackLockPtr = NULL;
m_CallbackLockObjectPtr = NULL;
m_DisposeList = NULL;
//
// These are initialized up front so that sub objects
// can have the right configuration
//
WDF_DRIVER_CONFIG_INIT(&m_Config, NULL);
// Only copy the smallest of what is specified and our size
RtlCopyMemory(&m_Config, DriverConfig, min(sizeof(m_Config), DriverConfig->Size) );
m_DebuggerConnected = FALSE;
#if FX_IS_USER_MODE
m_DriverParametersKey = NULL;
#endif
}
//------------------------------------------------------------------------------
// Function: DriverEntry
//
// This routine is the driver initialization entry point.
//
// Arguments:
// DriverObject: IN: Pointer to the driver object created by the I/O manager
// RegistryPath: IN: Pointer to the driver specific registry key
//
// Return Value:
// NTSTATUS code
//------------------------------------------------------------------------------
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
{
WDF_DRIVER_CONFIG DriverConfig;
NTSTATUS Status = STATUS_SUCCESS;
//
// Initialize WPP Tracing
//
WPP_INIT_TRACING(DriverObject, NULL);
SENSOR_FunctionEnter();
DriverConfig.DriverPoolTag = SENSORV2_POOL_TAG_COMBO;
//
// Initialize the driver configuration structure.
//
WDF_DRIVER_CONFIG_INIT(&DriverConfig, OnDeviceAdd);
DriverConfig.EvtDriverUnload = OnDriverUnload;
//
// Create a framework driver object to represent our driver.
//
Status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&DriverConfig,
WDF_NO_HANDLE);
if (!NT_SUCCESS(Status))
{
TraceError("COMBO %!FUNC! WdfDriverCreate failed: %!STATUS!", Status);
goto Exit;
}
Exit:
SENSOR_FunctionExit(Status);
return Status;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
Installable driver initialization entry point.
This entry point is called directly by the I/O system.
Arguments:
DriverObject - pointer to the driver object
RegistryPath - pointer to a unicode string representing the path,
to driver-specific key in the registry.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
WDF_DRIVER_CONFIG_INIT(&config,
MarsEvtDeviceAdd
);
status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
WDF_NO_HANDLE
);
return status;
}
NTSTATUS
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath) {
NTSTATUS status;
WDF_DRIVER_CONFIG config;
WDFDRIVER driver;
UNREFERENCED_PARAMETER(RegistryPath);
FUNCTION_ENTER();
WDF_DRIVER_CONFIG_INIT(&config, XenVbd_EvtDeviceAdd);
status = WdfDriverCreate(DriverObject, RegistryPath, WDF_NO_OBJECT_ATTRIBUTES, &config, &driver);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("WdfDriverCreate failed with status 0x%x\n", status);
FUNCTION_EXIT();
return status;
}
FUNCTION_EXIT();
return status;
}
NTSTATUS
DriverEntry(__in PDRIVER_OBJECT DriverObject, __in PUNICODE_STRING RegistryPath)
{
WDF_DRIVER_CONFIG DriverConfig;
NTSTATUS Status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG_INIT(&DriverConfig, EvtDriverDeviceAdd);
DriverConfig.EvtDriverUnload = EvtDriverUnload;
Status = WdfDriverCreate(DriverObject, RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES, &DriverConfig,
WDF_NO_HANDLE);
if (NT_SUCCESS(Status)) {
TRACE_MSG(TRACE_LEVEL_INFO, TRACE_FLAG_DRIVER,
"Driver initialized\n");
} else {
TRACE_ERR("WdfDriverCreate", Status);
}
return Status;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
WDF_OBJECT_ATTRIBUTES attributes;
WDFDRIVER driver;
#if (NTDDI_VERSION > NTDDI_WIN7)
ExInitializeDriverRuntime(DrvRtPoolNxOptIn);
#endif
WPP_INIT_TRACING(DriverObject, RegistryPath);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT,
"Virtio-input driver started...built on %s %s\n", __DATE__, __TIME__);
WDF_DRIVER_CONFIG_INIT(&config,VIOInputEvtDeviceAdd);
config.DriverPoolTag = VIOINPUT_DRIVER_MEMORY_TAG;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = VIOInputEvtDriverContextCleanup;
status = WdfDriverCreate(DriverObject,
RegistryPath,
&attributes,
&config,
&driver);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfDriverCreate failed - 0x%x\n", status);
WPP_CLEANUP(DriverObject);
return status;
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- %s\n", __FUNCTION__);
return status;
}
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,IN PUNICODE_STRING RegistryPath) {
NTSTATUS status;
WDF_DRIVER_CONFIG config;
WDF_OBJECT_ATTRIBUTES attributes;
#if defined(_DEBUG) || defined(DBG)
// if (TRUE == KdRefreshDebuggerNotPresent())
// return STATUS_UNSUCCESSFUL;// For the time being, don't load the driver if no debugger is attached
// DbgBreakPoint();
if (FALSE == KdRefreshDebuggerNotPresent())
DbgBreakPoint();
#endif
// Initialize WPP Tracing
WPP_INIT_TRACING( DriverObject, RegistryPath );
WPP_FLAG_LEVEL_ENABLED(MYDRIVER_ALL_INFO, TRACE_LEVEL_VERBOSE);
TraceEvents(TRACE_LEVEL_INFORMATION, TRACE_DRIVER, "UsbCfgCtrl>> DriverEntry " __DATE__ " " __TIME__ "\r\n");
// Register a cleanup callback so that we can call WPP_CLEANUP when the framework driver object is deleted during driver unload.
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = [](IN WDFOBJECT DriverObject) {
TraceEvents(TRACE_LEVEL_INFORMATION, TRACE_DRIVER, "%!FUNC! Entry");
// Stop WPP Tracing
WPP_CLEANUP(WdfDriverWdmGetDriverObject((WDFDRIVER)DriverObject));
};
WDF_DRIVER_CONFIG_INIT(&config, UsbCfgDevice::CreateDevice);// UsbCfgCtrlEvtDeviceAdd);
status = WdfDriverCreate(DriverObject, RegistryPath, &attributes, &config, WDF_NO_HANDLE);
if (NT_FAILED(status)) {
TraceEvents(TRACE_LEVEL_ERROR, TRACE_DRIVER, "WdfDriverCreate failed %!STATUS!\r\n", status);
WPP_CLEANUP(DriverObject);
return status;
}
TraceEvents(TRACE_LEVEL_INFORMATION, TRACE_DRIVER, "%!FUNC! Exit\r\n");
return status;
}
// This routine is the driver initialization entry point.
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject, // Pointer to the driver object created by the I/O manager
_In_ PUNICODE_STRING RegistryPath // Pointer to the driver specific registry key
)
{
WDF_DRIVER_CONFIG DriverConfig;
NTSTATUS Status = STATUS_SUCCESS;
// Initialize WPP Tracing
WPP_INIT_TRACING(DriverObject, NULL);
SENSOR_FunctionEnter();
DriverConfig.DriverPoolTag = SENSOR_POOL_TAG_PEDOMETER;
// Initialize the driver configuration structure.
WDF_DRIVER_CONFIG_INIT(&DriverConfig, PedometerDevice::OnDeviceAdd);
DriverConfig.EvtDriverUnload = OnDriverUnload;
// Create a framework driver object to represent our driver.
Status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&DriverConfig,
WDF_NO_HANDLE);
if (!NT_SUCCESS(Status))
{
TraceError("PED %!FUNC! WdfDriverCreate failed: %!STATUS!", Status);
goto Exit;
}
Exit:
SENSOR_FunctionExit(Status);
return Status;
}
// Driver Entry
NTSTATUS DriverEntry( IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
// Init
NTSTATUS status;
WDF_DRIVER_CONFIG config;
WDF_OBJECT_ATTRIBUTES colAttributes;
WDFDRIVER hDriver;
DEBUG("Entry");
// Register this driver and its add dev method with the WDF
WDF_DRIVER_CONFIG_INIT( &config,
GFilterAddDevice);
status = WdfDriverCreate( DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
&hDriver);
CHECKSTATUS(status, ERROR("Unable to create driver object"));
return(status);
}
NTSTATUS DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDFDRIVER driver;
WDF_OBJECT_ATTRIBUTES attrib;
WPP_INIT_TRACING( DriverObject, RegistryPath );
TraceEvents(TRACE_LEVEL_WARNING, DBG_HW_ACCESS, "Balloon driver, built on %s %s\n",
__DATE__, __TIME__);
WDF_OBJECT_ATTRIBUTES_INIT(&attrib);
attrib.EvtCleanupCallback = EvtDriverContextCleanup;
WDF_DRIVER_CONFIG_INIT(&config, BalloonDeviceAdd);
status = WdfDriverCreate(
DriverObject,
RegistryPath,
&attrib,
&config,
&driver);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,"WdfDriverCreate failed with status 0x%08x\n", status);
WPP_CLEANUP(DriverObject);
return status;
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,"<-- %s\n", __FUNCTION__);
return status;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
Installable driver initialization entry point.
This entry point is called directly by the I/O system.
Arguments:
DriverObject - pointer to the driver object
RegistryPath - pointer to a unicode string representing the path
to driver-specific key in the registry
Return Value:
STATUS_SUCCESS if successful.
--*/
{
WDF_DRIVER_CONFIG config;
KdPrint(("Windows Ramdisk Driver - Driver Framework Edition.\n"));
KdPrint(("Built %s %s\n", __DATE__, __TIME__));
WDF_DRIVER_CONFIG_INIT( &config, RamDiskEvtDeviceAdd );
return WdfDriverCreate(DriverObject, RegistryPath, WDF_NO_OBJECT_ATTRIBUTES, &config, WDF_NO_HANDLE);
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
Installable driver initialization entry point.
This entry point is called directly by the I/O system.
Arguments:
DriverObject - pointer to the driver object
RegistryPath - pointer to a unicode string representing the path,
to driver-specific key in the registry.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDFDRIVER hDriver;
KdPrint(("OSRUSBFX2 Filter Driver - Driver Framework Edition.\n"));
KdPrint(("Built %s %s\n", __DATE__, __TIME__));
//
// Initiialize driver config to control the attributes that
// are global to the driver. Note that framework by default
// provides a driver unload routine. If you create any resources
// in the DriverEntry and want to be cleaned in driver unload,
// you can override that by manually setting the EvtDriverUnload in the
// config structure. In general xxx_CONFIG_INIT macros are provided to
// initialize most commonly used members.
//
WDF_DRIVER_CONFIG_INIT(
&config,
FilterEvtDeviceAdd
);
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
&hDriver);
if (!NT_SUCCESS(status)) {
KdPrint( ("WdfDriverCreate failed with status 0x%x\n", status));
}
return status;
}
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
Driver initialization entry point. This entry point is called directly by
the I/O system.
Arguments:
DriverObject - pointer to the driver object
RegistryPath - pointer to a unicode string representing the path to the
driver-specific key in the registry.
Return Value:
An NTSTATUS value representing success or failure of the function.
--*/
{
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
WDF_OBJECT_ATTRIBUTES attributes;
WPP_INIT_TRACING(RegistryPath->Buffer);
//
// Initiialize driver config to control the attributes that are global to
// the driver. Note that framework by default provides a driver unload
// routine. If DriverEntry creates any resources that require clean-up in
// driver unload, you can manually override the default by supplying a
// pointer to the EvtDriverUnload callback in the config structure. In
// general xxx_CONFIG_INIT macros are provided to initialize most commonly
// used members.
//
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = SingleCompEvtDriverCleanup;
WDF_DRIVER_CONFIG_INIT(
&config,
SingleCompEvtDeviceAdd
);
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(DriverObject,
RegistryPath,
&attributes, // Driver Attributes
&config, // Driver Config Info
WDF_NO_HANDLE
);
if (FALSE == NT_SUCCESS(status)) {
KdPrint( ("WdfDriverCreate failed with status 0x%x\n", status));
WPP_CLEANUP();
}
return status;
}
