// Add device
NTSTATUS GFilterAddDevice( IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit)
{
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES deviceAttributes;
WDFDEVICE device;
PFILTER_EXTENSION filtExt;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
WDFQUEUE ioDefaultQueue;
DEBUG("Adding Device");
// Indicate we are a filter driver, This forwards all IRPs on to the lower filters
WdfFdoInitSetFilter(DeviceInit);
// Setup the actual filter for the IRPs
#ifdef USE_SETIOINCALLERCONTEXTCALLBACK
// Use built in KMDF filter
WdfDeviceInitSetIoInCallerContextCallback( DeviceInit,
GFilterIOCallback);
#endif
// Create a new device
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE( &deviceAttributes,
FILTER_EXTENSION);
// no cleanup callback needed -- deviceAttributes.EvtCleanupCallback = GFilterDeviceCleanUp; // Set device unload callback
status = WdfDeviceCreate( &DeviceInit, // Create the device
&deviceAttributes,
&device);
CHECKSTATUS(status, return(status));
// Create the filter extension -- We don't really care about this really
filtExt = FilterGetData(device);
filtExt->Instance = 0x00;
#ifndef USE_SETIOINCALLERCONTEXTCALLBACK
// Create IO queue and set callbacks to be filtered.
//!todo, we created a parrallel que here but some drivers may need multiple parallel queues which is not done
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE( &ioQueueConfig, // Create parallel IO queue in case the device we filter does not like sequential
WdfIoQueueDispatchParallel );
ioQueueConfig.EvtIoRead = GFilterRead; // Read
ioQueueConfig.EvtIoWrite = GFilterWrite; // Write
status = WdfIoQueueCreate( device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&ioDefaultQueue);
CHECKSTATUS(status, ERROR("Failed to create queues. status=0x%0.4x",status); goto GFilterAddDeviceCleanup);
#endif
// Create sideband communications to userspace
#ifdef USE_CONTROL_DEVICE
GFilterCreateControlDevice( device,
++DeviceInstances); //!todo, should we lock instance ??
#else
GFilterCreateRawPDO( device,
++DeviceInstances); //!todo, should we lock instance ??
#endif
GFilterAddDeviceCleanup:
return(status);
}
NTSTATUS
bareflankQueueInitialize(
_In_ WDFDEVICE Device
)
{
WDFQUEUE queue;
NTSTATUS status;
WDF_IO_QUEUE_CONFIG queueConfig;
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchParallel
);
queueConfig.EvtIoStop = bareflankEvtIoStop;
queueConfig.EvtIoDeviceControl = bareflankEvtIoDeviceControl;
status = WdfIoQueueCreate(Device, &queueConfig, WDF_NO_OBJECT_ATTRIBUTES, &queue);
if (!NT_SUCCESS(status))
return status;
if (common_init() != BF_SUCCESS)
{
ALERT("common_init failed\n");
return STATUS_ACCESS_DENIED;
}
DEBUG("bareflankQueueInitialize: success\n");
return STATUS_SUCCESS;
}
NTSTATUS
LoopbackDeviceCreateIoQueue(_In_ WDFDEVICE device)
{
TraceEntry();
NTSTATUS status = STATUS_SUCCESS;
WDF_IO_QUEUE_CONFIG config;
//
// Register I/O callbacks to tell the framework that you are interested
// in handling read and write requests.
//
// A default queue is where requests are delivered by the framework
// by default unless specific request handlers are configured using
// WdfDeviceConfigureRequestDispatching.
//
// WdfIoQueueDispatchSequential means that the queue is setup to dispatch
// no more than one WDFREQUEST at a time, so driver does not need to
// protect data that could be accessed by the queue's callbacks concurrently
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&config, WdfIoQueueDispatchSequential);
config.PowerManaged = WdfTrue;
config.EvtIoWrite = LoopbackEvtIoWrite;
config.EvtIoRead = LoopbackEvtIoRead;
config.EvtIoDeviceControl = LoopbackEvtIoDeviceControl;
status = WdfIoQueueCreate(
device,
&config,
WDF_NO_OBJECT_ATTRIBUTES,
nullptr);
TraceStatusAndReturn(status);
}
NTSTATUS
KMDFDriver1QueueInitialize(
_In_ WDFDEVICE Device
)
/*++
Routine Description:
The I/O dispatch callbacks for the frameworks device object
are configured in this function.
A single default I/O Queue is configured for parallel request
processing, and a driver context memory allocation is created
to hold our structure QUEUE_CONTEXT.
Arguments:
Device - Handle to a framework device object.
Return Value:
VOID
--*/
{
WDFQUEUE queue;
NTSTATUS status;
WDF_IO_QUEUE_CONFIG queueConfig;
PAGED_CODE();
//
// Configure a default queue so that requests that are not
// configure-fowarded using WdfDeviceConfigureRequestDispatching to goto
// other queues get dispatched here.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchParallel
);
queueConfig.EvtIoDeviceControl = KMDFDriver1EvtIoDeviceControl;
queueConfig.EvtIoStop = KMDFDriver1EvtIoStop;
status = WdfIoQueueCreate(
Device,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue
);
if( !NT_SUCCESS(status) ) {
TraceEvents(TRACE_LEVEL_ERROR, TRACE_QUEUE, "WdfIoQueueCreate failed %!STATUS!", status);
return status;
}
return status;
}
NTSTATUS
DefaultQueueCreate(
_In_ WDFDEVICE Device
)
/*++
Routine Description:
Creates and configures the default IO Queue for the device.
Arguments:
Device - Handle to a framework device object.
Return Value:
Appropriate NTSTATUS message
--*/
{
NTSTATUS Status;
WDF_IO_QUEUE_CONFIG QueueConfig;
TraceEntry();
PAGED_CODE();
//
// Create the default queue
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&QueueConfig,
WdfIoQueueDispatchParallel
);
QueueConfig.PowerManaged = WdfTrue;
QueueConfig.EvtIoDeviceControl = DefaultQueue_EvtIoDeviceControl;
QueueConfig.EvtIoInternalDeviceControl = DefaultQueue_EvtIoInternalDeviceControl;
Status = WdfIoQueueCreate(
Device,
&QueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
NULL);
CHK_NT_MSG(Status, "WdfIoQueueCreate failed");
End:
TraceExit();
return Status;
}
//
// 创建队列。
NTSTATUS DrvClass::CreateWDFQueues()
{
NTSTATUS status = STATUS_SUCCESS;
WDF_IO_QUEUE_CONFIG ioQConfig;
KDBG(DPFLTR_INFO_LEVEL, "[CreateWDFQueues]");
// 创建默认并发队列，处理DeviceIOControl命令。
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQConfig, WdfIoQueueDispatchParallel);
ioQConfig.EvtIoDefault = EventDefault_sta;
status = WdfIoQueueCreate(m_hDevice, &ioQConfig, WDF_NO_OBJECT_ATTRIBUTES, &m_hDefQueue);
if(!NT_SUCCESS(status))
{
KDBG(DPFLTR_INFO_LEVEL, "WdfIoQueueCreate failed with status 0x%08x\n", status);
}
return status;
}
NTSTATUS MouseTrapEvtDeviceAdd(WDFDRIVER driver, PWDFDEVICE_INIT deviceInit) {
UNREFERENCED_PARAMETER(driver);
PAGED_CODE(); // Ensure paging is allowed in current IRQL
// Create filter
WdfFdoInitSetFilter(deviceInit);
// Set driver type to mouse
WdfDeviceInitSetDeviceType(deviceInit, FILE_DEVICE_MOUSE);
// Create attributes for a device extension
WDF_OBJECT_ATTRIBUTES deviceAttributes;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&deviceAttributes, DEVICE_CONTEXT);
// Create framework device object
WDFDEVICE hDevice;
NTSTATUS status = WdfDeviceCreate(&deviceInit, &deviceAttributes, &hDevice);
if(!NT_SUCCESS(status)) {
DebugPrint(("[MouseTrap] WdfDeviceCreate failed with status code 0x%x\n", status));
return status;
}
// Set request queue type
WDF_IO_QUEUE_CONFIG ioQueueConfig;
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig, WdfIoQueueDispatchParallel);
// Set handler for device control requests
ioQueueConfig.EvtIoInternalDeviceControl = MouseTrapEvtIoInternalDeviceControl;
// Create queue for filter device
status = WdfIoQueueCreate(hDevice, &ioQueueConfig, WDF_NO_OBJECT_ATTRIBUTES, WDF_NO_HANDLE);
if(!NT_SUCCESS(status)) {
DebugPrint(("[MouseTrap] WdfIoQueueCreate failed 0x%x\n", status));
return status;
}
return status;
}
NTSTATUS
MonitorCtlDriverInit(
_In_ WDFDEVICE* pDevice
)
/*++
Routine Description:
Initializes the request queue for our driver. This is how
DeviceIoControl requests are sent to KMDF drivers.
Arguments:
[in] WDFDEVICE* pDevice - Our device.
--*/
{
NTSTATUS status;
WDF_IO_QUEUE_CONFIG queueConfig;
DoTraceMessage(TRACE_INIT, "MonitorSample Control Initialization in progress.");
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchSequential
);
queueConfig.EvtIoDeviceControl = MonitorEvtDeviceControl;
status = WdfIoQueueCreate(
*pDevice,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
NULL
);
return status;
}
NTSTATUS
tgwinkQueueInitialize(
_In_ WDFDEVICE Device
)
{
NTSTATUS status;
WDF_IO_QUEUE_CONFIG queueConfig;
PDEVICE_CONTEXT deviceContext;
PAGED_CODE();
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchSequential
);
queueConfig.EvtIoDeviceControl = tgwinkEvtIoDeviceControl;
queueConfig.EvtIoStop = tgwinkEvtIoStop;
queueConfig.EvtIoRead = tgwinkEvtIoRead;
queueConfig.EvtIoWrite = tgwinkEvtIoWrite;
deviceContext = DeviceGetContext(Device);
status = WdfIoQueueCreate(
Device,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&deviceContext->IoDefaultQueue
);
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig, WdfIoQueueDispatchManual);
status = WdfIoQueueCreate(
Device,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&deviceContext->NotificationQueue);
return status;
}
NTSTATUS AndroidUsbDeviceObject::CreateDefaultQueue() {
ASSERT_IRQL_PASSIVE();
// Register I/O callbacks to tell the framework that we are interested
// in handling WdfRequestTypeRead, WdfRequestTypeWrite, and
// WdfRequestTypeDeviceControl requests. WdfIoQueueDispatchParallel means
// that we are capable of handling all the I/O request simultaneously and we
// are responsible for protecting data that could be accessed by these
// callbacks simultaneously. This queue will be, by default, automanaged by
// the framework with respect to PnP and Power events. That is, framework
// will take care of queuing, failing, dispatching incoming requests based
// on the current PnP / Power state of the device. We also need to register
// a EvtIoStop handler so that we can acknowledge requests that are pending
// at the target driver.
WDF_IO_QUEUE_CONFIG io_queue_config;
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&io_queue_config,
WdfIoQueueDispatchParallel);
io_queue_config.EvtIoDeviceControl = EvtIoDeviceControlEntry;
io_queue_config.EvtIoRead = EvtIoReadEntry;
io_queue_config.EvtIoWrite = EvtIoWriteEntry;
io_queue_config.AllowZeroLengthRequests = TRUE;
// By default KMDF will take care of the power management of this queue
io_queue_config.PowerManaged = WdfUseDefault;
// Create queue object
WDFQUEUE wdf_queue_obj = NULL;
NTSTATUS status = WdfIoQueueCreate(wdf_device(),
&io_queue_config,
WDF_NO_OBJECT_ATTRIBUTES,
&wdf_queue_obj);
ASSERT(NT_SUCCESS(status) && (NULL != wdf_queue_obj));
if (!NT_SUCCESS(status))
return status;
return STATUS_SUCCESS;
}
NTSTATUS
OnDeviceAdd(
_In_ WDFDRIVER FxDriver,
_Inout_ PWDFDEVICE_INIT FxDeviceInit
)
/*++
Routine Description:
This routine creates the device object for an SPB
controller and the device's child objects.
Arguments:
FxDriver - the WDF driver object handle
FxDeviceInit - information about the PDO that we are loading on
Return Value:
Status
--*/
{
FuncEntry(TRACE_FLAG_WDFLOADING);
PDEVICE_CONTEXT pDevice;
WDFDEVICE fxDevice;
WDF_INTERRUPT_CONFIG interruptConfig;
NTSTATUS status;
UNREFERENCED_PARAMETER(FxDriver);
//
// Tell framework this is a filter driver. Filter drivers by default are
// not power policy owners. This works well for this driver because
// HIDclass driver is the power policy owner for HID minidrivers.
//
WdfFdoInitSetFilter(FxDeviceInit);
//
// Setup PNP/Power callbacks.
//
{
WDF_PNPPOWER_EVENT_CALLBACKS pnpCallbacks;
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpCallbacks);
pnpCallbacks.EvtDevicePrepareHardware = OnPrepareHardware;
pnpCallbacks.EvtDeviceReleaseHardware = OnReleaseHardware;
pnpCallbacks.EvtDeviceD0Entry = OnD0Entry;
pnpCallbacks.EvtDeviceD0Exit = OnD0Exit;
WdfDeviceInitSetPnpPowerEventCallbacks(FxDeviceInit, &pnpCallbacks);
}
//
// Set request attributes.
//
{
WDF_OBJECT_ATTRIBUTES attributes;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(
&attributes,
REQUEST_CONTEXT);
WdfDeviceInitSetRequestAttributes(FxDeviceInit, &attributes);
}
//
// Create the device.
//
{
WDF_OBJECT_ATTRIBUTES deviceAttributes;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&deviceAttributes, DEVICE_CONTEXT);
status = WdfDeviceCreate(
&FxDeviceInit,
&deviceAttributes,
&fxDevice);
if (!NT_SUCCESS(status))
{
CyapaPrint(
TRACE_LEVEL_ERROR,
TRACE_FLAG_WDFLOADING,
"Error creating WDFDEVICE - %!STATUS!",
status);
goto exit;
}
pDevice = GetDeviceContext(fxDevice);
NT_ASSERT(pDevice != nullptr);
pDevice->FxDevice = fxDevice;
}
//
// Ensure device is disable-able
//
{
WDF_DEVICE_STATE deviceState;
WDF_DEVICE_STATE_INIT(&deviceState);
deviceState.NotDisableable = WdfFalse;
WdfDeviceSetDeviceState(pDevice->FxDevice, &deviceState);
}
//
// Create queues to handle IO
//
{
WDF_IO_QUEUE_CONFIG queueConfig;
WDFQUEUE queue;
//
// Top-level queue
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchParallel);
queueConfig.EvtIoDefault = OnTopLevelIoDefault;
queueConfig.PowerManaged = WdfFalse;
status = WdfIoQueueCreate(
pDevice->FxDevice,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue
);
if (!NT_SUCCESS(status))
{
CyapaPrint(
TRACE_LEVEL_ERROR,
TRACE_FLAG_WDFLOADING,
"Error creating top-level IO queue - %!STATUS!",
status);
goto exit;
}
//
// Sequential SPB queue
//
WDF_IO_QUEUE_CONFIG_INIT(
&queueConfig,
WdfIoQueueDispatchSequential);
queueConfig.EvtIoInternalDeviceControl = OnIoDeviceControl;
queueConfig.PowerManaged = WdfFalse;
status = WdfIoQueueCreate(
fxDevice,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&pDevice->SpbQueue
);
if (!NT_SUCCESS(status))
{
CyapaPrint(DEBUG_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed 0x%x\n", status);
goto exit;
}
}
WDF_IO_QUEUE_CONFIG queueConfig;
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig, WdfIoQueueDispatchManual);
queueConfig.PowerManaged = WdfFalse;
status = WdfIoQueueCreate(pDevice->FxDevice,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&pDevice->ReportQueue
);
if (!NT_SUCCESS(status))
{
CyapaPrint(DEBUG_LEVEL_ERROR, DBG_PNP, "Queue 2!\n");
CyapaPrint(DEBUG_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed 0x%x\n", status);
return status;
}
//
// Create an interrupt object for hardware notifications
//
WDF_INTERRUPT_CONFIG_INIT(
&interruptConfig,
OnInterruptIsr,
NULL);
interruptConfig.PassiveHandling = TRUE;
status = WdfInterruptCreate(
fxDevice,
&interruptConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&pDevice->Interrupt);
if (!NT_SUCCESS(status))
{
CyapaPrint(DEBUG_LEVEL_ERROR, DBG_PNP,
"Error creating WDF interrupt object - %!STATUS!",
status);
goto exit;
}
WDF_TIMER_CONFIG timerConfig;
WDFTIMER hTimer;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_TIMER_CONFIG_INIT_PERIODIC(&timerConfig, CyapaTimerFunc, 10);
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = fxDevice;
status = WdfTimerCreate(&timerConfig, &attributes, &hTimer);
pDevice->Timer = hTimer;
if (!NT_SUCCESS(status))
{
CyapaPrint(DEBUG_LEVEL_ERROR, DBG_PNP, "(%!FUNC!) WdfTimerCreate failed status:%!STATUS!\n", status);
return status;
}
CyapaPrint(DEBUG_LEVEL_ERROR, DBG_PNP,
"Success! 0x%x\n", status);
pDevice->DeviceMode = DEVICE_MODE_MOUSE;
exit:
FuncExit(TRACE_FLAG_WDFLOADING);
return status;
}
/*++
Routine Description:
EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager. We create and initialize a device object to
represent a new instance of the device. All the software resources
should be allocated in this callback.
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
NTSTATUS PSDrv_EvtDeviceAdd(IN WDFDRIVER Driver, IN PWDFDEVICE_INIT DeviceInit)
{
WDF_FILEOBJECT_CONFIG fileConfig;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_OBJECT_ATTRIBUTES fdoAttributes;
WDF_OBJECT_ATTRIBUTES fileObjectAttributes;
WDF_OBJECT_ATTRIBUTES requestAttributes;
NTSTATUS status;
WDFDEVICE device;
WDF_DEVICE_PNP_CAPABILITIES pnpCaps;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
PDEVICE_CONTEXT pDevContext;
WDFQUEUE queue;
ULONG maximumTransferSize;
UNREFERENCED_PARAMETER(Driver);
PSDrv_DbgPrint (3, ("PSDrv_EvtDeviceAdd - begins\n"));
PAGED_CODE();
// Initialize the pnpPowerCallbacks structure. Callback events for PNP
// and Power are specified here. If you don't supply any callbacks,
// the Framework will take appropriate default actions based on whether
// DeviceInit is initialized to be an FDO, a PDO or a filter device
// object.
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
pnpPowerCallbacks.EvtDevicePrepareHardware = PSDrv_EvtDevicePrepareHardware;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
// Initialize the request attributes to specify the context size and type
// for every request created by framework for this device.
WDF_OBJECT_ATTRIBUTES_INIT(&requestAttributes);
WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(&requestAttributes, REQUEST_CONTEXT);
WdfDeviceInitSetRequestAttributes(DeviceInit, &requestAttributes);
// Initialize WDF_FILEOBJECT_CONFIG_INIT struct to tell the
// framework whether you are interested in handle Create, Close and
// Cleanup requests that gets generate when an application or another
// kernel component opens an handle to the device. If you don't register
// the framework default behaviour would be complete these requests
// with STATUS_SUCCESS. A driver might be interested in registering these
// events if it wants to do security validation and also wants to maintain
// per handle (fileobject) context.
WDF_FILEOBJECT_CONFIG_INIT(&fileConfig, PSDrv_EvtDeviceFileCreate, WDF_NO_EVENT_CALLBACK, WDF_NO_EVENT_CALLBACK);
// Specify a context for FileObject. If you register FILE_EVENT callbacks,
// the framework by default creates a framework FILEOBJECT corresponding
// to the WDM fileobject. If you want to track any per handle context,
// use the context for FileObject. Driver that typically use FsContext
// field should instead use Framework FileObject context.
WDF_OBJECT_ATTRIBUTES_INIT(&fileObjectAttributes);
WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(&fileObjectAttributes, FILE_CONTEXT);
WdfDeviceInitSetFileObjectConfig(DeviceInit, &fileConfig, &fileObjectAttributes);
// We can do iso transfer only if the io type is directio.
WdfDeviceInitSetIoType(DeviceInit, WdfDeviceIoDirect);
// Now specify the size of device extension where we track per device
// context.DeviceInit is completely initialized. So call the framework
// to create the device and attach it to the lower stack.
WDF_OBJECT_ATTRIBUTES_INIT(&fdoAttributes);
WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(&fdoAttributes, DEVICE_CONTEXT);
status = WdfDeviceCreate(&DeviceInit, &fdoAttributes, &device);
if (!NT_SUCCESS(status))
{
PSDrv_DbgPrint(1, ("WdfDeviceCreate failed! (Status = %x)\n", status));
return status;
}
// Get the DeviceObject context by using accessory function specified in
// the WDF_DECLARE_CONTEXT_TYPE_WITH_NAME macro for DEVICE_CONTEXT.
pDevContext = GetDeviceContext(device);
//Get MaximumTransferSize from registry
maximumTransferSize=0;
status = ReadFdoRegistryKeyValue(Driver, L"MaximumTransferSize", &maximumTransferSize);
if (!NT_SUCCESS(status))
{
PSDrv_DbgPrint(1, ("ReadFdoRegistryKeyValue failed with Status code %!STATUS!\n", status));
return status;
}
if (maximumTransferSize)
{
pDevContext->MaximumTransferSize = maximumTransferSize;
}
else
{
pDevContext->MaximumTransferSize = DEFAULT_REGISTRY_TRANSFER_SIZE;
}
// Tell the framework to set the SurpriseRemovalOK in the DeviceCaps so
// that you don't get the popup in usermode (on Win2K) when you surprise
// remove the device.
WDF_DEVICE_PNP_CAPABILITIES_INIT(&pnpCaps);
// Do not show the little green remove icon
pnpCaps.SurpriseRemovalOK = WdfTrue;
/*
// Show the little green remove icon...
pnpCaps.SurpriseRemovalOK = WdfFalse;
pnpCaps.Removable = WdfTrue;
*/
WdfDeviceSetPnpCapabilities(device, &pnpCaps);
// Register I/O callbacks to tell the framework that you are interested
// in handling WdfRequestTypeRead, WdfRequestTypeWrite, and IRP_MJ_DEVICE_CONTROL requests.
// WdfIoQueueDispatchParallel means that we are capable of handling
// all the I/O request simultaneously and we are responsible for protecting
// data that could be accessed by these callbacks simultaneously.
// This queue will be, by default, auto managed by the framework with
// respect to PNP and Power events. That is, framework will take care
// of queuing, failing, dispatching incoming requests based on the current
// pnp/power state of the device.
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig, WdfIoQueueDispatchParallel);
ioQueueConfig.EvtIoRead = PSDrv_EvtIoRead;
ioQueueConfig.EvtIoWrite = PSDrv_EvtIoWrite;
ioQueueConfig.EvtIoDeviceControl = PSDrv_EvtIoDeviceControl;
ioQueueConfig.EvtIoStop = PSDrvEvtIoStop;
ioQueueConfig.EvtIoResume = PSDrvEvtIoResume;
status = WdfIoQueueCreate(device, &ioQueueConfig, WDF_NO_OBJECT_ATTRIBUTES, &queue);
if (!NT_SUCCESS(status))
{
PSDrv_DbgPrint(1, ("WdfIoQueueCreate failed! (Status = %x)\n", status));
return status;
}
// Register a device interface so that app can find our device and talk to it.
status = WdfDeviceCreateDeviceInterface(device, (LPGUID)&GUID_CLASS_PSDRV_USB, NULL);
if (!NT_SUCCESS(status))
{
PSDrv_DbgPrint(1, ("WdfDeviceCreateDeviceInterface failed! (Status = %x)\n", status));
return status;
}
PSDrv_DbgPrint(3, ("PSDrv_EvtDeviceAdd - ends\n"));
return status;
}
NTSTATUS
HidFx2EvtDeviceAdd(
IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
HidFx2EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager. We create and initialize a WDF device object to
represent a new instance of toaster device.
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
WDF_IO_QUEUE_CONFIG queueConfig;
WDF_OBJECT_ATTRIBUTES attributes;
WDFDEVICE hDevice;
PDEVICE_EXTENSION devContext = NULL;
WDFQUEUE queue;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_TIMER_CONFIG timerConfig;
WDFTIMER timerHandle;
UNREFERENCED_PARAMETER(Driver);
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
"HidFx2EvtDeviceAdd called\n");
//
// Tell framework this is a filter driver. Filter drivers by default are
// not power policy owners. This works well for this driver because
// HIDclass driver is the power policy owner for HID minidrivers.
//
WdfFdoInitSetFilter(DeviceInit);
//
// Initialize pnp-power callbacks, attributes and a context area for the device object.
//
//
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
//
// For usb devices, PrepareHardware callback is the to place select the
// interface and configure the device.
//
pnpPowerCallbacks.EvtDevicePrepareHardware = HidFx2EvtDevicePrepareHardware;
//
// These two callbacks start and stop the wdfusb pipe continuous reader
// as we go in and out of the D0-working state.
//
pnpPowerCallbacks.EvtDeviceD0Entry = HidFx2EvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = HidFx2EvtDeviceD0Exit;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, DEVICE_EXTENSION);
//
// Create a framework device object.This call will in turn create
// a WDM device object, attach to the lower stack, and set the
// appropriate flags and attributes.
//
status = WdfDeviceCreate(&DeviceInit, &attributes, &hDevice);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceCreate failed with status code 0x%x\n", status);
return status;
}
devContext = GetDeviceContext(hDevice);
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&queueConfig, WdfIoQueueDispatchParallel);
queueConfig.EvtIoInternalDeviceControl = HidFx2EvtInternalDeviceControl;
status = WdfIoQueueCreate(hDevice,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue
);
if (!NT_SUCCESS (status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed 0x%x\n", status);
return status;
}
//
// Register a manual I/O queue for handling Interrupt Message Read Requests.
// This queue will be used for storing Requests that need to wait for an
// interrupt to occur before they can be completed.
//
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig, WdfIoQueueDispatchManual);
//
// This queue is used for requests that dont directly access the device. The
// requests in this queue are serviced only when the device is in a fully
// powered state and sends an interrupt. So we can use a non-power managed
// queue to park the requests since we dont care whether the device is idle
// or fully powered up.
//
queueConfig.PowerManaged = WdfFalse;
status = WdfIoQueueCreate(hDevice,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&devContext->InterruptMsgQueue
);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed 0x%x\n", status);
return status;
}
//
// Create a timer to handle debouncing of switchpack
//
WDF_TIMER_CONFIG_INIT(
&timerConfig,
HidFx2EvtTimerFunction
);
timerConfig.AutomaticSerialization = FALSE;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = hDevice;
status = WdfTimerCreate(
&timerConfig,
&attributes,
&timerHandle
);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfTimerCreate failed status:0x%x\n", status);
return status;
}
devContext->DebounceTimer = timerHandle;
return status;
}
///////////////////////////////////////////////////////////////////////////////
//
// BasicUsbEvtDeviceAdd
//
// This routine is called by the framework when a device of
// the type we support is found in the system.
//
// INPUTS:
//
// DriverObject - Our WDFDRIVER object
//
// DeviceInit - The device iniitalization structure we'll
// be using to create our WDFDEVICE
//
// OUTPUTS:
//
// None.
//
// RETURNS:
//
// STATUS_SUCCESS, otherwise an error indicating why the driver could not
// load.
//
// IRQL:
//
// This routine is called at IRQL == PASSIVE_LEVEL.
//
// NOTES:
//
//
///////////////////////////////////////////////////////////////////////////////
NTSTATUS
BasicUsbEvtDeviceAdd(WDFDRIVER Driver, PWDFDEVICE_INIT DeviceInit)
{
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES objAttributes;
WDFDEVICE device;
WDF_IO_QUEUE_CONFIG queueConfig;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
PBASICUSB_DEVICE_CONTEXT devContext;
#if DBG
DbgPrint("BasicUsbEvtDeviceAdd\n");
#endif
//
// Our "internal" (native) and user-accessible device names
//
DECLARE_CONST_UNICODE_STRING(nativeDeviceName, L"\\Device\\BasicUsb");
DECLARE_CONST_UNICODE_STRING(userDeviceName, L"\\Global??\\BasicUsb");
UNREFERENCED_PARAMETER(Driver);
//
// Life is a bit more complicated in this driver...
//
// We need an EvtPrepareHardware to configure our device. In addition, we
// must handle EvtD0Entry and EvtD0Exit in order to manage our continuous
// reader.
//
//
// Prepare for WDFDEVICE creation
//
// Initialize standard WDF Object Attributes structure
//
WDF_OBJECT_ATTRIBUTES_INIT(&objAttributes);
//
// Specify our device context
//
WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(&objAttributes,
BASICUSB_DEVICE_CONTEXT);
//
// We want our device object NAMED, thank you very much
//
status = WdfDeviceInitAssignName(DeviceInit, &nativeDeviceName);
if (!NT_SUCCESS(status)) {
#if DBG
DbgPrint("WdfDeviceInitAssignName failed 0x%0x\n", status);
#endif
return(status);
}
//
// Set our I/O type to DIRECT, meaning that we want to receive
// MDLs for both read and write requests.
//
// While we are not obligated to choose direct, USB drivers
// typically do so because the USB bus driver needs MDLs to
// actually perform the transfer. If we select DIRECT I/O, the
// bus driver can just use the MDL that we're given as opposed
// to creating his own.
//
WdfDeviceInitSetIoType(DeviceInit, WdfDeviceIoDirect);
//
// In this driver we need to be notified of some Pnp/Power
// events, so initialize a pnp power callbacks structure.
//
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
//
// USB drivers configure their device within prepare hardware,
// so register an EvtDevicePrepareHardware callback.
//
pnpPowerCallbacks.EvtDevicePrepareHardware
= BasicUsbEvtDevicePrepareHardware;
//
// Our driver uses a continuous reader on the interrupt pipe to
// be notified asynchronously of changes to the OSRFX2's
// switchpack. We need to start the reader in D0Entry and stop
// it in D0Exit, so register for EvtDeviceD0Entry and
// EvtDeviceD0Exit callbacks
//
pnpPowerCallbacks.EvtDeviceD0Entry = BasicUsbEvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = BasicUsbEvtDeviceD0Exit;
//
// Update the DeviceInit structure to contain the new callbacks.
//
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit,
&pnpPowerCallbacks);
//
// We want to send control transfers synchronously from within
// EvtIoDeviceControl, so we'll apply a PASSIVE_LEVEL constraint
// to our device
//
objAttributes.ExecutionLevel = WdfExecutionLevelPassive;
//
// Now let's create our device object
//
status = WdfDeviceCreate(&DeviceInit,
&objAttributes,
&device);
if (!NT_SUCCESS(status)) {
#if DBG
DbgPrint("WdfDeviceCreate failed 0x%0x\n", status);
#endif
return status;
}
//
// Create a symbolic link for the control object so that usermode can open
// the device by name.
//
status = WdfDeviceCreateSymbolicLink(device, &userDeviceName);
if (!NT_SUCCESS(status)) {
#if DBG
DbgPrint("WdfDeviceCreateSymbolicLink failed 0x%0x\n", status);
#endif
return(status);
}
//
// ALSO create a device interface for the device
// This allows usage of the lovely SetupApiXxxx functions to locate
// the device
//
status = WdfDeviceCreateDeviceInterface(device,
&GUID_DEVINTERFACE_BASICUSB,
NULL);
if (!NT_SUCCESS(status)) {
#if DBG
DbgPrint("WdfDeviceCreateDeviceInterface failed 0x%0x\n", status);
#endif
return(status);
}
//
// Configure our queue of incoming requests
//
// We only use the default queue, and we set it for parallel processing.
// We chose this because we may have, say, a bulk read hanging on the bus
// driver that won't get completed until we send down a bulk write.
//
// If we chose a sequential queue we wouldn't be presented the write from
// the user until the read completed, but the read wouldn't complete
// until we were presented the write from the user - resulting in an "I/O
// deadlock".
//
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&queueConfig,
WdfIoQueueDispatchParallel);
//
// Declare our I/O Event Processing callbacks
//
// We handle, read, write, and device control requests.
//
// WDF will automagically handle Create and Close requests for us and will
// will complete any OTHER request types with STATUS_INVALID_DEVICE_REQUEST.
//
queueConfig.EvtIoRead = BasicUsbEvtRead;
queueConfig.EvtIoWrite = BasicUsbEvtWrite;
queueConfig.EvtIoDeviceControl = BasicUsbEvtDeviceControl;
//
// Because this is a queue for a real hardware
// device, indicate that the queue needs to be
// power managed
//
queueConfig.PowerManaged = WdfTrue;
status = WdfIoQueueCreate(device,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
NULL); // optional pointer to receive queue handle
if (!NT_SUCCESS(status)) {
#if DBG
DbgPrint("WdfIoQueueCreate for default queue failed 0x%0x\n", status);
#endif
return(status);
}
devContext = BasicUsbGetContextFromDevice(device);
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig,
WdfIoQueueDispatchManual);
status = WdfIoQueueCreate(device,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&devContext->SwitchPackStateChangeQueue);
if (!NT_SUCCESS(status)) {
#if DBG
DbgPrint("WdfIoQueueCreate for manual queue failed 0x%0x\n", status);
#endif
return(status);
}
return(STATUS_SUCCESS);
}
NTSTATUS
QueueCreate(
_In_ WDFDEVICE Device,
_Out_ WDFQUEUE *Queue
)
/*++
Routine Description:
This function creates a default, parallel I/O queue to proces IOCTLs
from hidclass.sys.
Arguments:
Device - Handle to a framework device object.
Queue - Output pointer to a framework I/O queue handle, on success.
Return Value:
NTSTATUS
--*/
{
NTSTATUS status;
WDF_IO_QUEUE_CONFIG queueConfig;
WDF_OBJECT_ATTRIBUTES queueAttributes;
WDFQUEUE queue;
PQUEUE_CONTEXT queueContext;
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchParallel);
#ifdef _KERNEL_MODE
queueConfig.EvtIoInternalDeviceControl = EvtIoDeviceControl;
#else
//
// HIDclass uses INTERNAL_IOCTL which is not supported by UMDF. Therefore
// the hidumdf.sys changes the IOCTL type to DEVICE_CONTROL for next stack
// and sends it down
//
queueConfig.EvtIoDeviceControl = EvtIoDeviceControl;
#endif
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(
&queueAttributes,
QUEUE_CONTEXT);
status = WdfIoQueueCreate(
Device,
&queueConfig,
&queueAttributes,
&queue);
if( !NT_SUCCESS(status) ) {
KdPrint(("WdfIoQueueCreate failed 0x%x\n",status));
return status;
}
queueContext = GetQueueContext(queue);
queueContext->Queue = queue;
queueContext->DeviceContext = GetDeviceContext(Device);
queueContext->OutputReport = 0;
*Queue = queue;
return status;
}
NTSTATUS
FilterEvtDeviceAdd(
IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager. Here you can query the device properties
using WdfFdoInitWdmGetPhysicalDevice/IoGetDeviceProperty and based
on that, decide to create a filter device object and attach to the
function stack. If you are not interested in filtering this particular
instance of the device, you can just return STATUS_SUCCESS without creating
a framework device.
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
{
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_OBJECT_ATTRIBUTES deviceAttributes;
PFILTER_EXTENSION filterExt;
NTSTATUS status;
WDFDEVICE device;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
WDFQUEUE hQueue;
PAGED_CODE ();
UNREFERENCED_PARAMETER(Driver);
KdPrint(("--> FilterEvtDeviceAdd\n"));
//
// Tell the framework that you are filter driver. Framework
// takes care of inherting all the device flags & characterstics
// from the lower device you are attaching to.
//
WdfFdoInitSetFilter(DeviceInit);
//
// Initialize the pnpPowerCallbacks structure. Callback events for PNP
// and Power are specified here. If you don't supply any callbacks,
// the Framework will take appropriate default actions based on whether
// DeviceInit is initialized to be an FDO, a PDO or a filter device
// object.
//
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
//
// For usb devices, PrepareHardware callback is the to place select the
// interface and configure the device.
//
pnpPowerCallbacks.EvtDevicePrepareHardware = FilterEvtDevicePrepareHardware;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
//
// Specify the size of device extension where we track per device
// context.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&deviceAttributes, FILTER_EXTENSION);
//
// Create a framework device object.This call will inturn create
// a WDM deviceobject, attach to the lower stack and set the
// appropriate flags and attributes.
//
status = WdfDeviceCreate(&DeviceInit, &deviceAttributes, &device);
if (!NT_SUCCESS(status)) {
KdPrint( ("WdfDeviceCreate failed with status code 0x%x\n", status));
return status;
}
filterExt = FilterGetData(device);
//
// Configure the default queue to be Parallel.
// to handle IOCTLs that will be forwarded to us from
// the rawPDO.
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchParallel);
//
// Framework by default creates non-power managed queues for
// filter drivers.
//
ioQueueConfig.EvtIoDeviceControl = FilterEvtIoDeviceControlFromRawPdo;
status = WdfIoQueueCreate(device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&hQueue // pointer to default queue
);
if (!NT_SUCCESS(status)) {
KdPrint( ("WdfIoQueueCreate failed 0x%x\n", status));
return status;
}
filterExt->rawPdoQueue = hQueue;
//
// Create a RAW pdo so we can provide a sideband communication with
// the application. Please note that not filter drivers desire to
// produce such a communication and not all of them are contrained
// by other filter above which prevent communication thru the device
// interface exposed by the main stack. So use this only if absolutely
// needed. Also look at the toaster filter driver sample for an alternate
// approach to providing sideband communication.
//
status = FiltrCreateRawPdo(device, ++InstanceNo);
KdPrint(("<-- FilterEvtDeviceAdd\n"));
return status;
}
NTSTATUS
OnDeviceAdd(
_In_ WDFDRIVER FxDriver,
_Inout_ PWDFDEVICE_INIT FxDeviceInit
)
/*++
Routine Description:
This routine creates the device object for an SPB
controller and the device's child objects.
Arguments:
FxDriver - the WDF driver object handle
FxDeviceInit - information about the PDO that we are loading on
Return Value:
Status
--*/
{
//FuncEntry(TRACE_FLAG_WDFLOADING);
PDEVICE_CONTEXT pDevice;
NTSTATUS status;
UNREFERENCED_PARAMETER(FxDriver);
//
// Setup PNP/Power callbacks.
//
{
WDF_PNPPOWER_EVENT_CALLBACKS pnpCallbacks;
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpCallbacks);
pnpCallbacks.EvtDevicePrepareHardware = OnPrepareHardware;
pnpCallbacks.EvtDeviceReleaseHardware = OnReleaseHardware;
pnpCallbacks.EvtDeviceD0Entry = OnD0Entry;
pnpCallbacks.EvtDeviceD0Exit = OnD0Exit;
WdfDeviceInitSetPnpPowerEventCallbacks(FxDeviceInit, &pnpCallbacks);
}
//
// Prepare for file object handling.
//
{
WDF_FILEOBJECT_CONFIG fileObjectConfig;
WDF_FILEOBJECT_CONFIG_INIT(
&fileObjectConfig,
nullptr,
nullptr,
OnFileCleanup);
WDF_OBJECT_ATTRIBUTES fileObjectAttributes;
WDF_OBJECT_ATTRIBUTES_INIT(&fileObjectAttributes);
WdfDeviceInitSetFileObjectConfig(
FxDeviceInit,
&fileObjectConfig,
&fileObjectAttributes);
}
//
// Set request attributes.
//
{
WDF_OBJECT_ATTRIBUTES attributes;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(
&attributes,
REQUEST_CONTEXT);
WdfDeviceInitSetRequestAttributes(FxDeviceInit, &attributes);
}
//
// Create the device.
//
{
WDFDEVICE fxDevice;
WDF_OBJECT_ATTRIBUTES deviceAttributes;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&deviceAttributes, DEVICE_CONTEXT);
status = WdfDeviceCreate(
&FxDeviceInit,
&deviceAttributes,
&fxDevice);
if (!NT_SUCCESS(status))
{
Trace(
TRACE_LEVEL_ERROR,
TRACE_FLAG_WDFLOADING,
"Error creating WDFDEVICE - %!STATUS!",
status);
goto exit;
}
pDevice = GetDeviceContext(fxDevice);
NT_ASSERT(pDevice != nullptr);
pDevice->FxDevice = fxDevice;
}
//
// Ensure device is disable-able
//
{
WDF_DEVICE_STATE deviceState;
WDF_DEVICE_STATE_INIT(&deviceState);
deviceState.NotDisableable = WdfFalse;
WdfDeviceSetDeviceState(pDevice->FxDevice, &deviceState);
}
//
// Create queues to handle IO
//
{
WDF_IO_QUEUE_CONFIG queueConfig;
WDFQUEUE queue;
//
// Top-level queue
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchParallel);
queueConfig.EvtIoDefault = OnTopLevelIoDefault;
queueConfig.PowerManaged = WdfFalse;
status = WdfIoQueueCreate(
pDevice->FxDevice,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue
);
if (!NT_SUCCESS(status))
{
Trace(
TRACE_LEVEL_ERROR,
TRACE_FLAG_WDFLOADING,
"Error creating top-level IO queue - %!STATUS!",
status);
goto exit;
}
//
// Sequential SPB queue
//
WDF_IO_QUEUE_CONFIG_INIT(
&queueConfig,
WdfIoQueueDispatchSequential);
queueConfig.EvtIoRead = OnIoRead;
queueConfig.EvtIoWrite = OnIoWrite;
queueConfig.EvtIoDeviceControl = OnIoDeviceControl;
queueConfig.PowerManaged = WdfFalse;
status = WdfIoQueueCreate(
pDevice->FxDevice,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&pDevice->SpbQueue
);
if (!NT_SUCCESS(status))
{
Trace(
TRACE_LEVEL_ERROR,
TRACE_FLAG_WDFLOADING,
"Error creating SPB IO queue - %!STATUS!",
status);
goto exit;
}
}
//
// Create a symbolic link.
//
{
DECLARE_UNICODE_STRING_SIZE(symbolicLinkName, 128);
status = RtlUnicodeStringPrintf(
&symbolicLinkName, L"%ws",
sensy_SYMBOLIC_NAME);
if (!NT_SUCCESS(status))
{
Trace(
TRACE_LEVEL_ERROR,
TRACE_FLAG_WDFLOADING,
"Error creating symbolic link string for device "
"- %!STATUS!",
status);
goto exit;
}
status = WdfDeviceCreateSymbolicLink(
pDevice->FxDevice,
&symbolicLinkName);
if (!NT_SUCCESS(status))
{
Trace(
TRACE_LEVEL_ERROR,
TRACE_FLAG_WDFLOADING,
"Error creating symbolic link for device "
"- %!STATUS!",
status);
goto exit;
}
}
//
// Retrieve registry settings.
//
{
WDFKEY key = NULL;
WDFKEY subkey = NULL;
ULONG connectInterrupt = 0;
NTSTATUS settingStatus;
DECLARE_CONST_UNICODE_STRING(subkeyName, L"Settings");
DECLARE_CONST_UNICODE_STRING(connectInterruptName, L"ConnectInterrupt");
settingStatus = WdfDeviceOpenRegistryKey(
pDevice->FxDevice,
PLUGPLAY_REGKEY_DEVICE,
KEY_READ,
WDF_NO_OBJECT_ATTRIBUTES,
&key);
if (!NT_SUCCESS(settingStatus))
{
Trace(
TRACE_LEVEL_WARNING,
TRACE_FLAG_WDFLOADING,
"Error opening device registry key - %!STATUS!",
settingStatus);
}
if (NT_SUCCESS(settingStatus))
{
settingStatus = WdfRegistryOpenKey(
key,
&subkeyName,
KEY_READ,
WDF_NO_OBJECT_ATTRIBUTES,
&subkey);
if (!NT_SUCCESS(settingStatus))
{
Trace(
TRACE_LEVEL_WARNING,
TRACE_FLAG_WDFLOADING,
"Error opening registry subkey for 'Settings' - %!STATUS!",
settingStatus);
}
}
if (NT_SUCCESS(settingStatus))
{
settingStatus = WdfRegistryQueryULong(
subkey,
&connectInterruptName,
&connectInterrupt);
if (!NT_SUCCESS(settingStatus))
{
Trace(
TRACE_LEVEL_WARNING,
TRACE_FLAG_WDFLOADING,
"Error querying registry value for 'ConnectInterrupt' - %!STATUS!",
settingStatus);
}
}
if (key != NULL)
{
WdfRegistryClose(key);
}
if (subkey != NULL)
{
WdfRegistryClose(subkey);
}
pDevice->ConnectInterrupt = (connectInterrupt == 1);
}
exit:
//FuncExit(TRACE_FLAG_WDFLOADING);
return status;
}
VCHIQ_PAGED_SEGMENT_BEGIN
/*++
Routine Description:
Worker routine called to create a device and its software resources.
Arguments:
DeviceInitPtr - Pointer to an opaque init structure. Memory for this
structure will be freed by the framework when the WdfDeviceCreate
succeeds. So don't access the structure after that point.
Return Value:
NTSTATUS
--*/
_Use_decl_annotations_
NTSTATUS VchiqCreateDevice (
WDFDRIVER Driver,
PWDFDEVICE_INIT DeviceInitPtr
)
{
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_OBJECT_ATTRIBUTES deviceAttributes;
DEVICE_CONTEXT* deviceContextPtr;
WDFDEVICE device;
NTSTATUS status;
WDF_IO_TYPE_CONFIG ioConfig;
DECLARE_CONST_UNICODE_STRING(vchiqSymbolicLink, VCHIQ_SYMBOLIC_NAME);
UNREFERENCED_PARAMETER(Driver);
PAGED_CODE();
{
WDF_FILEOBJECT_CONFIG fileobjectConfig;
WDF_FILEOBJECT_CONFIG_INIT(
&fileobjectConfig,
WDF_NO_EVENT_CALLBACK,
VchiqFileClose,
WDF_NO_EVENT_CALLBACK);
fileobjectConfig.FileObjectClass = WdfFileObjectWdfCanUseFsContext;
WdfDeviceInitSetFileObjectConfig(
DeviceInitPtr,
&fileobjectConfig,
WDF_NO_OBJECT_ATTRIBUTES);
}
WDF_IO_TYPE_CONFIG_INIT(&ioConfig);
ioConfig.ReadWriteIoType = WdfDeviceIoDirect;
ioConfig.DeviceControlIoType = WdfDeviceIoDirect;
ioConfig.DirectTransferThreshold = 0;
WdfDeviceInitSetIoTypeEx(DeviceInitPtr, &ioConfig);
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
pnpPowerCallbacks.EvtDevicePrepareHardware =
VchiqPrepareHardware;
pnpPowerCallbacks.EvtDeviceReleaseHardware =
VchiqReleaseHardware;
pnpPowerCallbacks.EvtDeviceD0EntryPostInterruptsEnabled =
VchiqInitOperation;
WdfDeviceInitSetPnpPowerEventCallbacks(
DeviceInitPtr,
&pnpPowerCallbacks);
WdfDeviceInitSetIoInCallerContextCallback(
DeviceInitPtr,
VchiqInCallerContext);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(
&deviceAttributes,
DEVICE_CONTEXT);
status = WdfDeviceCreate(
&DeviceInitPtr,
&deviceAttributes,
&device);
if (!NT_SUCCESS(status)) {
VCHIQ_LOG_ERROR(
"WdfDeviceCreate fail %!STATUS!", status);
goto End;
}
{
WDF_OBJECT_ATTRIBUTES attributes;
WDF_IO_QUEUE_CONFIG queueConfig;
WDFQUEUE queue;
deviceContextPtr = VchiqGetDeviceContext(device);
deviceContextPtr->Device = device;
deviceContextPtr->VersionMajor = VCHIQ_VERSION_MAJOR;
deviceContextPtr->VersionMinor = VCHIQ_VERSION_MINOR;
deviceContextPtr->PhyDeviceObjectPtr =
WdfDeviceWdmGetPhysicalDevice(device);
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchParallel);
queueConfig.EvtIoDeviceControl = VchiqIoDeviceControl;
queueConfig.EvtIoStop = VchiqIoStop;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ExecutionLevel = WdfExecutionLevelPassive;
status = WdfIoQueueCreate(
device,
&queueConfig,
&attributes,
&queue);
if (!NT_SUCCESS(status)) {
VCHIQ_LOG_ERROR(
"WdfIoQueueCreate fail %!STATUS!", status);
goto End;
}
}
// Create symbolic and device interface
status = WdfDeviceCreateSymbolicLink(
device,
&vchiqSymbolicLink);
if (!NT_SUCCESS(status)) {
VCHIQ_LOG_ERROR(
"Fail to register symbolic link %!STATUS!",
status);
goto End;
}
End:
VCHIQ_LOG_INFORMATION("Exit Status %!STATUS!", status);
return status;
}
NTSTATUS
AmccPciAddDevice(
_In_ WDFDRIVER Driver,
_Inout_ PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager. It is responsible for initializing and
creating a WDFDEVICE object.
Any work that should be done after the object is created should be
deferred until EvtDeviceSoftwareInit, as that callback will be made
with the device lock held (if there is one.)
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_OBJECT_ATTRIBUTES fdoAttributes;
WDF_INTERRUPT_CONFIG interruptConfig;
WDF_OBJECT_ATTRIBUTES interruptAttributes;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
PAMCC_DEVICE_EXTENSION devExt;
WDFQUEUE hQueue;
WDFDEVICE device;
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, AMCC_TRACE_INIT,
"AmccPciAddDevice: 0x%p", Driver);
//
// Zero out the PnpPowerCallbacks structure.
//
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
//
// Set Callbacks for any of the functions we are interested in.
// If no callback is set, Framework will take the default action
// by itself.
//
pnpPowerCallbacks.EvtDevicePrepareHardware = AmccPciEvtDevicePrepareHardware;
pnpPowerCallbacks.EvtDeviceReleaseHardware = AmccPciEvtDeviceReleaseHardware;
pnpPowerCallbacks.EvtDeviceD0Entry = AmccPciEvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = AmccPciEvtDeviceD0Exit;
//
// Register the PnP Callbacks..
//
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
//
// Set various attributes for this device
//
WdfDeviceInitSetIoType( DeviceInit, WdfDeviceIoDirect );
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&fdoAttributes, AMCC_DEVICE_EXTENSION);
fdoAttributes.EvtCleanupCallback = AmccPciContextCleanup;
//
// We want all the queue callbacks, cancel routine, and DpcForIsr to be serialized
// at the device level, so we don't have worry about any synchronization issues.
//
fdoAttributes.SynchronizationScope = WdfSynchronizationScopeDevice;
status = WdfDeviceCreate( &DeviceInit, &fdoAttributes, &device );
if ( !NT_SUCCESS(status) ) {
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"WdfDeviceInitialize failed 0x%X", status);
return status;
}
//
// Device Initialization is complete.
// Get the Device Extension and initialize it.
//
devExt = AmccPciGetDevExt(device);
devExt->Device = device;
TraceEvents(TRACE_LEVEL_INFORMATION, AMCC_TRACE_INIT,
"PDO 0x%p, FDO 0x%p, DevExt 0x%p",
WdfDeviceWdmGetPhysicalDevice(device),
WdfDeviceWdmGetDeviceObject( device ), devExt);
//
// This device generates an interrupt. So create an interrupt object which
// will later be associated with the devices resources and connected
// by the Framework.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&interruptAttributes, INTERRUPT_DATA);
//
// Configure the Interrupt object
//
WDF_INTERRUPT_CONFIG_INIT(&interruptConfig,
AmccPciEvtInterruptIsr,
AmccPciEvtInterruptDpc);
status = WdfInterruptCreate(device,
&interruptConfig,
&interruptAttributes,
&devExt->WdfInterrupt);
if (!NT_SUCCESS (status))
{
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"WdfInterruptCreate failed: %!STATUS!\n", status);
return status;
}
//
// The S5933 requires DMA buffers be aligned on a 32-bit boundary
//
// NOTE: Read the existing alignment value. If it is greater than
// or equal then keep it. If it is less then update the
// alignment requirement field with this device's required
// value.
//
// NOTE: See the MSDN section titled "Initializing a Device Object"
// for details on how to specify this alignment value.
//
// NOTE: AMCC5933_ALIGNMENT__32BITS is equated to (4-1) for 32-bit
// alignment.
//
{
ULONG alignReq;
alignReq = WdfDeviceGetAlignmentRequirement( device );
if (alignReq < AMCC5933_ALIGNMENT__32BITS) {
//
// Set the S5933 alignment requirement as new value.
//
WdfDeviceSetAlignmentRequirement( device,
AMCC5933_ALIGNMENT__32BITS);
}
}
//
// Register I/O callbacks.
//
// Create a sequential IO Queue for serial operation. That means all the requests (Read/Write
// & IOCTL) are serialized to the device. Until the driver completes the request presented to it,
// the framework will not schedule another one. The requests held in the framework will be
// cancelled automatically if the source of request (application) terminate or cancels it.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE( &ioQueueConfig,
WdfIoQueueDispatchSequential);
ioQueueConfig.EvtIoDefault = AmccPciEvtIoDefault;
//
// By default, Static Driver Verifier (SDV) displays a warning if it
// doesn't find the EvtIoStop callback on a power-managed queue.
// The 'assume' below causes SDV to suppress this warning. If the driver
// has not explicitly set PowerManaged to WdfFalse, the framework creates
// power-managed queues when the device is not a filter driver. Normally
// the EvtIoStop is required for power-managed queues, but for this driver
// it is not needed b/c the driver doesn't hold on to the requests for
// long time or forward them to other drivers.
// If the EvtIoStop callback is not implemented, the framework waits for
// all driver-owned requests to be done before moving in the Dx/sleep
// states or before removing the device, which is the correct behavior
// for this type of driver. If the requests were taking an indeterminate
// amount of time to complete, or if the driver forwarded the requests
// to a lower driver/another stack, the queue should have an
// EvtIoStop/EvtIoResume.
//
__analysis_assume(ioQueueConfig.EvtIoStop != 0);
status = WdfIoQueueCreate( device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&hQueue );
__analysis_assume(ioQueueConfig.EvtIoStop == 0);
if (!NT_SUCCESS (status)) {
//
// We don't have worry about deleting the device here because framework will automatically
// cleanup that when the driver unloads.
//
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"WdfIoQueueCreate failed %!STATUS!", status);
return status;
}
//
// Register an interface so that application can find and talk to us.
// NOTE: See the note in Public.h concerning this GUID value.
//
status = WdfDeviceCreateDeviceInterface( device,
(LPGUID) &GUID_DEVINTERFACE_AMCC_PCI,
NULL );
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"<-- AMCCAddDevice: WdfDeviceCreateDeviceInterface failed %!STATUS!", status);
return status;
}
devExt->MaximumTransferLength = MAXIMUM_REQUEST_CONTEXT_LENGTH;
//
// Set the maximum physical pages for now, but this value may change if
// there aren't enough map registers
//
devExt->MaximumPhysicalPages = MAXIMUM_PHYSICAL_PAGES;
return status;
}
NTSTATUS
NfcCxEvtDeviceInitialize(
_In_ PNFCCX_DRIVER_GLOBALS NfcCxGlobals,
_In_ WDFDEVICE Device
)
/*++
Routine Description:
This routine is called by the CX client to indicate
that a device initialization is required.
Arguments:
NfcCxGlobal - CX global pointer
Device - WDF device to initialize
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
WDF_OBJECT_ATTRIBUTES fdoAttributes;
WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS idleSettings;
WDF_IO_QUEUE_CONFIG queueConfig;
PNFCCX_FDO_CONTEXT fdoContext;
WDFQUEUE queue;
PNFCCX_CLIENT_GLOBALS nfcCxClientGlobal;
WDF_OBJECT_ATTRIBUTES objectAttrib;
TRACE_FUNCTION_ENTRY(LEVEL_VERBOSE);
if (!VerifyPrivateGlobals(NfcCxGlobals)) {
TRACE_LINE(LEVEL_ERROR, "Invalid CX global pointer");
status = STATUS_INVALID_PARAMETER;
goto Done;
}
nfcCxClientGlobal = GetPrivateGlobals(NfcCxGlobals);
//
// Create class extension device context
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&fdoAttributes, NFCCX_FDO_CONTEXT);
fdoAttributes.EvtCleanupCallback = NfcCxFdoContextCleanup;
status = WdfObjectAllocateContext(Device, &fdoAttributes, (PVOID*)&fdoContext);
if (!NT_SUCCESS(status)) {
TRACE_LINE(LEVEL_ERROR, "Failed to allocate the client context");
goto Done;
}
fdoContext->Device = Device;
fdoContext->NfpRadioInterfaceCreated = FALSE;
fdoContext->NfpPowerOffSystemOverride = FALSE;
fdoContext->NfpPowerOffPolicyOverride = FALSE;
fdoContext->NfpPowerPolicyReferences = 0;
fdoContext->SERadioInterfaceCreated = FALSE;
fdoContext->SEPowerOffSystemOverride = FALSE;
fdoContext->SEPowerOffPolicyOverride = FALSE;
fdoContext->SEPowerPolicyReferences = 0;
fdoContext->NfcCxClientGlobal = nfcCxClientGlobal;
status = NfcCxFdoReadCxDriverRegistrySettings(&fdoContext->LogNciDataMessages);
if (!NT_SUCCESS(status)) {
TRACE_LINE(LEVEL_ERROR, "NfcCxFdoReadCxDriverRegistrySettings failed, %!STATUS!", status);
goto Done;
}
WDF_OBJECT_ATTRIBUTES_INIT(&objectAttrib);
objectAttrib.ParentObject = Device;
status = WdfWaitLockCreate(&objectAttrib,
&fdoContext->PowerPolicyWaitLock);
if (!NT_SUCCESS(status)) {
TRACE_LINE(LEVEL_ERROR, "Failed to create the PowerPolicy WaitLock, %!STATUS!", status);
goto Done;
}
//
// Register I/O callbacks to tell the framework that you are interested
// in handling IRP_MJ_DEVICE_CONTROL requests.
//
// In case a specific handler is not specified for one of these,
// the request will be dispatched to the EvtIoDefault handler, if any.
// If there is no EvtIoDefault handler, the request will be failed with
// STATUS_INVALID_DEVICE_REQUEST.
//
// WdfIoQueueDispatchParallel means that we are capable of handling
// all the I/O request simultaneously and we are responsible for protecting
// data that could be accessed by these callbacks simultaneously.
// A default queue gets all the requests that are not
// configure-fowarded using WdfDeviceConfigureRequestDispatching.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&queueConfig,
WdfIoQueueDispatchParallel);
//
// Our default queue is non power managed. Based on the request and the Radio on/off
// state, we forward the request to the power managed queue to wake the system as
// appropriate
//
queueConfig.PowerManaged = WdfFalse;
queueConfig.EvtIoDeviceControl = NfcCxEvtDefaultIoControl;
WDF_OBJECT_ATTRIBUTES_INIT(&objectAttrib);
objectAttrib.ParentObject = Device;
status = WdfIoQueueCreate(Device,
&queueConfig,
&objectAttrib,
&queue
);
if (!NT_SUCCESS (status)) {
TRACE_LINE(LEVEL_ERROR, "WdfIoQueueCreate failed %!STATUS!", status);
goto Done;
}
fdoContext->DefaultQueue = queue;
//
// Our internal queue is non power managed because we need to send IO during.
// D0Entry/D0Exit routines. It is the default queue for SelfIoTarget requests.
//
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig,
WdfIoQueueDispatchParallel);
queueConfig.PowerManaged = WdfFalse;
queueConfig.EvtIoDeviceControl = NfcCxEvtSelfIoControl;
WDF_OBJECT_ATTRIBUTES_INIT(&objectAttrib);
objectAttrib.ParentObject = Device;
status = WdfIoQueueCreate(Device,
&queueConfig,
&objectAttrib,
&queue
);
if (!NT_SUCCESS (status)) {
TRACE_LINE(LEVEL_ERROR, "WdfIoQueueCreate failed %!STATUS!", status);
goto Done;
}
fdoContext->SelfQueue = queue;
//
// Assign our internal queue as the default queue for the SelfIoTarget. Any IO
// sent to the SelfIoTarget would be dispatched from this queue.
//
status = WdfIoTargetSelfAssignDefaultIoQueue(WdfDeviceGetSelfIoTarget(Device),
fdoContext->SelfQueue);
if (!NT_SUCCESS (status)) {
TRACE_LINE(LEVEL_ERROR, "WdfIoTargetSelfAssignDefaultIoQueue failed %!STATUS!", status);
goto Done;
}
status = NfcCxFdoCreate(fdoContext);
if (!NT_SUCCESS(status)) {
TRACE_LINE(LEVEL_ERROR, "Failed to create the Fdo context failed %!STATUS!", status);
goto Done;
}
if (NFC_CX_DEVICE_MODE_NCI == fdoContext->NfcCxClientGlobal->Config.DeviceMode) {
//
// Read the FDO's persisted settings from the registry
//
status = NfcCxFdoReadPersistedDeviceRegistrySettings(fdoContext);
if (!NT_SUCCESS(status)) {
TRACE_LINE(LEVEL_ERROR, "NfcCxFdoReadPersistedDeviceRegistrySettings, %!STATUS!", status);
goto Done;
}
//
// Log all settings that could have been overridden from the registry.
//
EventWriteDevicePersistedRegistrySettings(fdoContext->NfpPowerOffPolicyOverride,
fdoContext->NfpPowerOffSystemOverride,
fdoContext->SEPowerOffPolicyOverride,
fdoContext->SEPowerOffSystemOverride);
//
// Check the currently required power state
//
fdoContext->NfpRadioState = (!fdoContext->NfpPowerOffPolicyOverride && !fdoContext->NfpPowerOffSystemOverride);
fdoContext->SERadioState = (!fdoContext->SEPowerOffPolicyOverride && !fdoContext->SEPowerOffSystemOverride);
}
//
// The class extension is the default power policy owner. This option allows the client
// to now be the power policy owner
//
if (fdoContext->NfcCxClientGlobal->Config.IsPowerPolicyOwner == WdfUseDefault) {
fdoContext->NfcCxClientGlobal->Config.IsPowerPolicyOwner = WdfFalse;
}
if (fdoContext->NfcCxClientGlobal->Config.IsPowerPolicyOwner == WdfFalse) {
//
// Set the idle power policy to put the device to Dx if the device is not used
// for the specified IdleTimeout time. Since this is a non wakeable device we
// tell the framework that we cannot wake ourself if we sleep in S0. Only
// way the device can be brought to D0 is if the device recieves an I/O from
// the system.
//
WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_INIT(&idleSettings, IdleCannotWakeFromS0);
idleSettings.IdleTimeoutType = fdoContext->NfcCxClientGlobal->Config.PowerIdleType;
idleSettings.IdleTimeout = fdoContext->NfcCxClientGlobal->Config.PowerIdleTimeout;
status = WdfDeviceAssignS0IdleSettings(Device, &idleSettings);
if (!NT_SUCCESS(status)) {
TRACE_LINE(LEVEL_ERROR, "WdfDeviceAssignS0IdleSettings failed %!STATUS!", status);
goto Done;
}
}
Done:
TRACE_FUNCTION_EXIT_NTSTATUS(LEVEL_VERBOSE, status);
TRACE_LOG_NTSTATUS_ON_FAILURE(status);
return status;
}
NTSTATUS
kmdf1394_EvtDeviceAdd (
IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit)
/*++
Routine Description:
EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager.
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PDEVICE_EXTENSION deviceExtension;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_OBJECT_ATTRIBUTES fdoAttributes,lockAttributes;
WDFDEVICE device;
WDF_DEVICE_PNP_CAPABILITIES pnpCaps;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
UNREFERENCED_PARAMETER (Driver);
PAGED_CODE();
Enter();
//
// Zero out the PnpPowerCallbacks structure.
//
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
//
// Set Callbacks for any of the functions we are interested in.
// If no callback is set, Framework will take the default action
// by itself.
//
// These two callbacks set up and tear down hardware state,
// specifically that which only has to be done once.
//
pnpPowerCallbacks.EvtDevicePrepareHardware = kmdf1394_EvtPrepareHardware;
pnpPowerCallbacks.EvtDeviceReleaseHardware = kmdf1394_EvtReleaseHardware;
pnpPowerCallbacks.EvtDeviceSelfManagedIoCleanup = \
kmdf1394_EvtDeviceSelfManagedIoCleanup;
pnpPowerCallbacks.EvtDeviceD0Entry = kmdf1394_EvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = kmdf1394_EvtDeviceD0Exit;
//
// Register the PnP and power callbacks. Power policy related callbacks
// will be registered// later in SotwareInit.
//
WdfDeviceInitSetPnpPowerEventCallbacks (DeviceInit, &pnpPowerCallbacks);
if (!NT_SUCCESS (ntStatus))
{
DoTraceLevelMessage(TRACE_LEVEL_ERROR,
TRACE_FLAG_PNP,
"WdfDeviceInitSetPnpPowerEventCallbacks failed %!STATUS!\n",
ntStatus);
return ntStatus;
}
//
// We'll allow multiple handles to be opened to this device driver
// so we'll set exclusivity to FALSE.
//
WdfDeviceInitSetExclusive (DeviceInit, FALSE);
//
// Specify the size and type of device context.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE (&fdoAttributes, DEVICE_EXTENSION);
ntStatus = WdfDeviceCreate (&DeviceInit, &fdoAttributes, &device);
if (!NT_SUCCESS (ntStatus))
{
DoTraceLevelMessage(TRACE_LEVEL_ERROR,
TRACE_FLAG_PNP,
"WdfDeviceInitialize failed %!STATUS!\n",
ntStatus);
return ntStatus;
}
deviceExtension = GetDeviceContext (device);
deviceExtension->WdfDevice = device;
DoTraceLevelMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_PNP,
"PDO(0x%p) FDO(0x%p), Lower(0x%p) DevExt (0x%p)\n",
WdfDeviceWdmGetPhysicalDevice (device),
WdfDeviceWdmGetDeviceObject (device),
WdfDeviceWdmGetAttachedDevice(device),
deviceExtension);
//
// Tell the Framework that this device will need an interface so that
// application can interact with it.
//
ntStatus = WdfDeviceCreateDeviceInterface (
device,
(LPGUID) &GUID_KMDF_VDEV,
NULL);
if (!NT_SUCCESS (ntStatus))
{
DoTraceLevelMessage(TRACE_LEVEL_ERROR,
TRACE_FLAG_PNP,
"WdfDeviceCreateDeviceInterface failed %!STATUS!\n",
ntStatus);
return ntStatus;
}
//
// Tell the framework to set the SurpriseRemovalOK in the DeviceCaps so
// that you don't get the popup in usermode (on Win2K) when you surprise
// remove the device.
//
WDF_DEVICE_PNP_CAPABILITIES_INIT (&pnpCaps);
pnpCaps.SurpriseRemovalOK = WdfTrue;
WdfDeviceSetPnpCapabilities (device, &pnpCaps);
//
// save the device object we created as our physical device object
//
deviceExtension->PhysicalDeviceObject = \
WdfDeviceWdmGetPhysicalDevice (device);
if (NULL == deviceExtension->PhysicalDeviceObject)
{
DoTraceLevelMessage(TRACE_LEVEL_ERROR,
TRACE_FLAG_PNP,
"WdfDeviceWdmGetPhysicalDevice: NULL DeviceObject\n");
return STATUS_UNSUCCESSFUL;
}
//
// This is our default IoTarget representing the deviceobject
// we are attached to.
//
deviceExtension->StackIoTarget = WdfDeviceGetIoTarget(device);
deviceExtension->StackDeviceObject = WdfDeviceWdmGetAttachedDevice(device);
if (NULL == deviceExtension->StackDeviceObject)
{
DoTraceLevelMessage(TRACE_LEVEL_ERROR,
TRACE_FLAG_PNP,
"WdfDeviceWdmGetAttachedDevice: NULL DeviceObject\n");
return STATUS_UNSUCCESSFUL;
}
//
// Create a automanaged queue for dispatching ioctl requests.
// All other requests are automatically failed by the framework.
// By creating an automanaged queue we don't have to worry about
// PNP/Power synchronization.
// A default queue gets all the requests that are not
// configure-fowarded using WdfDeviceConfigureRequestDispatching.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE (
&ioQueueConfig,
WdfIoQueueDispatchParallel);
ioQueueConfig.EvtIoDeviceControl = kmdf1394_EvtIoDeviceControl;
__analysis_assume(ioQueueConfig.EvtIoStop != 0);
ntStatus = WdfIoQueueCreate (
deviceExtension->WdfDevice,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&deviceExtension->IoctlQueue);
__analysis_assume(ioQueueConfig.EvtIoStop == 0);
if (!NT_SUCCESS (ntStatus))
{
DoTraceLevelMessage(TRACE_LEVEL_ERROR,
TRACE_FLAG_PNP,
"WdfIoQueueCreate failed %!STATUS!\n",
ntStatus);
return ntStatus;
}
//
// Create an additional queue to hold bus reset requests.
//
WDF_IO_QUEUE_CONFIG_INIT (&ioQueueConfig, WdfIoQueueDispatchManual);
__analysis_assume(ioQueueConfig.EvtIoStop != 0);
ntStatus = WdfIoQueueCreate (
deviceExtension->WdfDevice,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&deviceExtension->BusResetRequestsQueue);
__analysis_assume(ioQueueConfig.EvtIoStop == 0);
if(!NT_SUCCESS (ntStatus))
{
DoTraceLevelMessage(TRACE_LEVEL_ERROR,
TRACE_FLAG_PNP,
"Error Creating Reset Request Queue %!STATUS!\n",
ntStatus);
return ntStatus;
}
WDF_OBJECT_ATTRIBUTES_INIT (&lockAttributes);
lockAttributes.ParentObject = device;
ntStatus = WdfSpinLockCreate (&lockAttributes,&deviceExtension->CromSpinLock);
if(!NT_SUCCESS (ntStatus))
{
DoTraceLevelMessage(TRACE_LEVEL_ERROR,
TRACE_FLAG_PNP,
"WdfSpinLockCreate CromSpinLock failed %!STATUS!\n",
ntStatus);
return ntStatus;
}
WDF_OBJECT_ATTRIBUTES_INIT (&lockAttributes);
lockAttributes.ParentObject = device;
ntStatus = WdfSpinLockCreate (
&lockAttributes,
&deviceExtension->AsyncSpinLock);
if(!NT_SUCCESS (ntStatus))
{
DoTraceLevelMessage(TRACE_LEVEL_ERROR,
TRACE_FLAG_PNP,
"WdfSpinLockCreate AsyncSpinLock failed %!STATUS!\n",
ntStatus);
return ntStatus;
}
WDF_OBJECT_ATTRIBUTES_INIT (&lockAttributes);
lockAttributes.ParentObject = device;
ntStatus = WdfSpinLockCreate (
&lockAttributes,
&deviceExtension->IsochSpinLock );
if(!NT_SUCCESS (ntStatus))
{
DoTraceLevelMessage(TRACE_LEVEL_ERROR,
TRACE_FLAG_PNP,
"WdfSpinLockCreate IsochSpinLock failed %!STATUS!\n",
ntStatus);
return ntStatus;
}
WDF_OBJECT_ATTRIBUTES_INIT (&lockAttributes);
lockAttributes.ParentObject = device;
ntStatus = WdfSpinLockCreate (
&lockAttributes,
&deviceExtension->IsochResourceSpinLock);
if(!NT_SUCCESS (ntStatus))
{
DoTraceLevelMessage(TRACE_LEVEL_ERROR,
TRACE_FLAG_PNP,
"WdfSpinLockCreate IsochResourceSpinLock failed %!STATUS!\n",
ntStatus);
return ntStatus;
}
InitializeListHead (&deviceExtension->CromData);
InitializeListHead (&deviceExtension->AsyncAddressData);
InitializeListHead (&deviceExtension->IsochDetachData);
InitializeListHead (&deviceExtension->IsochResourceData);
ExitS(ntStatus);
return(ntStatus);
} // kmdf1394_PnpAddDevice
///////////////////////////////////////////////////////////////////////////////
//
// CDFilterEvtDeviceAdd
//
// This routine is called by the framework when a device of
// the type we filter is found in the system.
//
// INPUTS:
//
// DriverObject - Our WDFDRIVER object
//
// DeviceInit - The device iniitalization structure we'll
// be using to create our WDFDEVICE
//
// OUTPUTS:
//
// None.
//
// RETURNS:
//
// STATUS_SUCCESS, otherwise an error indicating why the driver could not
// load.
//
// IRQL:
//
// This routine is called at IRQL == PASSIVE_LEVEL.
//
// NOTES:
//
//
///////////////////////////////////////////////////////////////////////////////
NTSTATUS
CDFilterEvtDeviceAdd(WDFDRIVER Driver, PWDFDEVICE_INIT DeviceInit)
{
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES wdfObjectAttr;
WDFDEVICE wdfDevice;
PFILTER_DEVICE_CONTEXT devContext;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
#if DBG
DbgPrint("CDFilterEvtDeviceAdd: Adding device...\n");
#endif
UNREFERENCED_PARAMETER(Driver);
//
// Indicate that we're creating a FILTER device. This will cause
// KMDF to attach us correctly to the device stack and auto-forward
// any requests we don't explicitly handle.
//
WdfFdoInitSetFilter(DeviceInit);
//
// Setup our device attributes to have our context type
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&wdfObjectAttr,
FILTER_DEVICE_CONTEXT);
//
// And create our WDF device. This does a multitude of things,
// including:
//
// 1) Creating a WDM device object
// 2) Attaching the device object to the filtered device object
// 3) Propogates all of the flags and characteristics of the
// target device to our filter device. So, for example, if
// the target device is setup for direct I/O our filter
// device will also be setup for direct I/O
//
status = WdfDeviceCreate(&DeviceInit,
&wdfObjectAttr,
&wdfDevice);
if (!NT_SUCCESS(status)) {
#if DBG
DbgPrint("WdfDeviceCreate failed - 0x%x\n", status);
#endif
return status;
}
//
// Get our filter context
//
devContext = CDFilterGetDeviceContext(wdfDevice);
//
// Get our local (aka "in-stack") I/O Target. This is the device
// to which we'll be forwarding requests that we intercept (and
// hence aren't automagically forwarded).
//
devContext->TargetToSendRequestsTo = WdfDeviceGetIoTarget(wdfDevice);
//
// Now that that's over with, we can create our default queue.
// This queue will allow us to pick off any I/O requests
// that we may be interested in before they are forwarded
// to the target device.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchParallel);
//
// For this exercise we'll intercept READ requests
//
ioQueueConfig.EvtIoRead = CDFilterEvtRead;
//
// Create the queue...
//
status = WdfIoQueueCreate(wdfDevice,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
NULL);
if (!NT_SUCCESS(status)) {
#if DBG
DbgPrint("WdfIoQueueCreate failed - 0x%x\n", status);
#endif
return status;
}
//
// Success!
//
return STATUS_SUCCESS;
}
NTSTATUS
OsrFxEvtDeviceAdd(
WDFDRIVER Driver,
PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager. We create and initialize a device object to
represent a new instance of the device. All the software resources
should be allocated in this callback.
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
{
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_OBJECT_ATTRIBUTES attributes;
NTSTATUS status;
WDFDEVICE device;
WDF_DEVICE_PNP_CAPABILITIES pnpCaps;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
PDEVICE_CONTEXT pDevContext;
WDFQUEUE queue;
GUID activity;
UNREFERENCED_PARAMETER(Driver);
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,"--> OsrFxEvtDeviceAdd routine\n");
//
// Initialize the pnpPowerCallbacks structure. Callback events for PNP
// and Power are specified here. If you don't supply any callbacks,
// the Framework will take appropriate default actions based on whether
// DeviceInit is initialized to be an FDO, a PDO or a filter device
// object.
//
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
//
// For usb devices, PrepareHardware callback is the to place select the
// interface and configure the device.
//
pnpPowerCallbacks.EvtDevicePrepareHardware = OsrFxEvtDevicePrepareHardware;
//
// These two callbacks start and stop the wdfusb pipe continuous reader
// as we go in and out of the D0-working state.
//
pnpPowerCallbacks.EvtDeviceD0Entry = OsrFxEvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = OsrFxEvtDeviceD0Exit;
pnpPowerCallbacks.EvtDeviceSelfManagedIoFlush = OsrFxEvtDeviceSelfManagedIoFlush;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
WdfDeviceInitSetIoType(DeviceInit, WdfDeviceIoBuffered);
//
// Now specify the size of device extension where we track per device
// context.DeviceInit is completely initialized. So call the framework
// to create the device and attach it to the lower stack.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, DEVICE_CONTEXT);
status = WdfDeviceCreate(&DeviceInit, &attributes, &device);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceCreate failed with Status code %!STATUS!\n", status);
return status;
}
//
// Setup the activity ID so that we can log events using it.
//
activity = DeviceToActivityId(device);
//
// Get the DeviceObject context by using accessor function specified in
// the WDF_DECLARE_CONTEXT_TYPE_WITH_NAME macro for DEVICE_CONTEXT.
//
pDevContext = GetDeviceContext(device);
//
// Get the device's friendly name and location so that we can use it in
// error logging. If this fails then it will setup dummy strings.
//
GetDeviceEventLoggingNames(device);
//
// Tell the framework to set the SurpriseRemovalOK in the DeviceCaps so
// that you don't get the popup in usermodewhen you surprise remove the device.
//
WDF_DEVICE_PNP_CAPABILITIES_INIT(&pnpCaps);
pnpCaps.SurpriseRemovalOK = WdfTrue;
WdfDeviceSetPnpCapabilities(device, &pnpCaps);
//
// Create a parallel default queue and register an event callback to
// receive ioctl requests. We will create separate queues for
// handling read and write requests. All other requests will be
// completed with error status automatically by the framework.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchParallel);
ioQueueConfig.EvtIoDeviceControl = OsrFxEvtIoDeviceControl;
//
// By default, Static Driver Verifier (SDV) displays a warning if it
// doesn't find the EvtIoStop callback on a power-managed queue.
// The 'assume' below causes SDV to suppress this warning. If the driver
// has not explicitly set PowerManaged to WdfFalse, the framework creates
// power-managed queues when the device is not a filter driver. Normally
// the EvtIoStop is required for power-managed queues, but for this driver
// it is not needed b/c the driver doesn't hold on to the requests for
// long time or forward them to other drivers.
// If the EvtIoStop callback is not implemented, the framework waits for
// all driver-owned requests to be done before moving in the Dx/sleep
// states or before removing the device, which is the correct behavior
// for this type of driver. If the requests were taking an indeterminate
// amount of time to complete, or if the driver forwarded the requests
// to a lower driver/another stack, the queue should have an
// EvtIoStop/EvtIoResume.
//
__analysis_assume(ioQueueConfig.EvtIoStop != 0);
status = WdfIoQueueCreate(device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue);// pointer to default queue
__analysis_assume(ioQueueConfig.EvtIoStop == 0);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed %!STATUS!\n", status);
goto Error;
}
//
// We will create a separate sequential queue and configure it
// to receive read requests. We also need to register a EvtIoStop
// handler so that we can acknowledge requests that are pending
// at the target driver.
//
WDF_IO_QUEUE_CONFIG_INIT(&ioQueueConfig, WdfIoQueueDispatchSequential);
ioQueueConfig.EvtIoRead = OsrFxEvtIoRead;
ioQueueConfig.EvtIoStop = OsrFxEvtIoStop;
status = WdfIoQueueCreate(
device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue // queue handle
);
if (!NT_SUCCESS (status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed 0x%x\n", status);
goto Error;
}
status = WdfDeviceConfigureRequestDispatching(
device,
queue,
WdfRequestTypeRead);
if(!NT_SUCCESS (status)){
assert(NT_SUCCESS(status));
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceConfigureRequestDispatching failed 0x%x\n", status);
goto Error;
}
//
// We will create another sequential queue and configure it
// to receive write requests.
//
WDF_IO_QUEUE_CONFIG_INIT(&ioQueueConfig, WdfIoQueueDispatchSequential);
ioQueueConfig.EvtIoWrite = OsrFxEvtIoWrite;
ioQueueConfig.EvtIoStop = OsrFxEvtIoStop;
status = WdfIoQueueCreate(
device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue // queue handle
);
if (!NT_SUCCESS (status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed 0x%x\n", status);
goto Error;
}
status = WdfDeviceConfigureRequestDispatching(
device,
queue,
WdfRequestTypeWrite);
if(!NT_SUCCESS (status)){
assert(NT_SUCCESS(status));
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceConfigureRequestDispatching failed 0x%x\n", status);
goto Error;
}
//
// Register a manual I/O queue for handling Interrupt Message Read Requests.
// This queue will be used for storing Requests that need to wait for an
// interrupt to occur before they can be completed.
//
WDF_IO_QUEUE_CONFIG_INIT(&ioQueueConfig, WdfIoQueueDispatchManual);
//
// This queue is used for requests that dont directly access the device. The
// requests in this queue are serviced only when the device is in a fully
// powered state and sends an interrupt. So we can use a non-power managed
// queue to park the requests since we dont care whether the device is idle
// or fully powered up.
//
ioQueueConfig.PowerManaged = WdfFalse;
status = WdfIoQueueCreate(device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&pDevContext->InterruptMsgQueue
);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed 0x%x\n", status);
goto Error;
}
//
// Register a device interface so that app can find our device and talk to it.
//
status = WdfDeviceCreateDeviceInterface(device,
(LPGUID) &GUID_DEVINTERFACE_OSRUSBFX2,
NULL); // Reference String
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceCreateDeviceInterface failed %!STATUS!\n", status);
goto Error;
}
//
// Create the lock that we use to serialize calls to ResetDevice(). As an
// alternative to using a WDFWAITLOCK to serialize the calls, a sequential
// WDFQUEUE can be created and reset IOCTLs would be forwarded to it.
//
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = device;
status = WdfWaitLockCreate(&attributes, &pDevContext->ResetDeviceWaitLock);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfWaitLockCreate failed %!STATUS!\n", status);
goto Error;
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- OsrFxEvtDeviceAdd\n");
return status;
Error:
//
// Log fail to add device to the event log
//
EventWriteFailAddDevice(pDevContext->DeviceName,
pDevContext->Location,
status);
return status;
}
NTSTATUS
FilterEvtDeviceAdd(
IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager. Here you can query the device properties
using WdfFdoInitWdmGetPhysicalDevice/IoGetDeviceProperty and based
on that, decide to create a filter device object and attach to the
function stack. If you are not interested in filtering this particular
instance of the device, you can just return STATUS_SUCCESS without creating
a framework device.
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
{
WDF_OBJECT_ATTRIBUTES deviceAttributes;
PFILTER_EXTENSION filterExt;
NTSTATUS status;
WDFDEVICE device;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
PAGED_CODE ();
UNREFERENCED_PARAMETER(Driver);
//
// Tell the framework that you are filter driver. Framework
// takes care of inherting all the device flags & characterstics
// from the lower device you are attaching to.
//
WdfFdoInitSetFilter(DeviceInit);
//
// Specify the size of device extension where we track per device
// context.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&deviceAttributes, FILTER_EXTENSION);
//
// Create a framework device object.This call will inturn create
// a WDM deviceobject, attach to the lower stack and set the
// appropriate flags and attributes.
//
status = WdfDeviceCreate(&DeviceInit, &deviceAttributes, &device);
if (!NT_SUCCESS(status)) {
KdPrint( ("WdfDeviceCreate failed with status code 0x%x\n", status));
return status;
}
filterExt = FilterGetData(device);
//
// Configure the default queue to be Parallel.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchParallel);
//
// Framework by default creates non-power managed queues for
// filter drivers.
//
ioQueueConfig.EvtIoDeviceControl = FilterEvtIoDeviceControl;
status = WdfIoQueueCreate(device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
WDF_NO_HANDLE // pointer to default queue
);
if (!NT_SUCCESS(status)) {
KdPrint( ("WdfIoQueueCreate failed 0x%x\n", status));
return status;
}
return status;
}
void CWdfDefaultQueue::InitConfig(WDF_IO_QUEUE_CONFIG &QueueConfig)
{
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&QueueConfig, m_DispatchType);
}
NTSTATUS
XenUsb_EvtDriverDeviceAdd(WDFDRIVER driver, PWDFDEVICE_INIT device_init)
{
NTSTATUS status;
WDF_CHILD_LIST_CONFIG child_list_config;
WDFDEVICE device;
PXENUSB_DEVICE_DATA xudd;
//UNICODE_STRING reference;
WDF_OBJECT_ATTRIBUTES device_attributes;
PNP_BUS_INFORMATION pbi;
WDF_PNPPOWER_EVENT_CALLBACKS pnp_power_callbacks;
WDF_DEVICE_POWER_CAPABILITIES power_capabilities;
WDF_IO_QUEUE_CONFIG queue_config;
UCHAR pnp_minor_functions[] = { IRP_MN_QUERY_INTERFACE };
DECLARE_CONST_UNICODE_STRING(symbolicname_name, L"SymbolicName");
WDFSTRING symbolicname_value_wdfstring;
WDFKEY device_key;
UNICODE_STRING symbolicname_value;
UNREFERENCED_PARAMETER(driver);
FUNCTION_ENTER();
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnp_power_callbacks);
pnp_power_callbacks.EvtDeviceD0Entry = XenUsb_EvtDeviceD0Entry;
pnp_power_callbacks.EvtDeviceD0Exit = XenUsb_EvtDeviceD0Exit;
WdfDeviceInitSetPnpPowerEventCallbacks(device_init, &pnp_power_callbacks);
status = WdfDeviceInitAssignWdmIrpPreprocessCallback(device_init, XenUsb_EvtDeviceWdmIrpPreprocessQUERY_INTERFACE,
IRP_MJ_PNP, pnp_minor_functions, ARRAY_SIZE(pnp_minor_functions));
if (!NT_SUCCESS(status))
{
return status;
}
WdfDeviceInitSetDeviceType(device_init, FILE_DEVICE_BUS_EXTENDER);
WdfDeviceInitSetExclusive(device_init, FALSE);
WDF_CHILD_LIST_CONFIG_INIT(&child_list_config, sizeof(XENUSB_PDO_IDENTIFICATION_DESCRIPTION), XenUsb_EvtChildListCreateDevice);
child_list_config.EvtChildListScanForChildren = XenUsb_EvtChildListScanForChildren;
WdfFdoInitSetDefaultChildListConfig(device_init, &child_list_config, WDF_NO_OBJECT_ATTRIBUTES);
WdfDeviceInitSetIoType(device_init, WdfDeviceIoBuffered);
WdfDeviceInitSetPowerNotPageable(device_init);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&device_attributes, XENUSB_DEVICE_DATA);
status = WdfDeviceCreate(&device_init, &device_attributes, &device);
if (!NT_SUCCESS(status))
{
FUNCTION_MSG("Error creating device %08x\n", status);
return status;
}
xudd = GetXudd(device);
xudd->pdo = WdfDeviceWdmGetPhysicalDevice(device);
xudd->child_list = WdfFdoGetDefaultChildList(device);
KeInitializeEvent(&xudd->backend_event, SynchronizationEvent, FALSE);
InitializeListHead(&xudd->partial_pvurb_queue);
InitializeListHead(&xudd->partial_pvurb_ring);
KeInitializeDpc(&xudd->event_dpc, XenUsb_HandleEventDpc, xudd);
KeInitializeSpinLock(&xudd->urb_ring_lock);
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&queue_config, WdfIoQueueDispatchParallel);
queue_config.PowerManaged = FALSE; /* ? */
queue_config.EvtIoDeviceControl = XenUsb_EvtIoDeviceControl;
queue_config.EvtIoInternalDeviceControl = XenUsb_EvtIoInternalDeviceControl;
queue_config.EvtIoDefault = XenUsb_EvtIoDefault;
status = WdfIoQueueCreate(device, &queue_config, WDF_NO_OBJECT_ATTRIBUTES, &xudd->io_queue);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("Error creating io_queue 0x%x\n", status);
return status;
}
WDF_IO_QUEUE_CONFIG_INIT(&queue_config, WdfIoQueueDispatchParallel);
queue_config.PowerManaged = FALSE; /* ? */
//queue_config.EvtIoDeviceControl = XenUsb_EvtIoDeviceControl;
queue_config.EvtIoInternalDeviceControl = XenUsb_EvtIoInternalDeviceControl_PVURB;
//queue_config.EvtIoDefault = XenUsb_EvtIoDefault;
queue_config.Settings.Parallel.NumberOfPresentedRequests = USB_URB_RING_SIZE; /* the queue controls if the ring is full */
status = WdfIoQueueCreate(device, &queue_config, WDF_NO_OBJECT_ATTRIBUTES, &xudd->pvurb_queue);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("Error creating urb_queue 0x%x\n", status);
return status;
}
WDF_DEVICE_POWER_CAPABILITIES_INIT(&power_capabilities);
power_capabilities.DeviceD1 = WdfTrue;
power_capabilities.WakeFromD1 = WdfTrue;
power_capabilities.DeviceWake = PowerDeviceD1;
power_capabilities.DeviceState[PowerSystemWorking] = PowerDeviceD0;
power_capabilities.DeviceState[PowerSystemSleeping1] = PowerDeviceD1;
power_capabilities.DeviceState[PowerSystemSleeping2] = PowerDeviceD2;
power_capabilities.DeviceState[PowerSystemSleeping3] = PowerDeviceD2;
power_capabilities.DeviceState[PowerSystemHibernate] = PowerDeviceD3;
power_capabilities.DeviceState[PowerSystemShutdown] = PowerDeviceD3;
WdfDeviceSetPowerCapabilities(device, &power_capabilities);
WdfDeviceSetSpecialFileSupport(device, WdfSpecialFilePaging, TRUE);
WdfDeviceSetSpecialFileSupport(device, WdfSpecialFileHibernation, TRUE);
WdfDeviceSetSpecialFileSupport(device, WdfSpecialFileDump, TRUE);
pbi.BusTypeGuid = GUID_BUS_TYPE_XEN;
pbi.LegacyBusType = PNPBus;
pbi.BusNumber = 0;
WdfDeviceSetBusInformationForChildren(device, &pbi);
status = WdfDeviceCreateDeviceInterface(device, &GUID_DEVINTERFACE_USB_HOST_CONTROLLER, NULL);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("WdfDeviceCreateDeviceInterface returned %08x\n");
return status;
}
/* USB likes to have a registry key with the symbolic link name in it */
status = WdfStringCreate(NULL, WDF_NO_OBJECT_ATTRIBUTES, &symbolicname_value_wdfstring);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("WdfStringCreate returned %08x\n");
return status;
}
status = WdfDeviceRetrieveDeviceInterfaceString(device, &GUID_DEVINTERFACE_USB_HOST_CONTROLLER, NULL, symbolicname_value_wdfstring);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("WdfDeviceRetrieveDeviceInterfaceString returned %08x\n");
return status;
}
WdfStringGetUnicodeString(symbolicname_value_wdfstring, &symbolicname_value);
status = WdfDeviceOpenRegistryKey(device, PLUGPLAY_REGKEY_DEVICE, KEY_SET_VALUE, WDF_NO_OBJECT_ATTRIBUTES, &device_key);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("WdfDeviceOpenRegistryKey returned %08x\n");
return status;
}
WdfRegistryAssignUnicodeString(device_key, &symbolicname_name, &symbolicname_value);
FUNCTION_EXIT();
return status;
}
NTSTATUS
Bus_EvtDeviceAdd(
IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
Bus_EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager. We create and initialize a device object to
represent a new instance of toaster bus.
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
{
WDF_CHILD_LIST_CONFIG config;
WDF_OBJECT_ATTRIBUTES fdoAttributes;
NTSTATUS status;
WDFDEVICE device;
WDF_IO_QUEUE_CONFIG queueConfig;
PNP_BUS_INFORMATION busInfo;
//PFDO_DEVICE_DATA deviceData;
WDFQUEUE queue;
UNREFERENCED_PARAMETER(Driver);
PAGED_CODE ();
KdPrint(("Bus_EvtDeviceAdd: 0x%p\n", Driver));
//
// Initialize all the properties specific to the device.
// Framework has default values for the one that are not
// set explicitly here. So please read the doc and make sure
// you are okay with the defaults.
//
WdfDeviceInitSetDeviceType(DeviceInit, FILE_DEVICE_BUS_EXTENDER);
WdfDeviceInitSetExclusive(DeviceInit, TRUE);
//
// Since this is pure software bus enumerator, we don't have to register for
// any PNP/Power callbacks. Framework will take the default action for
// all the PNP and Power IRPs.
//
//
// WDF_ DEVICE_LIST_CONFIG describes how the framework should handle
// dynamic child enumeration on behalf of the driver writer.
// Since we are a bus driver, we need to specify identification description
// for our child devices. This description will serve as the identity of our
// child device. Since the description is opaque to the framework, we
// have to provide bunch of callbacks to compare, copy, or free
// any other resources associated with the description.
//
WDF_CHILD_LIST_CONFIG_INIT(&config,
sizeof(PDO_IDENTIFICATION_DESCRIPTION),
Bus_EvtDeviceListCreatePdo // callback to create a child device.
);
//
// This function pointer will be called when the framework needs to copy a
// identification description from one location to another. An implementation
// of this function is only necessary if the description contains description
// relative pointer values (like LIST_ENTRY for instance) .
// If set to NULL, the framework will use RtlCopyMemory to copy an identification .
// description. In this sample, it's not required to provide these callbacks.
// they are added just for illustration.
//
config.EvtChildListIdentificationDescriptionDuplicate =
Bus_EvtChildListIdentificationDescriptionDuplicate;
//
// This function pointer will be called when the framework needs to compare
// two identificaiton descriptions. If left NULL a call to RtlCompareMemory
// will be used to compare two identificaiton descriptions.
//
config.EvtChildListIdentificationDescriptionCompare =
Bus_EvtChildListIdentificationDescriptionCompare;
//
// This function pointer will be called when the framework needs to free a
// identification description. An implementation of this function is only
// necessary if the description contains dynamically allocated memory
// (by the driver writer) that needs to be freed. The actual identification
// description pointer itself will be freed by the framework.
//
config.EvtChildListIdentificationDescriptionCleanup =
Bus_EvtChildListIdentificationDescriptionCleanup;
//
// Tell the framework to use the built-in childlist to track the state
// of the device based on the configuration we just created.
//
WdfFdoInitSetDefaultChildListConfig(DeviceInit,
&config,
WDF_NO_OBJECT_ATTRIBUTES);
//
// Initialize attributes structure to specify size and accessor function
// for storing device context.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&fdoAttributes, FDO_DEVICE_DATA);
//
// Create a framework device object. In response to this call, framework
// creates a WDM deviceobject and attach to the PDO.
//
status = WdfDeviceCreate(&DeviceInit, &fdoAttributes, &device);
if (!NT_SUCCESS(status)) {
KdPrint(("Error creating device 0x%x\n", status));
return status;
}
//
// Configure a default queue so that requests that are not
// configure-fowarded using WdfDeviceConfigureRequestDispatching to goto
// other queues get dispatched here.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchParallel
);
queueConfig.EvtIoDeviceControl = Bus_EvtIoDeviceControl;
//
// By default, Static Driver Verifier (SDV) displays a warning if it
// doesn't find the EvtIoStop callback on a power-managed queue.
// The 'assume' below causes SDV to suppress this warning. If the driver
// has not explicitly set PowerManaged to WdfFalse, the framework creates
// power-managed queues when the device is not a filter driver. Normally
// the EvtIoStop is required for power-managed queues, but for this driver
// it is not needed b/c the driver doesn't hold on to the requests or
// forward them to other drivers. This driver completes the requests
// directly in the queue's handlers. If the EvtIoStop callback is not
// implemented, the framework waits for all driver-owned requests to be
// done before moving in the Dx/sleep states or before removing the
// device, which is the correct behavior for this type of driver.
// If the requests were taking an indeterminate amount of time to complete,
// or if the driver forwarded the requests to a lower driver/another stack,
// the queue should have an EvtIoStop/EvtIoResume.
//
__analysis_assume(queueConfig.EvtIoStop != 0);
status = WdfIoQueueCreate( device,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue );
__analysis_assume(queueConfig.EvtIoStop == 0);
if (!NT_SUCCESS(status)) {
KdPrint(("WdfIoQueueCreate failed status 0x%x\n", status));
return status;
}
//
// Get the device context.
//
//deviceData = FdoGetData(device);
//
// Create device interface for this device. The interface will be
// enabled by the framework when we return from StartDevice successfully.
// Clients of this driver will open this interface and send ioctls.
//
status = WdfDeviceCreateDeviceInterface(
device,
&GUID_DEVINTERFACE_BUSENUM_TOASTER,
NULL // No Reference String. If you provide one it will appended to the
); // symbolic link. Some drivers register multiple interfaces for the same device
// and use the reference string to distinguish between them
if (!NT_SUCCESS(status)) {
return status;
}
//
// This value is used in responding to the IRP_MN_QUERY_BUS_INFORMATION
// for the child devices. This is an optional information provided to
// uniquely idenitfy the bus the device is connected.
//
busInfo.BusTypeGuid = GUID_DEVCLASS_TOASTER;
busInfo.LegacyBusType = PNPBus;
busInfo.BusNumber = 0;
WdfDeviceSetBusInformationForChildren(device, &busInfo);
status = Bus_WmiRegistration(device);
if (!NT_SUCCESS(status)) {
return status;
}
//
// Check the registry to see if we need to enumerate child devices during
// start.
//
status = Bus_DoStaticEnumeration(device);
return status;
}
NTSTATUS
EvtDeviceAdd(
IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit
)
{
WDF_OBJECT_ATTRIBUTES attributes;
NTSTATUS status;
WDFDEVICE device;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
UNREFERENCED_PARAMETER(Driver);
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
pnpPowerCallbacks.EvtDevicePrepareHardware = EvtDevicePrepareHardware;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, DEVICE_CONTEXT);
status = WdfDeviceCreate(&DeviceInit, &attributes, &device);
if (!NT_SUCCESS(status)) {
KdPrint(("WdfDeviceCreate failed %!STATUS!\n", status));
return status;
}
status = WdfDeviceCreateDeviceInterface(device,
(LPGUID) &GUID_DEVINTERFACE_OSRUSBFX2,
NULL);// Reference String
if (!NT_SUCCESS(status)) {
KdPrint(("WdfDeviceCreateDeviceInterface failed %!STATUS!\n", status));
return status;
}
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchParallel);
ioQueueConfig.EvtIoDeviceControl = EvtIoDeviceControl;
ioQueueConfig.EvtIoRead = EvtIoRead;
ioQueueConfig.EvtIoWrite = EvtIoWrite;
//
// By default, Static Driver Verifier (SDV) displays a warning if it
// doesn't find the EvtIoStop callback on a power-managed queue.
// The 'assume' below causes SDV to suppress this warning.
// Please see 'final' step for implementation of EvtIoStop.
//
__analysis_assume(ioQueueConfig.EvtIoStop != 0);
status = WdfIoQueueCreate(device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
WDF_NO_HANDLE);
__analysis_assume(ioQueueConfig.EvtIoStop == 0);
if (!NT_SUCCESS(status)) {
KdPrint(("WdfIoQueueCreate failed %!STATUS!\n", status));
return status;
}
return status;
}
NTSTATUS
EchoQueueInitialize(
WDFDEVICE Device
)
/*++
Routine Description:
The I/O dispatch callbacks for the frameworks device object
are configured in this function.
A single default I/O Queue is configured for serial request
processing, and a driver context memory allocation is created
to hold our structure QUEUE_CONTEXT.
This memory may be used by the driver automatically synchronized
by the Queue's presentation lock.
The lifetime of this memory is tied to the lifetime of the I/O
Queue object, and we register an optional destructor callback
to release any private allocations, and/or resources.
Arguments:
Device - Handle to a framework device object.
Return Value:
NTSTATUS
--*/
{
WDFQUEUE queue;
NTSTATUS status;
PQUEUE_CONTEXT queueContext;
WDF_IO_QUEUE_CONFIG queueConfig;
WDF_OBJECT_ATTRIBUTES queueAttributes;
//
// Configure a default queue so that requests that are not
// configure-fowarded using WdfDeviceConfigureRequestDispatching to goto
// other queues get dispatched here.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchSequential
);
queueConfig.EvtIoRead = EchoEvtIoRead;
queueConfig.EvtIoWrite = EchoEvtIoWrite;
//
// Fill in a callback for destroy, and our QUEUE_CONTEXT size
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&queueAttributes, QUEUE_CONTEXT);
//
// Set synchronization scope on queue and have the timer to use queue as
// the parent object so that queue and timer callbacks are synchronized
// with the same lock.
//
queueAttributes.SynchronizationScope = WdfSynchronizationScopeQueue;
queueAttributes.EvtDestroyCallback = EchoEvtIoQueueContextDestroy;
status = WdfIoQueueCreate(
Device,
&queueConfig,
&queueAttributes,
&queue
);
if( !NT_SUCCESS(status) ) {
KdPrint(("WdfIoQueueCreate failed 0x%x\n",status));
return status;
}
// Get our Driver Context memory from the returned Queue handle
queueContext = QueueGetContext(queue);
queueContext->WriteMemory = NULL;
queueContext->Timer = NULL;
queueContext->CurrentRequest = NULL;
queueContext->CurrentStatus = STATUS_INVALID_DEVICE_REQUEST;
//
// Create the Queue timer
//
status = EchoTimerCreate(&queueContext->Timer, queue);
if (!NT_SUCCESS(status)) {
KdPrint(("Error creating timer 0x%x\n",status));
return status;
}
return status;
}
NTSTATUS
NonPnpDeviceAdd(
IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
Called by the DriverEntry to create a control-device. This call is
responsible for freeing the memory for DeviceInit.
Arguments:
DriverObject - a pointer to the object that represents this device
driver.
DeviceInit - Pointer to a driver-allocated WDFDEVICE_INIT structure.
Return Value:
STATUS_SUCCESS if initialized; an error otherwise.
--*/
{
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
WDF_FILEOBJECT_CONFIG fileConfig;
WDFQUEUE queue;
WDFDEVICE controlDevice;
DECLARE_CONST_UNICODE_STRING(ntDeviceName, NTDEVICE_NAME_STRING) ;
DECLARE_CONST_UNICODE_STRING(symbolicLinkName, SYMBOLIC_NAME_STRING) ;
UNREFERENCED_PARAMETER( Driver );
PAGED_CODE();
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_INIT,
"NonPnpDeviceAdd DeviceInit %p\n", DeviceInit);
//
// Set exclusive to TRUE so that no more than one app can talk to the
// control device at any time.
//
WdfDeviceInitSetExclusive(DeviceInit, TRUE);
WdfDeviceInitSetIoType(DeviceInit, WdfDeviceIoBuffered);
status = WdfDeviceInitAssignName(DeviceInit, &ntDeviceName);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "WdfDeviceInitAssignName failed %!STATUS!", status);
goto End;
}
WdfControlDeviceInitSetShutdownNotification(DeviceInit,
NonPnpShutdown,
WdfDeviceShutdown);
//
// Initialize WDF_FILEOBJECT_CONFIG_INIT struct to tell the
// framework whether you are interested in handling Create, Close and
// Cleanup requests that gets generated when an application or another
// kernel component opens an handle to the device. If you don't register
// the framework default behaviour would be to complete these requests
// with STATUS_SUCCESS. A driver might be interested in registering these
// events if it wants to do security validation and also wants to maintain
// per handle (fileobject) context.
//
WDF_FILEOBJECT_CONFIG_INIT(
&fileConfig,
NonPnpEvtDeviceFileCreate,
NonPnpEvtFileClose,
WDF_NO_EVENT_CALLBACK // not interested in Cleanup
);
WdfDeviceInitSetFileObjectConfig(DeviceInit,
&fileConfig,
WDF_NO_OBJECT_ATTRIBUTES);
//
// In order to support METHOD_NEITHER Device controls, or
// NEITHER device I/O type, we need to register for the
// EvtDeviceIoInProcessContext callback so that we can handle the request
// in the calling threads context.
//
WdfDeviceInitSetIoInCallerContextCallback(DeviceInit,
NonPnpEvtDeviceIoInCallerContext);
//
// Specify the size of device context
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes,
CONTROL_DEVICE_EXTENSION);
status = WdfDeviceCreate(&DeviceInit,
&attributes,
&controlDevice);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "WdfDeviceCreate failed %!STATUS!", status);
goto End;
}
//
// Create a symbolic link for the control object so that usermode can open
// the device.
//
status = WdfDeviceCreateSymbolicLink(controlDevice,
&symbolicLinkName);
if (!NT_SUCCESS(status)) {
//
// Control device will be deleted automatically by the framework.
//
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "WdfDeviceCreateSymbolicLink failed %!STATUS!", status);
goto End;
}
//
// Configure a default queue so that requests that are not
// configure-fowarded using WdfDeviceConfigureRequestDispatching to goto
// other queues get dispatched here.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchSequential);
ioQueueConfig.EvtIoRead = FileEvtIoRead;
ioQueueConfig.EvtIoWrite = FileEvtIoWrite;
ioQueueConfig.EvtIoDeviceControl = FileEvtIoDeviceControl;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
//
// Since we are using Zw function set execution level to passive so that
// framework ensures that our Io callbacks called at only passive-level
// even if the request came in at DISPATCH_LEVEL from another driver.
//
//attributes.ExecutionLevel = WdfExecutionLevelPassive;
//
// By default, Static Driver Verifier (SDV) displays a warning if it
// doesn't find the EvtIoStop callback on a power-managed queue.
// The 'assume' below causes SDV to suppress this warning. If the driver
// has not explicitly set PowerManaged to WdfFalse, the framework creates
// power-managed queues when the device is not a filter driver. Normally
// the EvtIoStop is required for power-managed queues, but for this driver
// it is not needed b/c the driver doesn't hold on to the requests or
// forward them to other drivers. This driver completes the requests
// directly in the queue's handlers. If the EvtIoStop callback is not
// implemented, the framework waits for all driver-owned requests to be
// done before moving in the Dx/sleep states or before removing the
// device, which is the correct behavior for this type of driver.
// If the requests were taking an indeterminate amount of time to complete,
// or if the driver forwarded the requests to a lower driver/another stack,
// the queue should have an EvtIoStop/EvtIoResume.
//
__analysis_assume(ioQueueConfig.EvtIoStop != 0);
status = WdfIoQueueCreate(controlDevice,
&ioQueueConfig,
&attributes,
&queue // pointer to default queue
);
__analysis_assume(ioQueueConfig.EvtIoStop == 0);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "WdfIoQueueCreate failed %!STATUS!", status);
goto End;
}
//
// Control devices must notify WDF when they are done initializing. I/O is
// rejected until this call is made.
//
WdfControlFinishInitializing(controlDevice);
End:
//
// If the device is created successfully, framework would clear the
// DeviceInit value. Otherwise device create must have failed so we
// should free the memory ourself.
//
if (DeviceInit != NULL) {
WdfDeviceInitFree(DeviceInit);
}
return status;
}
